pi-invisible-continue 0.2.0 → 0.2.2

package/README.md

@@ -60,7 +60,7 @@ User types "/continue"
 
 ### Trade-off: bypasses AgentSession
 
-`agent.prompt([])` is called on the `Agent` directly, bypassing `AgentSession._runAgentPrompt()`. This means auto-retry on errors and auto-compaction are not triggered after a `/continue`. For a manual command where the user explicitly said "keep going," this is acceptable — they can always `/continue` again.
+`agent.prompt([])` is called on the `Agent` directly, bypassing `AgentSession._runAgentPrompt()`. This means auto-compaction is not triggered after a `/continue`. Auto-retry is not a concern — [pi-retry](https://github.com/monotykamary/pi-retry) covers that gap by listening for `agent_end` events and re-triggering the loop on errors. Since the agent still emits events through `AgentSession`'s subscriber, pi-retry's handlers fire normally even after an `agent.prompt([])` continuation.
 
 ---
 

package/continue.ts

@@ -9,19 +9,24 @@ import {
  * pi-invisible-continue — resume the agentic loop without the LLM seeing any new prompt.
  *
  * Strategy:
- *   - Monkey-patch Agent.prototype.prompt to capture the Agent instance
+ *   - Monkey-patch Agent.prototype.subscribe to capture the Agent instance
  *   - /continue calls agent.prompt([]) directly, starting a fresh agent loop
  *     with an empty prompt — no message is injected into context at all
  *   - The LLM receives the exact same message list it had before
  *   - No session JSONL artifact, no convertToLlm involvement, no filter needed
  *
- * This bypasses AgentSession._runAgentPrompt, so auto-retry and auto-compaction
- * are not triggered after a manual /continue. The user can always /continue again.
+ * This bypasses AgentSession._runAgentPrompt, so auto-compaction is not
+ * triggered after a manual /continue. Auto-retry is not a concern — pi-retry
+ * covers that gap via its agent_end handler, which still fires because the
+ * agent's processEvents propagates to AgentSession's subscriber normally.
  */
 
 // Capture the live Agent instance when AgentSession subscribes to it.
 // subscribe() is called during AgentSession construction — fires on both
 // fresh sessions and session resumes, unlike prompt().
+//
+// Chain the previous patch (if pi-retry or pi-vcc already patched it)
+// so all extensions can coexist.
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 let _agent: Agent | null = null;
 const _origSubscribe = Agent.prototype.subscribe as (this: Agent, ...args: any[]) => any;
@@ -30,6 +35,68 @@ Agent.prototype.subscribe = function (this: Agent, ...args: any[]) {
   return _origSubscribe.apply(this, args);
 };
 
+// Mutex: only one invisible continue may be in-flight at a time.
+// Without this, concurrent /continue (or /continue during pi-retry/pi-vcc
+// auto-continuation) race through waitForIdle() and both call prompt([]),
+// producing "Agent is already processing".
+let _continueInProgress = false;
+
+// Monkey-patch continue() so the session's built-in loop cooperates with
+// our mutex AND can convert the "Cannot continue from assistant" error
+// into a prompt([]) call when the agent was mid-task.
+// Without this, the session's continue() would throw when the last message
+// is an assistant (common after compaction), and the agent loop would die
+// leaving mid-task work unfinished.
+//
+// When continue() throws "Cannot continue from message role: assistant":
+// - stopReason "stop" → agent finished cleanly, don't continue
+// - stopReason "aborted" → user cancelled, don't continue
+// - stopReason "error" → pi-retry handles errors, don't race it
+// - stopReason "toolUse" or "length" → mid-task, fall back to prompt([])
+//
+// Chains the previous patch (pi-retry, pi-vcc) so all mutexes are respected.
+const _origContinue = Agent.prototype.continue;
+Agent.prototype.continue = function (this: Agent) {
+  const self = this;
+  return (async (): Promise<void> => {
+    while (_continueInProgress) {
+      await new Promise(r => setTimeout(r, 10));
+    }
+    try {
+      await _origContinue.call(self);
+    } catch (e: any) {
+      const msg = e?.message ?? '';
+      if (msg.includes('Cannot continue from message role') ||
+          msg.includes('Cannot continue from an assistant message')) {
+        // Check stopReason — only continue if the agent was mid-task
+        const lastMsg = self.state.messages[self.state.messages.length - 1];
+        if (lastMsg?.role === 'assistant' &&
+            lastMsg.stopReason !== 'stop' &&
+            lastMsg.stopReason !== 'aborted' &&
+            lastMsg.stopReason !== 'error') {
+          // Agent was mid-task — fall back to prompt([])
+          if (!_continueInProgress) {
+            _continueInProgress = true;
+            try {
+              await self.prompt([]);
+            } catch {
+              // Agent already processing or other transient error
+            } finally {
+              _continueInProgress = false;
+            }
+          }
+        }
+        // For stop/aborted/error: return void, the session loop exits naturally
+        return;
+      }
+      if (msg.includes('Agent is already processing')) {
+        return;
+      }
+      throw e;
+    }
+  })();
+};
+
 export default function (pi: ExtensionAPI) {
   pi.registerCommand("continue", {
     description: CONTINUE_COMMAND_DESCRIPTION,
@@ -37,6 +104,10 @@ export default function (pi: ExtensionAPI) {
       await runContinueCommand(ctx, args);
     },
   });
+
+  pi.on("session_start", () => {
+    _continueInProgress = false;
+  });
 }
 
 async function runContinueCommand(
@@ -82,5 +153,25 @@ async function runContinueCommand(
     await ctx.waitForIdle();
   }
 
-  await _agent.prompt([]);
+  // Guard: if pi-retry or pi-vcc already has an invisible continue in-flight,
+  // skip — their prompt([]) will resume the loop.
+  if (_continueInProgress) {
+    ctx.ui.notify(
+      "pi-invisible-continue: Another invisible continue is already in progress.",
+      "info",
+    );
+    return;
+  }
+  _continueInProgress = true;
+
+  try {
+    await _agent.waitForIdle();
+    try {
+      await _agent.prompt([]);
+    } catch {
+      // Agent is already processing — something else is driving.
+    }
+  } finally {
+    _continueInProgress = false;
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-invisible-continue",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Invisible session continuation for pi — resume the agentic loop without sending ANY prompt the LLM can see",
   "type": "module",
   "author": "Tom X Nguyen",