fix(langgraph): computeFold falls back to the last human boundary so mid-turn folding works (#66)

The forward-only cut scan meant a long tool loop (protected tail all
ai/tool) could never fold: the trigger fired every cycle and computeFold
returned null every cycle, exactly when relief was needed. When no human
exists at/after the naive cut, the cut now falls back to the LAST
HumanMessage before it — keeps more than keepRecent (always safe), and the
retained history still opens on a human (nothing orphaned).

Author: IcculusC

.changeset/mid-turn-fold.md

@@ -0,0 +1,5 @@
+---
+"@harpua/langgraph": patch
+---
+
+`computeFold` can now fold mid-turn: when the protected tail is all ai/tool messages (a long tool loop) and no HumanMessage exists at/after the naive cut, the cut falls back to the LAST HumanMessage before it — keeping more than `keepRecent` (always safe) with the retained history still opening on a human. Previously the forward-only scan returned null every cycle exactly when relief was needed, so a token trigger fired forever while the whole tool loop rode at peak context.

packages/langgraph/src/__tests__/compaction-cut.spec.ts

@@ -35,3 +35,50 @@ describe("computeFold", () => {
     expect(computeFold(msgs, { keepRecent: 1, pin: (m) => (m as any).id === "h1" })).toBeNull();
   });
 });
+
+describe("mid-turn fold (walkie 012)", () => {
+  // A long tool loop: the protected tail is ALL ai/tool, so the forward scan
+  // finds no human and the fold used to return null every cycle — exactly the
+  // turns that need relief got none. The safe boundary sits BEHIND the
+  // window: the running turn's own HumanMessage.
+  function midTurn() {
+    const msgs: any[] = [
+      new HumanMessage({ id: "h1", content: "goal" }), // 0 pin
+      new AIMessage({ id: "a1", content: "ok" }),       // 1
+      new HumanMessage({ id: "h2", content: "old turn" }), // 2
+      new AIMessage({ id: "a2", content: "done" }),     // 3
+      new HumanMessage({ id: "h3", content: "design the board" }), // 4 running turn
+    ];
+    for (let i = 0; i < 6; i++) {
+      msgs.push(new AIMessage({ id: `loop-a${i}`, content: "", tool_calls: [{ name: "t", args: {}, id: `c${i}`, type: "tool_call" }] }));
+      msgs.push(new ToolMessage({ id: `loop-t${i}`, content: "res", tool_call_id: `c${i}` }));
+    }
+    return msgs; // 17 messages, last human at index 4
+  }
+
+  it("falls back to the LAST human at/before the naive cut when the tail is all ai/tool", () => {
+    // keepRecent=4 => naive cut at 13, no human at/after it. Backward
+    // fallback cuts at h3 @4: keeps MORE than keepRecent (safe), retained
+    // history opens on a human, folded span = h1..h3 exclusive.
+    const plan = computeFold(midTurn(), { keepRecent: 4, pin: (m) => (m as any).id === "h1" });
+    expect(plan).not.toBeNull();
+    expect(plan!.foldedSpan.map((m) => (m as any).id)).toEqual(["a1", "h2", "a2"]);
+    expect(plan!.removeIds).toEqual(["a1", "h2", "a2"]);
+  });
+
+  it("still returns null when the only human at/before the cut is the pinned head's neighbor", () => {
+    // Nothing foldable between head and the running turn.
+    const msgs: any[] = [
+      new HumanMessage({ id: "h1", content: "goal" }),
+      new HumanMessage({ id: "h2", content: "turn" }),
+      new AIMessage({ id: "a1", content: "x" }),
+      new ToolMessage({ id: "t1", content: "r", tool_call_id: "c" }),
+    ];
+    expect(computeFold(msgs, { keepRecent: 1, pin: (m) => (m as any).id === "h1" })).toBeNull();
+  });
+
+  it("prefers the forward boundary when one exists (between-turn behavior unchanged)", () => {
+    const plan = computeFold(convo(), { keepRecent: 3, pin: (m) => (m as any).id === "h1" });
+    expect(plan!.foldedSpan.map((m) => (m as any).id)).toEqual(["a1", "t1", "h2", "a2"]);
+  });
+});

packages/langgraph/src/middleware/compaction-cut.ts

@@ -27,6 +27,18 @@ export function computeFold(
   for (let i = naiveCut; i < n; i++) {
     if (isHumanMessage(messages[i]!)) { cut = i; break; }
   }
+  if (cut < 0) {
+    // Mid-turn: the protected tail is all ai/tool (a long tool loop), so no
+    // boundary exists at/after the naive cut — but one may sit BEHIND it:
+    // the running turn's own HumanMessage. Cutting there keeps MORE than
+    // keepRecent (always safe) and the retained history still opens on a
+    // human. Without this fallback exactly the turns that need relief get
+    // none — the trigger fires every cycle and the fold nulls every cycle
+    // while context rides at peak.
+    for (let i = naiveCut - 1; i > headIndex + 1; i--) {
+      if (isHumanMessage(messages[i]!)) { cut = i; break; }
+    }
+  }
   if (cut < 0 || cut <= headIndex + 1) return null; // nothing to fold safely
 
   const foldedSpan = messages.slice(headIndex + 1, cut);