pi-invisible-continue 0.2.0

package/README.md

@@ -0,0 +1,128 @@
+<div align="center">
+
+# 👻 pi-invisible-continue
+
+**Invisible session continuation for [pi](https://github.com/earendil-works/pi-coding-agent)**
+
+_Resume the agentic loop without the LLM seeing any new prompt at all._
+
+[![pi extension](https://img.shields.io/badge/pi-extension-blueviolet)](https://github.com/earendil-works/pi-coding-agent)
+[![license](https://img.shields.io/badge/license-MIT-blue)](./LICENSE)
+
+</div>
+
+---
+
+## The Problem
+
+Every existing "continue" extension sends a **visible user message** to the LLM:
+
+| Package | What the LLM sees |
+|---------|-------------------|
+| `pi-continue` | `"Continue from the same-session pi-continue/v3 handoff Pi just saved..."` (full handoff doc) |
+| `pi-hodor` | `"continue"` (literal text) |
+| `pi-auto-continue` | `"continue"` (literal text) |
+| `pi-retry` | `"Continue"` on max-tokens, or hidden custom trigger on errors |
+
+Every one of those **changes the LLM's context** with new user text. That text influences the next response, sometimes in unintended ways — model changes course, re-reads things it already processed, or treats a bare `"continue"` as a new task.
+
+---
+
+## The Solution
+
+`pi-invisible-continue` captures the internal `Agent` instance via a prototype monkey-patch on `Agent.prototype.prompt`. When `/continue` is invoked, it calls `agent.prompt([])` directly — starting a fresh agent loop with an **empty prompt array**. No message is injected into the context at all:
+
+- The agent loop restarts
+- The LLM receives **the exact same message list it had before**
+- No new text, no handoff, no pollution, no session artifact
+- Nothing in `convertToLlm`'s path — no filtering needed
+
+---
+
+## How It Works
+
+```
+Extension loads
+  → Monkey-patches Agent.prototype.prompt to capture the Agent instance
+  → First real prompt stores the reference
+
+User types "/continue"
+  → agent.prompt([]) called directly
+  → runAgentLoop([], contextSnapshot, ...)
+  → prompts array is empty — no message emitted, no message pushed to context
+  → runLoop → streamAssistantResponse → convertToLlm(unmodified messages)
+  → LLM sees same messages as before → responds naturally
+```
+
+### Why `agent.prompt([])` and not `agent.continue()`?
+
+`agent.continue()` has a guard that throws `Cannot continue from message role: assistant` when the last message is from the assistant — which it always is when the agent stops. `agent.prompt([])` starts a fresh loop from the current context snapshot without that restriction.
+
+### 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.
+
+---
+
+## Usage
+
+Once loaded, use `/continue`:
+
+| Command | What it does |
+|---------|-------------|
+| `/continue` | Resume the loop invisibly. Waits for idle, then fires. |
+| `/continue status` | Show agent idle state, captured-agent status, and last assistant text (debug). |
+| `/continue help` | Show this reference. |
+
+---
+
+## Installation
+
+```bash
+pi install https://github.com/monotykamary/pi-invisible-continue
+```
+
+Or in `~/.pi/agent/settings.json`:
+
+```json
+{
+  "packages": [
+    "https://github.com/monotykamary/pi-invisible-continue"
+  ]
+}
+```
+
+Then `/reload` or restart pi.
+
+For quick one-off tests:
+
+```bash
+pi -e ./continue.ts
+```
+
+---
+
+## Comparison with Other Packages
+
+| Feature | pi-invisible-continue | pi-continue | pi-hodor | pi-auto-continue |
+|---------|----------------------|-------------|----------|-------------------|
+| LLM sees new user text | ❌ No | ✅ Handoff doc | ✅ "continue" | ✅ "continue" |
+| Session pollution | None | Full compaction entry + user message | 1 user message | 1 user message |
+| Mechanism | `agent.prompt([])` | `sendMessage` + handoff | `sendMessage` | `sendMessage` |
+| Auto-triggered | ❌ Manual only | ✅ On compaction | ✅ On error/length | ✅ On agent_end |
+| Retry integration | ❌ | ❌ | ✅ Error patterns | ❌ |
+| Complexity | Prototype patch + 1 call | 49 files, multi-stage | 2 files, config-driven | 1 file, loop-based |
+
+---
+
+## About the Hack
+
+The extension uses the public `@earendil-works/pi-agent-core` package (which pi's extension loader resolves to the same module instance used internally) to import `Agent` and monkey-patch `Agent.prototype.prompt`. This captures the live `Agent` instance when pi first calls `agent.prompt()` during normal operation.
+
+Then `/continue` calls `agent.prompt([])` — an empty prompt array. The `runAgentLoop` function spreads the prompts into the context messages, so with an empty array, nothing is added. The loop starts from the unmodified context snapshot and the LLM continues naturally.
+
+This is the approach discussed in [pi issue #3721](https://github.com/earendil-works/pi/issues/3721) ("Feature request: Resume agentic loop without sending a message"). The upstream fix would be exposing `agent.continue()` (or a variant that works from `assistant` last-message) on `AgentSession`, but this extension achieves the same effect without waiting for a core change.
+
+## License
+
+MIT

package/continue.ts

@@ -0,0 +1,86 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { Agent } from "@earendil-works/pi-agent-core";
+import {
+  CONTINUE_COMMAND_DESCRIPTION,
+  getLastAssistantMessageText,
+} from "./src/index.js";
+
+/**
+ * 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
+ *   - /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.
+ */
+
+// 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().
+// 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);
+};
+
+export default function (pi: ExtensionAPI) {
+  pi.registerCommand("continue", {
+    description: CONTINUE_COMMAND_DESCRIPTION,
+    handler: async (args, ctx) => {
+      await runContinueCommand(ctx, args);
+    },
+  });
+}
+
+async function runContinueCommand(
+  ctx: ExtensionCommandContext,
+  args: string,
+): Promise<void> {
+  if (args.trim().toLowerCase() === "status") {
+    const last = getLastAssistantMessageText(ctx.sessionManager.getEntries());
+    const idle = ctx.isIdle();
+    ctx.ui.notify(
+      [
+        "pi-invisible-continue status:",
+        `  Agent idle: ${idle ? "yes" : "no"}`,
+        `  Captured agent: ${_agent ? "yes" : "no"}`,
+        `  Last assistant: ${last ?? "(none)"}`.slice(0, 120),
+      ].join("\n"),
+      "info",
+    );
+    return;
+  }
+
+  if (args.trim().toLowerCase() === "help") {
+    ctx.ui.notify(
+      [
+        "pi-invisible-continue  /continue     Resume loop invisibly",
+        "                        /continue status  Show diagnostics",
+        "                        /continue help    This message",
+      ].join("\n"),
+      "info",
+    );
+    return;
+  }
+
+  if (!_agent) {
+    ctx.ui.notify(
+      "pi-invisible-continue: Agent instance not captured. Internal error?",
+      "warning",
+    );
+    return;
+  }
+
+  if (!ctx.isIdle()) {
+    await ctx.waitForIdle();
+  }
+
+  await _agent.prompt([]);
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "pi-invisible-continue",
+  "version": "0.2.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",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/monotykamary/pi-invisible-continue.git"
+  },
+  "homepage": "https://github.com/monotykamary/pi-invisible-continue#readme",
+  "bugs": {
+    "url": "https://github.com/monotykamary/pi-invisible-continue/issues"
+  },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-coding-agent",
+    "extension",
+    "continue",
+    "continuation",
+    "invisible",
+    "no-prompt",
+    "resume",
+    "agent-loop"
+  ],
+  "files": [
+    "*.ts",
+    "src/",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "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",
+    "knip": "6.14.1",
+    "typescript": "6.0.3",
+    "vitest": "4.1.7"
+  },
+  "pi": {
+    "extensions": [
+      "./continue.ts"
+    ]
+  },
+  "overrides": {
+    "brace-expansion": "5.0.6",
+    "protobufjs": "8.4.0",
+    "ws": "8.20.1"
+  }
+}

package/src/index.ts

@@ -0,0 +1,42 @@
+/**
+ * Shared constants and utilities for pi-invisible-continue.
+ *
+ * The extension is small enough that heavy shared logic is unnecessary.
+ * The command description and a session introspection helper are the only exports.
+ */
+
+/** Description shown in the / commands list. */
+export const CONTINUE_COMMAND_DESCRIPTION =
+  "Resume the agentic loop without sending a prompt the LLM can read";
+
+/**
+ * Extract the text content of the last assistant message in the session.
+ * Returns undefined if no assistant message exists.
+ */
+export function getLastAssistantMessageText(
+  entries: ReadonlyArray<{ type: string; message?: { role?: string; content?: unknown } }>,
+): string | undefined {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i];
+    if (
+      entry.type === "message" &&
+      entry.message?.role === "assistant" &&
+      entry.message?.content
+    ) {
+      const content = entry.message.content;
+      if (typeof content === "string") return content;
+      if (Array.isArray(content)) {
+        const textBlocks = content.filter(
+          (block: any): block is { type: "text"; text: string } =>
+            typeof block === "object" &&
+            block !== null &&
+            block.type === "text" &&
+            typeof block.text === "string",
+        );
+        if (textBlocks.length === 0) return undefined;
+        return textBlocks.map((block) => block.text).join("\n");
+      }
+    }
+  }
+  return undefined;
+}

package/vitest.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    include: ["__tests__/**/*.test.ts"],
+    exclude: ["node_modules", "dist", ".idea", ".git", ".cache"],
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json", "html"],
+      exclude: ["node_modules/", "**/*.d.ts", "**/*.test.ts"],
+    },
+  },
+});