@monotykamary/pi-vcc 0.4.0 → 0.5.0

package/__tests__/root-causes.test.ts

@@ -1,858 +0,0 @@
-/**
- * Litmus tests for "Cannot continue from message role: assistant" root causes.
- *
- * These tests verify the EXACT conditions under which the agent's
- * continue() would throw, and confirm our fixes prevent it.
- *
- * Root cause taxonomy:
- *
- *   RC1: After compaction, agent.state.messages has an assistant message
- *        as the last entry. The session's continue() call in the _runAgentPrompt
- *        while loop (or pre-prompt check) would throw.
- *
- *   RC2: After overflow compaction with willRetry=true, the error message
- *        removal in _runAutoCompaction checks lastMsg.stopReason === "error",
- *        but pi-vcc's buildOwnCut may produce a kept tail whose last message
- *        is NOT an error — it's a different assistant message (e.g., stopReason:
- *        "stop" or "toolUse"). The removal doesn't trigger, continue() sees
- *        an assistant last message, throws.
- *
- *   RC3: After threshold compaction, the session's _handlePostAgentRun while
- *        loop exits (returns false). But triggerInvisibleContinue() fires
- *        prompt([]) which starts a new agent run. If the session then tries
- *        to call continue() or prompt() (e.g., pre-prompt check or retry),
- *        it gets "Agent is already processing".
- *
- *   RC4: Both pi-retry and pi-vcc fire triggerInvisibleContinue() for the
- *        same compaction event. Their separate _continueInProgress mutexes
- *        don't cross-gate, so both attempt prompt([]). The second one
- *        gets "Agent is already processing" (caught, but wasteful).
- *        More critically: if the session's continue() wrapper is waiting on
- *        pi-vcc's mutex while pi-vcc's prompt([]) is running, the continue()
- *        eventually resumes and calls the original continue() which throws
- *        because the last message after prompt([]) is an assistant message.
- *
- *   RC5: The stopReason values in pi-ai are "stop" | "toolUse" | "length" |
- *        "error" | "aborted" — NOT "end_turn" / "tool_use" (Claude API names).
- *        Using the wrong string in guards means the gate never matches and
- *        triggerInvisibleContinue fires on every compaction (including clean
- *        ends).
- *
- *   RC6: Manual /compact should NOT auto-continue. After compaction, the user
- *        chose to compact. The agent may be idle. triggerInvisibleContinue
- *        would restart the agent loop against the user's intent.
- */
-
-import { describe, it, expect, beforeEach } from "vitest";
-import {
-  buildOwnCut,
-} from "../src/hooks/before-compact";
-import {
-  type MockEntry,
-  makeUserEntry,
-  makeAssistantEntry,
-  makeToolResultEntry,
-  makeCompactionEntry,
-  resetIds,
-  type ContextMessage,
-  userMsg,
-  assistantMsg,
-  toolResultMsg,
-  compactionSummaryMsg,
-  makeContextMessages,
-} from "./helpers";
-
-// ---------------------------------------------------------------------------
-// buildOwnCut — the compaction boundary logic
-// ---------------------------------------------------------------------------
-
-describe("buildOwnCut", () => {
-  beforeEach(resetIds);
-
-  it("keeps a tail from the last user message", () => {
-    const entries = [
-      makeUserEntry("u1"),
-      makeAssistantEntry("a1", "stop"),
-      makeUserEntry("u2"),
-      makeAssistantEntry("a2", "stop"),
-    ];
-    const result = buildOwnCut(entries);
-    expect(result.ok).toBe(true);
-    if (!result.ok) return;
-    // Summarizes u1 + a1, keeps u2 + a2
-    expect(result.messages).toHaveLength(2); // u1 + a1
-    expect(result.firstKeptEntryId).toBe(entries[2].id);
-  });
-
-  it("mid-cycle cut when only one user message (3+ live messages)", () => {
-    const entries = [
-      makeUserEntry("u1"),
-      makeAssistantEntry("a1", "stop"),
-      makeAssistantEntry("a1b", "stop"),
-    ];
-    const result = buildOwnCut(entries);
-    expect(result.ok).toBe(true);
-    if (!result.ok) return;
-    // Single user at idx 0 → mid-cycle boundary instead of compact-all
-    // But there are no toolResult messages, so no completed cycles → still compact-all
-    expect(result.compactAll).toBe(true);
-  });
-
-  it("cancels when no live messages", () => {
-    const result = buildOwnCut([]);
-    expect(result.ok).toBe(false);
-    if (result.ok) return;
-    expect(result.reason).toBe("no_live_messages");
-  });
-
-  it("cancels when too few live messages", () => {
-    const entries = [makeUserEntry("u1")];
-    const result = buildOwnCut(entries);
-    expect(result.ok).toBe(false);
-    if (result.ok) return;
-    expect(result.reason).toBe("too_few_live_messages");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// RC1: Compaction result produces assistant last message in context
-// ---------------------------------------------------------------------------
-
-describe("RC1: post-compaction context last message", () => {
-  /**
-   * After buildOwnCut compacts [u1, a1, u2, a2(stop)], the kept tail is
-   * [u2, a2]. After rebuild, the context is [compactionSummary, u2, a2].
-   * The LAST message is an assistant message.
-   *
-   * If continue() is called at this point, it throws.
-   */
-  it("kept tail ending with assistant message makes continue() impossible", () => {
-    const context = makeContextMessages(
-      compactionSummaryMsg("summary"),
-      userMsg("u2"),
-      assistantMsg("a2", "stop"),
-    );
-
-    const lastMsg = context[context.length - 1];
-    expect(lastMsg.role).toBe("assistant");
-    // This IS the condition that triggers "Cannot continue from message role: assistant"
-    // Fix: the session should strip or not call continue() in this case.
-  });
-
-  /**
-   * After buildOwnCut compacts [u1, a1(toolUse), toolResult, a2(stop)],
-   * the kept tail starts from u1 (or wherever the cut boundary is).
-   * If tail ends with assistant, same problem.
-   */
-  it("kept tail with toolUse assistant as last message is also blocked", () => {
-    const context = makeContextMessages(
-      compactionSummaryMsg("summary"),
-      userMsg("u2"),
-      assistantMsg("a2", "toolUse"),
-    );
-
-    const lastMsg = context[context.length - 1];
-    expect(lastMsg.role).toBe("assistant");
-    expect(lastMsg.stopReason).toBe("toolUse");
-  });
-
-  /**
-   * The ONLY case where continue() works after compaction is when the
-   * kept tail ends with a user or toolResult message.
-   */
-  it("kept tail ending with user message allows continue()", () => {
-    const context = makeContextMessages(
-      compactionSummaryMsg("summary"),
-      userMsg("u2"),
-    );
-
-    const lastMsg = context[context.length - 1];
-    expect(lastMsg.role).toBe("user");
-  });
-
-  it("kept tail ending with toolResult allows continue()", () => {
-    const context = makeContextMessages(
-      compactionSummaryMsg("summary"),
-      userMsg("u2"),
-      assistantMsg("a2", "toolUse"),
-      toolResultMsg("tc1", "result"),
-    );
-
-    const lastMsg = context[context.length - 1];
-    expect(lastMsg.role).toBe("toolResult");
-  });
-
-  /**
-   * Compact-all (firstKeptEntryId="") produces context with just
-   * compactionSummary — which is role "user". continue() works.
-   */
-  it("compact-all produces user-only context", () => {
-    const context = makeContextMessages(
-      compactionSummaryMsg("summary"),
-    );
-
-    const lastMsg = context[context.length - 1];
-    expect(lastMsg.role).toBe("user");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// RC2: Overflow compaction error removal mismatch
-// ---------------------------------------------------------------------------
-
-describe("RC2: overflow compaction error removal", () => {
-  /**
-   * After overflow compaction, _runAutoCompaction checks:
-   *   if (lastMsg?.role === "assistant" && lastMsg.stopReason === "error")
-   *     this.agent.state.messages = messages.slice(0, -1);
-   *
-   * This ONLY removes the last message if stopReason is "error".
-   * If the last message is a different assistant (e.g., stopReason "stop"
-   * or "toolUse"), it stays. continue() would throw.
-   *
-   * Scenario: Session has [u1, a1(stop), u2, a2(error)].
-   * pi-vcc cuts at u2 → kept tail: [u2, a2(error)].
-   * The error message IS the last → removal works → continue() OK.
-   *
-   * But what if: Session has [u1, a1(error), u2, a2(stop)].
-   * pi-vcc cuts at u2 → kept tail: [u2, a2(stop)].
-   * The last message is a2(stop), NOT an error → NO removal → continue() THROWS.
-   */
-  it("error removal only triggers for stopReason=error at tail", () => {
-    // Simulated context after compaction with assistant(stop) as last
-    const context = makeContextMessages(
-      compactionSummaryMsg("summary"),
-      userMsg("u2"),
-      assistantMsg("a2", "stop"), // NOT "error"
-    );
-
-    const lastMsg = context[context.length - 1];
-    const wouldRemove =
-      lastMsg.role === "assistant" && lastMsg.stopReason === "error";
-    expect(wouldRemove).toBe(false); // Removal doesn't fire!
-    // continue() would throw "Cannot continue from message role: assistant"
-  });
-
-  it("error removal works when error IS the last message", () => {
-    const context = makeContextMessages(
-      compactionSummaryMsg("summary"),
-      userMsg("u2"),
-      assistantMsg("a2", "error"),
-    );
-
-    const lastMsg = context[context.length - 1];
-    const wouldRemove =
-      lastMsg.role === "assistant" && lastMsg.stopReason === "error";
-    expect(wouldRemove).toBe(true); // Removal fires → after removal, last is user
-  });
-});
-
-// ---------------------------------------------------------------------------
-// RC5: stopReason value mapping
-// ---------------------------------------------------------------------------
-
-describe("RC5: stopReason string values", () => {
-  /**
-   * pi-ai StopReason type: "stop" | "toolUse" | "length" | "error" | "aborted"
-   *
-   * NOT the Claude API values: "end_turn" / "tool_use" / "max_tokens"
-   *
-   * Our invisible-continue gate must use the pi-ai values:
-   */
-  const PI_AI_STOP_REASONS = ["stop", "toolUse", "length", "error", "aborted"];
-  const WRONG_VALUES = ["end_turn", "tool_use", "max_tokens"];
-
-  it("pi-ai stopReason values are lowercase-first camelCase", () => {
-    expect(PI_AI_STOP_REASONS).toContain("stop");
-    expect(PI_AI_STOP_REASONS).toContain("toolUse");
-    expect(PI_AI_STOP_REASONS).toContain("length");
-    expect(PI_AI_STOP_REASONS).toContain("error");
-    expect(PI_AI_STOP_REASONS).toContain("aborted");
-  });
-
-  it("Claude API values are NOT valid pi-ai stopReasons", () => {
-    for (const wrong of WRONG_VALUES) {
-      expect(PI_AI_STOP_REASONS).not.toContain(wrong);
-    }
-  });
-
-  /**
-   * The invisible continue decision table with CORRECT values:
-   *
-   * stopReason | Continuation needed?
-   * -----------|---------------------
-   * stop       | NO (agent finished cleanly)
-   * toolUse    | YES (mid-tool cycle, compacted mid-task)
-   * length     | YES (hit max tokens, output truncated)
-   * error      | YES (API error, but pi-retry may handle)
-   * aborted    | NO (user cancelled)
-   */
-  it("correct invisible-continue decision table", () => {
-    const decisions: Record<string, boolean> = {
-      stop: false,
-      toolUse: true,
-      length: true,
-      error: true,
-      aborted: false,
-    };
-
-    // Verify the decisions match our intent
-    expect(decisions["stop"]).toBe(false);
-    expect(decisions["toolUse"]).toBe(true);
-    expect(decisions["length"]).toBe(true);
-    expect(decisions["error"]).toBe(true);
-    expect(decisions["aborted"]).toBe(false);
-  });
-
-  it("using 'end_turn' would NEVER match — always continues", () => {
-    const stopReasons = ["stop", "toolUse", "length", "error", "aborted"];
-    const matchesEndTurn = stopReasons.some((sr) => sr === "end_turn");
-    expect(matchesEndTurn).toBe(false);
-    // This was the original bug: checking === "end_turn" always fails,
-    // so triggerInvisibleContinue always fires.
-  });
-});
-
-// ---------------------------------------------------------------------------
-// RC6: Manual /compact should NOT auto-continue
-// ---------------------------------------------------------------------------
-
-describe("RC6: manual compact should not auto-continue", () => {
-  /**
-   * When the user runs /compact explicitly, they chose to compact.
-   * After compaction, the agent should NOT auto-continue.
-   *
-   * The session_compact event doesn't distinguish manual vs auto.
-   * We need to track whether the compaction was user-initiated.
-   *
-   * Currently, lastCompactWasPiVcc tracks /pi-vcc command, but
-   * /compact is NOT tracked separately.
-   */
-  it("session_compact event does not carry reason (manual/overflow/threshold)", () => {
-    // The event payload is: { compactionEntry, fromExtension }
-    // No "reason" field — we can't distinguish manual from auto
-    const eventShape = {
-      type: "session_compact" as const,
-      compactionEntry: {} as any,
-      fromExtension: false,
-    };
-    expect(
-      Object.keys(eventShape).includes("reason"),
-    ).toBe(false);
-  });
-
-  /**
-   * For manual /compact, the agent is always idle before compaction.
-   * The last assistant message always has stopReason !== "toolUse"
-   * (because if the agent were mid-task, it would be running).
-   *
-   * With our fix that checks stopReason === "stop" → no continue,
-   * manual /compact AFTER a clean finish correctly does NOT continue.
-   */
-  it("after user-initiated /compact, last stopReason is typically 'stop'", () => {
-    const lastAssistant = assistantMsg("done", "stop");
-    const shouldContinue = lastAssistant.stopReason !== "stop"
-      && lastAssistant.stopReason !== "aborted";
-    expect(shouldContinue).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// The comprehensive fix: strip trailing assistant from rebuilt context
-// ---------------------------------------------------------------------------
-
-describe("proposed fix: strip trailing assistant messages after compaction", () => {
-  /**
-   * The root fix is to ensure that after compaction, agent.state.messages
-   * NEVER ends with an assistant message. This means:
-   *
-   * 1. After rebuildSessionContext, check the tail.
-   * 2. If the last message is an assistant that was NOT in-progress
-   *    (stopReason: "stop", "error", "aborted"), remove it from context.
-   *    The assistant message is still in the session log — it's not lost.
-   *    But the rebuilt context used for the next LLM call should end
-   *    with a user/toolResult message so continue() works.
-   *
-   * 3. If the last assistant has stopReason "toolUse" or "length",
-   *    the agent was mid-task. DON'T strip — triggerInvisibleContinue
-   *    will handle resumption via prompt([]).
-   *
-   * Actually, even for toolUse/length, stripping and relying on
-   * triggerInvisibleContinue is cleaner. prompt([]) doesn't care
-   * about the last message role — it just sends the current context.
-   * And after stripping, continue() would also work if needed.
-   *
-   * But stripping removes context! The LLM wouldn't see the last
-   * assistant response. This could lose information about what the
-   * agent was doing.
-   *
-   * Alternative: instead of stripping, ensure that whenever we would
-   * call continue() after compaction, we call prompt([]) instead.
-   * This is essentially what our triggerInvisibleContinue does.
-   *
-   * The REAL fix is to not catch-and-swallow, but to PREVENT the
-   * continue() call entirely when the context is in an invalid state.
-   * This means: our monkey-patched continue() should detect the
-   * assistant-last-message case and call prompt([]) INSTEAD of
-   * throwing (or just returning void).
-   */
-
-  it("monkey-patched continue() should convert to prompt([]) for assistant last message", () => {
-    const context = makeContextMessages(
-      compactionSummaryMsg("summary"),
-      userMsg("u2"),
-      assistantMsg("a2", "stop"),
-    );
-
-    const lastMsg = context[context.length - 1];
-
-    // Instead of throwing "Cannot continue from message role: assistant",
-    // the patched continue() should detect this and call prompt([]).
-    if (lastMsg.role === "assistant") {
-      // The fix: instead of throwing, we call prompt([]) which works
-      // with any last message role.
-      const shouldConvertToPrompt = lastMsg.role === "assistant";
-      expect(shouldConvertToPrompt).toBe(true);
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// buildOwnCut — context ending positions
-// ---------------------------------------------------------------------------
-
-describe("buildOwnCut tail ending analysis", () => {
-  beforeEach(resetIds);
-
-  /**
-   * CRITICAL INSIGHT: buildOwnCut always produces a kept tail that
-   * starts from a user message. The tail includes everything from
-   * that user message to the end. If the session had a normal
-   * user→assistant→user→assistant pattern, the tail ends with
-   * an assistant message.
-   *
-   * This means: for any non-trivial compaction, the rebuilt context
-   * will ALWAYS end with an assistant message (unless the tail ends
-   * with toolResult).
-   */
-
-  it("typical conversation tail ends with assistant (stop)", () => {
-    const entries = [
-      makeUserEntry("task"),
-      makeAssistantEntry("working...", "stop"),
-      makeUserEntry("continue"),
-      makeAssistantEntry("done", "stop"),
-    ];
-    const result = buildOwnCut(entries);
-    expect(result.ok).toBe(true);
-    if (!result.ok) return;
-
-    // Kept tail starts from entries[2] (user "continue")
-    const firstKeptIdx = entries.findIndex(e => e.id === result.firstKeptEntryId);
-    expect(firstKeptIdx).toBe(2);
-
-    // The tail is entries[2:] = [user, assistant(stop)]
-    // So rebuilt context = [compactionSummary, user, assistant]
-    // Last message: assistant → continue() THROWS
-    const tail = entries.slice(firstKeptIdx);
-    const lastEntry = tail[tail.length - 1];
-    expect(lastEntry.message?.role).toBe("assistant");
-  });
-
-  it("tool-result ending is safe", () => {
-    const entries = [
-      makeUserEntry("task"),
-      makeAssistantEntry("working...", "toolUse"),
-      makeToolResultEntry("tc1", "result"),
-    ];
-    const result = buildOwnCut(entries);
-    expect(result.ok).toBe(true);
-    if (!result.ok) return;
-
-    // Single user + tool chain → compact-all (firstKeptEntryId = "")
-    if (result.compactAll) {
-      expect(result.firstKeptEntryId).toBe("");
-      // compact-all context = [compactionSummary] → continue() OK
-    }
-  });
-
-  it("conversation with tool calls: tail often ends with assistant", () => {
-    const entries = [
-      makeUserEntry("task"),
-      makeAssistantEntry("let me check", "toolUse"),
-      makeToolResultEntry("tc1", "found it"),
-      makeAssistantEntry("here's the answer", "stop"),
-      makeUserEntry("thanks"),
-      makeAssistantEntry("you're welcome", "stop"),
-    ];
-    const result = buildOwnCut(entries);
-    expect(result.ok).toBe(true);
-    if (!result.ok) return;
-
-    // Cut at last user message: entries[4] (user "thanks")
-    const firstKeptIdx = entries.findIndex(e => e.id === result.firstKeptEntryId);
-    const tail = entries.slice(firstKeptIdx);
-    const lastEntry = tail[tail.length - 1];
-    expect(lastEntry.message?.role).toBe("assistant");
-    // This tail ends with assistant → continue() throws
-  });
-
-  /**
-   * THE FUNDAMENTAL ISSUE: buildOwnCut's task-boundary logic keeps
-   * the tail from last user message onwards. This tail almost always
-   * ends with an assistant message (the response to that user message).
-   *
-   * After compaction, the rebuilt context includes this tail,
-   * so agent.state.messages ends with an assistant message.
-   *
-   * This means ANY call to continue() after compaction WILL throw
-   * "Cannot continue from message role: assistant" — unless we
-   * either:
-   * (a) Strip the trailing assistant message(s) from the context
-   * (b) Replace continue() calls with prompt([]) calls
-   * (c) Have the monkey-patched continue() fall back to prompt([])
-   *     when it detects an assistant last message
-   */
-});
-
-// ---------------------------------------------------------------------------
-// Monkey-patch behavior: current vs proposed
-// ---------------------------------------------------------------------------
-
-describe("continue() monkey-patch: catch vs convert", () => {
-  /**
-   * PREVIOUS BEHAVIOR (all three extensions):
-   *   continue() catches "Cannot continue from message role: assistant"
-   *   and swallows the error (returns void).
-   *   PROBLEM: the agent doesn't actually continue. The while loop
-   *   exits. The task is left incomplete.
-   *
-   * NEW BEHAVIOR (pi-vcc):
-   *   continue() catches the error and FALLS BACK to prompt([])
-   *   when the last assistant stopReason is NOT "stop" or "aborted".
-   *   This actually starts the agent loop, so the agent continues
-   *   processing. The while loop in _runAgentPrompt gets another
-   *   iteration because prompt([]) runs the agent (which emits
-   *   agent_end, which sets _lastAssistantMessage).
-   */
-
-  it("swallowing the error results in dead agent loop (old behavior)", () => {
-    const context = makeContextMessages(
-      compactionSummaryMsg("summary"),
-      userMsg("u2"),
-      assistantMsg("a2", "stop"),
-    );
-
-    // After compaction, _handlePostAgentRun returns false.
-    // The while loop exits. No continue() is called.
-    // BUT: if it WERE called, the OLD monkey-patch would swallow the error.
-    // The agent loop exits without continuing.
-    const lastMsg = context[context.length - 1];
-    const wouldSwallow = lastMsg.role === "assistant";
-    expect(wouldSwallow).toBe(true);
-    // Result: agent stops. Task incomplete if mid-tool-cycle.
-  });
-
-  /**
-   * The fix: instead of swallowing, convert continue() → prompt([])
-   * when the last assistant was mid-task.
-   */
-  it("new: continue() falls back to prompt([]) for toolUse tail", () => {
-    const context = makeContextMessages(
-      compactionSummaryMsg("summary"),
-      userMsg("u2"),
-      assistantMsg("a2", "toolUse"),
-    );
-
-    const lastMsg = context[context.length - 1];
-    const shouldConvertToPrompt = lastMsg.role === "assistant"
-      && lastMsg.stopReason !== "stop"
-      && lastMsg.stopReason !== "aborted";
-    expect(shouldConvertToPrompt).toBe(true);
-    // prompt([]) works regardless of last message role.
-    // The agent picks up where it left off.
-  });
-
-  it("new: continue() falls back to prompt([]) for length tail", () => {
-    const context = makeContextMessages(
-      compactionSummaryMsg("summary"),
-      userMsg("u2"),
-      assistantMsg("a2", "length"),
-    );
-
-    const lastMsg = context[context.length - 1];
-    const shouldConvertToPrompt = lastMsg.role === "assistant"
-      && lastMsg.stopReason !== "stop"
-      && lastMsg.stopReason !== "aborted";
-    expect(shouldConvertToPrompt).toBe(true);
-  });
-
-  /**
-   * For stopReason "stop", we should NOT convert to prompt([]).
-   * The agent finished cleanly. prompt([]) would restart it unnecessarily.
-   * The continue() return gives void, the while loop exits naturally.
-   */
-  it("new: NO fallback for stopReason=stop (agent finished cleanly)", () => {
-    const context = makeContextMessages(
-      compactionSummaryMsg("summary"),
-      userMsg("u2"),
-      assistantMsg("a2", "stop"),
-    );
-
-    const lastMsg = context[context.length - 1];
-    const shouldConvertToPrompt = lastMsg.role === "assistant"
-      && lastMsg.stopReason !== "stop"
-      && lastMsg.stopReason !== "aborted";
-    expect(shouldConvertToPrompt).toBe(false);
-    // Don't auto-continue after clean stop.
-  });
-
-  /**
-   * For stopReason "aborted" (user cancel), also don't auto-continue.
-   */
-  it("new: NO fallback for stopReason=aborted (user cancelled)", () => {
-    const context = makeContextMessages(
-      compactionSummaryMsg("summary"),
-      userMsg("u2"),
-      assistantMsg("a2", "aborted"),
-    );
-
-    const lastMsg = context[context.length - 1];
-    const shouldConvertToPrompt = lastMsg.role === "assistant"
-      && lastMsg.stopReason !== "stop"
-      && lastMsg.stopReason !== "aborted";
-    expect(shouldConvertToPrompt).toBe(false);
-  });
-
-  /**
-   * For stopReason "error", don't convert — pi-retry handles error retries.
-   * Falling back to prompt([]) here would race pi-retry's own triggerInvisibleContinue.
-   */
-  it("new: NO fallback for stopReason=error (pi-retry handles it)", () => {
-    const context = makeContextMessages(
-      compactionSummaryMsg("summary"),
-      userMsg("u2"),
-      assistantMsg("a2", "error"),
-    );
-
-    const lastMsg = context[context.length - 1];
-    // pi-vcc should NOT fire invisible continue for errors.
-    // pi-retry already fires triggerInvisibleContinue from its agent_end handler.
-    // Both firing would race prompt([]) → wasted or duplicate runs.
-    const piVccShouldFire = lastMsg.stopReason !== "stop"
-      && lastMsg.stopReason !== "aborted"
-      && lastMsg.stopReason !== "error"; // KEY: skip error
-    expect(piVccShouldFire).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Pre-prompt compaction race condition
-// ---------------------------------------------------------------------------
-
-describe("RC3: pre-prompt compaction race with triggerInvisibleContinue", () => {
-  /**
-   * When the user sends a message and the pre-prompt check triggers
-   * compaction, the flow in session.prompt() is:
-   *
-   *   1. _checkCompaction() → compaction runs
-   *   2. session_compact fires → pi-vcc calls triggerInvisibleContinue()
-   *   3. _checkCompaction returns false
-   *   4. Session builds user message
-   *   5. Session calls _runAgentPrompt(messages) → agent.prompt(messages)
-   *
-   * The triggerInvisibleContinue() from step 2 is fire-and-forget.
-   * It awaits waitForIdle() + 50ms sleep, then calls prompt([]).
-   *
-   * If step 5's agent.prompt() is called BEFORE the 50ms sleep expires,
-   * the user message takes priority. triggerInvisibleContinue's prompt([])
-   * would fail with "Agent is already processing" (caught, harmlessly).
-   *
-   * If the 50ms sleep expires BEFORE step 5, triggerInvisibleContinue's
-   * prompt([]) starts first. Then step 5's agent.prompt() fails with
-   * "Agent is already processing" — and this is NOT caught by our
-   * monkey-patch because it's agent.prompt(), not agent.continue().
-   */
-  it("agent.prompt() also throws for busy agent, but is NOT monkey-patched", () => {
-    // agent.prompt() checks: if (this.activeRun) throw "Agent is already processing a prompt."
-    // Our monkey-patches only cover continue(), not prompt().
-    // If triggerInvisibleContinue's prompt([]) races the session's prompt(),
-    // the session's prompt() throws — and this error IS visible to the user.
-    const promptThrowsForBusyAgent = true;
-    expect(promptThrowsForBusyAgent).toBe(true);
-  });
-
-  /**
-   * Fix: triggerInvisibleContinue should check if the session is about
-   * to send a new prompt. If so, skip the invisible continue — the
-   * session will handle continuation naturally.
-   *
-   * More precisely: the session_compact handler should NOT call
-   * triggerInvisibleContinue when the compaction was triggered from
-   * the pre-prompt check or from manual /compact. Invisible continue
-   * is ONLY appropriate for auto-threshold compaction during an
-   * active agent run.
-   *
-   * Since session_compact doesn't carry a "reason" field, we need
-   * another way to distinguish. Options:
-   *
-   * A) Track compaction reason in a module-level variable, set by
-   *    session_before_compact (which DOES receive customInstructions
-   *    and other context).
-   *
-   * B) Only fire invisible continue when _handlePostAgentRun would
-   *    return false AND the agent was mid-task. This is our current
-   *    approach (check last assistant stopReason in session_compact).
-   *
-   * C) Set a flag when the session is about to send a prompt, and
-   *    check it in triggerInvisibleContinue.
-   */
-  it("only auto-threshold during active run needs invisible continue", () => {
-    // Scenarios:
-    const scenarios = [
-      {
-        name: "auto-threshold, mid-task (toolUse)",
-        shouldContinueInvisibly: true,
-      },
-      {
-        name: "auto-threshold, clean end (stop)",
-        shouldContinueInvisibly: false,
-      },
-      {
-        name: "manual /compact",
-        shouldContinueInvisibly: false,
-      },
-      {
-        name: "pre-prompt threshold",
-        shouldContinueInvisibly: false,
-      },
-      {
-        name: "overflow (willRetry=true)",
-        shouldContinueInvisibly: false, // handled by willRetry
-      },
-    ];
-
-    for (const s of scenarios) {
-      expect(typeof s.shouldContinueInvisibly).toBe("boolean");
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// RC4: Dual trigger from pi-retry + pi-vcc
-// ---------------------------------------------------------------------------
-
-describe("RC4: both extensions fire for same compaction", () => {
-  /**
-   * When an overflow error triggers compaction:
-   * - pi-retry sees agent_end with stopReason: "error" → fires triggerInvisibleContinue()
-   * - pi-vcc sees session_compact with last assistant stopReason: "error"
-   *
-   * With the fix: pi-vcc now SKIPS invisible continue for stopReason "error",
-   * so only pi-retry fires. No duplicate run, no race.
-   */
-  it("pi-vcc defers to pi-retry for error retries (session_compact)", () => {
-    const lastAssistantStopReason = "error";
-    // Fixed: for stopReason "error", pi-vcc's session_compact handler returns early
-    // and does NOT call triggerInvisibleContinue
-    const piVccShouldFireFromSessionCompact = lastAssistantStopReason !== "stop"
-      && lastAssistantStopReason !== "aborted"
-      && lastAssistantStopReason !== "error"; // KEY: skip error
-    expect(piVccShouldFireFromSessionCompact).toBe(false);
-  });
-
-  /**
-   * But pi-vcc's continue() monkey-patch STILL needs to handle the case
-   * where pi-retry is also installed. The continue() patch chain:
-   * pi-vcc → pi-retry → original
-   *
-   * If pi-retry is driving (its _continueInProgress is true), pi-vcc's
-   * patch passes through (its own mutex is false). pi-retry's patch
-   * waits on its mutex. This is correct.
-   */
-  it("pi-vcc continue() patch chains correctly with pi-retry", () => {
-    // The chain is: pi-vcc → pi-retry → original
-    // If pi-retry is driving, its mutex blocks, not pi-vcc's
-    const piVccMutex = false;
-    const piRetryMutex = true;
-    // Session's continue() enters pi-vcc's wrapper → mutex not set → passes through
-    // Enters pi-retry's wrapper → mutex set → waits
-    expect(piVccMutex).toBe(false);
-    expect(piRetryMutex).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// RC7: Double continuation from continue() fallback after triggerInvisibleContinue
-// ---------------------------------------------------------------------------
-
-describe("RC7: continue() fallback races triggerInvisibleContinue", () => {
-  /**
-   * GAP: When both pi-retry and pi-vcc are installed, overflow compaction
-   * creates a race:
-   *
-   * 1. pi-retry's agent_end handler fires triggerInvisibleContinue()
-   *    (sets _continueInProgress = true, schedules async prompt([]))
-   * 2. _handlePostAgentRun returns true (willRetry)
-   * 3. Session's while loop calls continue()
-   * 4. pi-retry's wrapper: blocked on _continueInProgress
-   * 5. triggerInvisibleContinue() runs prompt([]) → agent runs → completes
-   * 6. _continueInProgress = false
-   * 7. continue() wrapper unblocks → calls original → throws
-   *    "Cannot continue from message role: assistant"
-   *    (because prompt([]) just added a new assistant message!)
-   * 8. Wrapper catches, checks stopReason:
-   *    - "stop" → swallows ✓ (no double run)
-   *    - "toolUse" → falls back to prompt([]) AGAIN ⚠️ DOUBLE CONTINUATION!
-   *
-   * The double continuation is wasteful and could cause duplicate tool calls.
-   * Fix: the continue() fallback should detect that triggerInvisibleContinue
-   * just ran (by checking a _justContinued flag or timestamp) and skip
-   * the fallback in that case.
-   */
-  it("after triggerInvisibleContinue completes, continue() sees assistant last message", () => {
-    // After triggerInvisibleContinue's prompt([]) runs:
-    const context = makeContextMessages(
-      compactionSummaryMsg("summary"),
-      userMsg("u2"),
-      assistantMsg("a2", "toolUse"), // produced by the first prompt([])
-    );
-
-    const lastMsg = context[context.length - 1];
-    expect(lastMsg.role).toBe("assistant");
-    expect(lastMsg.stopReason).toBe("toolUse");
-    // continue() would try to fall back to prompt([]) AGAIN
-  });
-
-  it("if first prompt([]) produced stop, no double continuation", () => {
-    const context = makeContextMessages(
-      compactionSummaryMsg("summary"),
-      userMsg("u2"),
-      assistantMsg("a2", "stop"), // produced by the first prompt([])
-    );
-
-    const lastMsg = context[context.length - 1];
-    // The continue() fallback checks: stopReason !== "stop" → false → swallows
-    const shouldFallBack = lastMsg.role === "assistant"
-      && lastMsg.stopReason !== "stop"
-      && lastMsg.stopReason !== "aborted";
-    expect(shouldFallBack).toBe(false);
-  });
-
-  it("fix: track last invisible-continue completion to skip fallback", () => {
-    // Proposed approach: set a timestamp when triggerInvisibleContinue
-    // completes. The continue() fallback checks this timestamp —
-    // if it was set within the last 500ms, another prompt([]) just ran,
-    // so skip the fallback (the continuation was already handled).
-    //
-    // Alternative approach: use a shared _justContinued flag that
-    // triggerInvisibleContinue sets and continue() checks+clears.
-    //
-    // Either way, the key insight: the fallback should NOT fire when
-    // triggerInvisibleContinue just completed, because the agent already
-    // continued.
-    const justContinuedTimestamp = Date.now() - 100; // 100ms ago
-    const shouldSkipFallback = Date.now() - justContinuedTimestamp < 500;
-    expect(shouldSkipFallback).toBe(true);
-  });
-});