pi-invisible-continue 0.3.0 → 0.3.1

package/continue.ts

@@ -1,4 +1,5 @@
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { Agent } from "@earendil-works/pi-agent-core";
 import {
   CONTINUE_COMMAND_DESCRIPTION,
   getLastAssistantMessageText,
@@ -8,45 +9,125 @@ import {
  * pi-invisible-continue — resume the agentic loop without the LLM seeing any new prompt.
  *
  * Strategy:
- *   - Use pi.sendMessage() with triggerTurn: true to start a new agent turn
- *   - The message uses role: "custom" which is filtered by convertToLlm(),
- *     so the LLM receives the exact same message list it had before
- *   - This goes through AgentSession._runAgentPrompt, so auto-compaction,
- *     auto-retry, and other session lifecycle features work correctly
- *   - No prototype monkey-patching needed — no fragile Agent import, no
- *     module duplication issues
+ *   - 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
  *
- * Why not agent.prompt([])?
- *   The previous approach monkey-patched Agent.prototype.subscribe to capture
- *   the Agent instance, then called agent.prompt([]) directly. This broke when
- *   the extension's import of Agent resolved to a different class (from the
- *   package's own node_modules/@earendil-works/pi-agent-core@0.75.4) than the
- *   one AgentSession uses (from pi's bundled 0.79.1). The subscribe patch was
- *   applied to the wrong prototype, so the agent was never captured.
+ * 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.
  *
- *   The new approach avoids this entirely by using the extension API's
- *   sendMessage() with triggerTurn: true, which is resolved at runtime by the
- *   AgentSession and doesn't depend on importing Agent at all.
+ * Module resolution:
+ *   The Agent class is imported from @earendil-works/pi-agent-core.
+ *   This package does NOT list pi-agent-core as a devDependency — there is
+ *   no local node_modules copy. When jiti loads this extension, its alias
+ *   system rewrites the import specifier to pi's bundled copy, so the
+ *   subscribe/continue patches apply to the SAME Agent class that
+ *   AgentSession uses. Previously, a local node_modules/@earendil-works/pi-agent-core
+ *   caused jiti to resolve the import to a different class — patching the
+ *   wrong prototype and leaving _agent permanently null.
  */
 
+// 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;
+Agent.prototype.subscribe = function (this: Agent, ...args: any[]) {
+  _agent = this;
+  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;
 
+// Timestamp of the last completed invisible continue.
+// Used to avoid double continuation when continue() unblocks after
+// triggerInvisibleContinue just ran.
+let _lastInvisibleContinueTime = 0;
+
+// 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([])
+          // Guard: if an invisible continue just completed, don't double-run
+          if (!_continueInProgress && Date.now() - _lastInvisibleContinueTime > 500) {
+            _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,
     handler: async (args, ctx) => {
-      await runContinueCommand(pi, ctx, args);
+      await runContinueCommand(ctx, args);
     },
   });
 
   pi.on("session_start", () => {
     _continueInProgress = false;
+    _lastInvisibleContinueTime = 0;
   });
 }
 
 async function runContinueCommand(
-  pi: ExtensionAPI,
   ctx: ExtensionCommandContext,
   args: string,
 ): Promise<void> {
@@ -57,6 +138,7 @@ async function runContinueCommand(
       [
         "pi-invisible-continue status:",
         `  Agent idle: ${idle ? "yes" : "no"}`,
+        `  Captured agent: ${_agent ? "yes" : "no"}`,
         `  Last assistant: ${last ?? "(none)"}`.slice(0, 120),
       ].join("\n"),
       "info",
@@ -76,12 +158,20 @@ async function runContinueCommand(
     return;
   }
 
+  if (!_agent) {
+    ctx.ui.notify(
+      "pi-invisible-continue: Agent instance not captured. Internal error?",
+      "warning",
+    );
+    return;
+  }
+
   if (!ctx.isIdle()) {
     await ctx.waitForIdle();
   }
 
   // Guard: if pi-retry or pi-vcc already has an invisible continue in-flight,
-  // skip — their triggerTurn will resume the loop.
+  // skip — their prompt([]) will resume the loop.
   if (_continueInProgress) {
     ctx.ui.notify(
       "pi-invisible-continue: Another invisible continue is already in progress.",
@@ -92,20 +182,14 @@ async function runContinueCommand(
   _continueInProgress = true;
 
   try {
-    // Send an invisible custom message that triggers a new agent turn.
-    // convertToLlm() filters role:"custom" messages, so the LLM sees
-    // the same context as before — no injected prompt.
-    pi.sendMessage(
-      { customType: "pi-invisible-continue", content: "", display: false, details: undefined },
-      { triggerTurn: true },
-    );
-
-    // Wait for the triggered turn (and any post-run continuations like
-    // auto-compaction and auto-retry) to complete.
-    await ctx.waitForIdle();
-  } catch {
-    // Agent is already processing — something else is driving.
+    await _agent.waitForIdle();
+    try {
+      await _agent.prompt([]);
+    } catch {
+      // Agent is already processing — something else is driving.
+    }
   } finally {
     _continueInProgress = false;
+    _lastInvisibleContinueTime = Date.now();
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-invisible-continue",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Invisible session continuation for pi — resume the agentic loop without sending ANY prompt the LLM can see",
   "type": "module",
   "author": "Tom X Nguyen",
@@ -38,6 +38,7 @@
     "lint:dead": "knip --no-gitignore"
   },
   "devDependencies": {
+    "@earendil-works/pi-agent-core": "^0.79.1",
     "@earendil-works/pi-coding-agent": "0.75.4",
     "@types/node": "25.9.1",
     "@vitest/coverage-v8": "4.1.7",