pi-invisible-continue 0.2.3 → 0.3.0

package/continue.ts

@@ -1,5 +1,4 @@
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { Agent } from "@earendil-works/pi-agent-core";
 import {
   CONTINUE_COMMAND_DESCRIPTION,
   getLastAssistantMessageText,
@@ -9,115 +8,45 @@ import {
  * pi-invisible-continue — resume the agentic loop without the LLM seeing any new prompt.
  *
  * Strategy:
- *   - 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
+ *   - 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
  *
- * 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.
+ * 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.
+ *
+ *   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.
  */
 
-// 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(ctx, args);
+      await runContinueCommand(pi, ctx, args);
     },
   });
 
   pi.on("session_start", () => {
     _continueInProgress = false;
-    _lastInvisibleContinueTime = 0;
   });
 }
 
 async function runContinueCommand(
+  pi: ExtensionAPI,
   ctx: ExtensionCommandContext,
   args: string,
 ): Promise<void> {
@@ -128,7 +57,6 @@ 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",
@@ -148,20 +76,12 @@ 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 prompt([]) will resume the loop.
+  // skip — their triggerTurn will resume the loop.
   if (_continueInProgress) {
     ctx.ui.notify(
       "pi-invisible-continue: Another invisible continue is already in progress.",
@@ -172,14 +92,20 @@ async function runContinueCommand(
   _continueInProgress = true;
 
   try {
-    await _agent.waitForIdle();
-    try {
-      await _agent.prompt([]);
-    } catch {
-      // Agent is already processing — something else is driving.
-    }
+    // 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.
   } finally {
     _continueInProgress = false;
-    _lastInvisibleContinueTime = Date.now();
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-invisible-continue",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "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,8 +38,6 @@
     "lint:dead": "knip --no-gitignore"
   },
   "devDependencies": {
-    "@earendil-works/pi-agent-core": "0.75.4",
-    "@earendil-works/pi-ai": "0.75.4",
     "@earendil-works/pi-coding-agent": "0.75.4",
     "@types/node": "25.9.1",
     "@vitest/coverage-v8": "4.1.7",