one-code-extension 0.4.0 → 0.5.0

package/extensions/plugins/shell-expand.ts

@@ -0,0 +1,107 @@
+/**
+ * Expanding a plugin command body: arguments, then each `` !`command` ``
+ * placeholder replaced with that command's output.
+ *
+ * Two rules keep a typed argument from becoming shell syntax. Placeholders
+ * are found in the body as written, before any argument goes in, and an
+ * argument substituted into a placeholder's command goes in as a
+ * single-quoted word (`template.ts`), so `$(…)`, `;` or a backtick pair in
+ * what the user typed stays text. And the command runs in the bash every
+ * other shell path uses (`lib/shell-spawn.ts`: Git Bash on Windows, never a
+ * bare `/bin/sh` or `cmd.exe`), as Claude Code runs these in its bash:
+ * Node's `shell: true` used `/bin/sh` (dash on Debian and Ubuntu) and
+ * `cmd.exe`, where `[[ ]]`, `head` and process substitution fail and the
+ * error text became the placeholder's output.
+ */
+
+import type { ChildProcess } from "node:child_process";
+import { detachedSpawnOptions, killProcessTree, waitForChildExit } from "../lib/process-tree.ts";
+import { bashSpawn, type ShellSpawn, spawnShellCommand } from "../lib/shell-spawn.ts";
+import { shellQuote } from "../lib/shell-quote.ts";
+import { splitShellPlaceholders, substituteArguments } from "./template.ts";
+
+export const SHELL_TIMEOUT_MS = 30_000;
+/** A placeholder output past this many characters stops being collected, and says so. */
+const MAX_OUTPUT_CHARS = 2 * 1024 * 1024;
+
+/**
+ * Run one placeholder command in bash and return its stdout (stderr when
+ * stdout is empty), trimmed. A failure returns its error text, as before:
+ * the placeholder shows what went wrong rather than vanishing.
+ */
+export async function runPlaceholderCommand(
+	command: string,
+	cwd: string,
+	opts: { spec?: ShellSpawn; timeoutMs?: number; maxOutputChars?: number } = {},
+): Promise<string> {
+	const spec = opts.spec ?? bashSpawn().spawn;
+	if (!spec) return `command failed: ${bashSpawn().error ?? "no bash shell found"}`;
+	let child: ChildProcess;
+	try {
+		child = spawnShellCommand(spec, command, { cwd, stdio: ["ignore", "pipe", "pipe"], ...detachedSpawnOptions() });
+	} catch (error) {
+		return `command failed: ${error instanceof Error ? error.message : String(error)}`;
+	}
+	const maxChars = opts.maxOutputChars ?? MAX_OUTPUT_CHARS;
+	let stdout = "";
+	let stderr = "";
+	const cut = { stdout: false, stderr: false };
+	const capture = (sink: "stdout" | "stderr") => (chunk: string) => {
+		const current = sink === "stdout" ? stdout : stderr;
+		if (current.length + chunk.length > maxChars) cut[sink] = true;
+		if (current.length >= maxChars) return;
+		const next = current + chunk.slice(0, maxChars - current.length);
+		if (sink === "stdout") stdout = next;
+		else stderr = next;
+	};
+	child.stdout?.setEncoding("utf8");
+	child.stderr?.setEncoding("utf8");
+	child.stdout?.on("data", capture("stdout"));
+	child.stderr?.on("data", capture("stderr"));
+	let timedOut = false;
+	const timeoutMs = opts.timeoutMs ?? SHELL_TIMEOUT_MS;
+	const timer = setTimeout(() => {
+		timedOut = true;
+		killProcessTree(child, "SIGKILL");
+	}, timeoutMs);
+	timer.unref();
+	try {
+		await waitForChildExit(child);
+	} catch (error) {
+		return `command failed: ${error instanceof Error ? error.message : String(error)}`;
+	} finally {
+		clearTimeout(timer);
+	}
+	// The model must know an output is incomplete (a `git diff` cut mid-file).
+	const shown = stdout ? "stdout" : "stderr";
+	const text = `${(stdout || stderr).trim()}${cut[shown] ? `\n[output cut after ${maxChars} characters]` : ""}`;
+	if (timedOut) return `${text ? `${text}\n` : ""}command timed out after ${Math.round(timeoutMs / 1000)} seconds`;
+	return text;
+}
+
+/**
+ * Expand a command body: every placeholder's command runs once (with the
+ * arguments quoted in), text pieces get the arguments as typed, and an
+ * output is never scanned for arguments or placeholders again. `persist`
+ * bounds each output (a large `git diff`) before it lands in the prompt.
+ */
+export async function expandTemplate(
+	body: string,
+	args: string,
+	cwd: string,
+	opts: { persist?: (text: string, index: number) => string; run?: (command: string, cwd: string) => Promise<string> } = {},
+): Promise<string> {
+	const pieces = splitShellPlaceholders(body);
+	const commands = [...new Set(pieces.flatMap((piece) => (piece.kind === "shell" ? [substituteArguments(piece.command, args, shellQuote)] : [])))];
+	const run = opts.run ?? ((command: string, dir: string) => runPlaceholderCommand(command, dir));
+	const outputs = new Map<string, string>();
+	await Promise.all(
+		commands.map(async (command, index) => {
+			const text = await run(command, cwd);
+			outputs.set(command, opts.persist ? opts.persist(text, index) : text);
+		}),
+	);
+	return pieces
+		.map((piece) => (piece.kind === "text" ? substituteArguments(piece.text, args) : (outputs.get(substituteArguments(piece.command, args, shellQuote)) ?? "")))
+		.join("");
+}

package/extensions/plugins/template.ts

@@ -1,5 +1,5 @@
 /**
- * Claude Code command-template expansion (pure apart from the shell hook).
+ * Claude Code command-template expansion (pure; `shell-expand.ts` runs the commands).
  *
  * A command markdown file has frontmatter (`description`, `allowed-tools`,
  * `argument-hint`) and a body that may contain:
@@ -17,26 +17,43 @@ export interface CommandTemplate {
 	body: string;
 }
 
-export function substituteArguments(body: string, args: string): string {
+/**
+ * Replace `$ARGUMENTS`, `$@` and `$1`… with the invocation's arguments. With
+ * `quote`, each argument word is passed through it (a shell placeholder's
+ * command gets them as quoted words), so `$ARGUMENTS` stays one word per
+ * argument and no argument can add shell syntax.
+ */
+export function substituteArguments(body: string, args: string, quote?: (word: string) => string): string {
 	const parts = args.trim().length > 0 ? args.trim().split(/\s+/) : [];
-	return body
-		.replace(/\$ARGUMENTS\b/g, args.trim())
-		.replace(/\$@/g, args.trim())
-		.replace(/\$(\d+)/g, (_match, index) => parts[Number(index) - 1] ?? "");
+	const all = quote ? parts.map(quote).join(" ") : args.trim();
+	// One pass: a second pass would substitute inside argument text the first
+	// one inserted (an argument holding `$1`), unquoting it.
+	return body.replace(/\$ARGUMENTS\b|\$@|\$(\d+)/g, (_match, index: string | undefined) => {
+		if (index === undefined) return all;
+		const part = parts[Number(index) - 1];
+		return quote ? quote(part ?? "") : (part ?? "");
+	});
 }
 
-/** Finds each !`command` occurrence so the caller can run them. */
-export function findShellPlaceholders(body: string): string[] {
-	const found: string[] = [];
+export type TemplatePiece = { kind: "text"; text: string } | { kind: "shell"; command: string };
+
+/**
+ * A template body split into text and `` !`command` `` placeholders, found in
+ * the body as written: an argument substituted later can never become a
+ * placeholder. Until 2026-09-27 the arguments went in first, so an argument
+ * holding `` !`…` `` ran as a command of its own.
+ */
+export function splitShellPlaceholders(body: string): TemplatePiece[] {
+	const pieces: TemplatePiece[] = [];
 	const pattern = /!`([^`]+)`/g;
+	let last = 0;
 	let match = pattern.exec(body);
 	while (match) {
-		found.push(match[1]);
+		if (match.index > last) pieces.push({ kind: "text", text: body.slice(last, match.index) });
+		pieces.push({ kind: "shell", command: match[1] });
+		last = match.index + match[0].length;
 		match = pattern.exec(body);
 	}
-	return found;
-}
-
-export function replaceShellPlaceholders(body: string, outputs: Map<string, string>): string {
-	return body.replace(/!`([^`]+)`/g, (_match, command: string) => outputs.get(command) ?? "");
+	if (last < body.length) pieces.push({ kind: "text", text: body.slice(last) });
+	return pieces;
 }

package/extensions/powershell/child.ts

@@ -0,0 +1,7 @@
+/** One Code's PowerShell tool for an in-process child session (lib/child-extensions.ts): the same tool and activation, prints nothing. */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { powershellTool } from "./index.ts";
+
+export default function childPowershellExtension(pi: ExtensionAPI) {
+	powershellTool(pi, { announce: false });
+}

package/extensions/powershell/description.ts

@@ -10,9 +10,11 @@
  * (identical in the reconstructed `PowerShellTool/prompt.ts`). The
  * "Developer tools verified on this machine's PATH" list Claude Code can add
  * sits behind a remote flag that was off in the capture, so it is not
- * reproduced. One Code appends its own short note about the deferred task
- * tools and the `Start-Sleep` guard, after the captured text, the way the
- * bash tool does.
+ * reproduced. The shipped text corrects the captured working-directory
+ * sentence (`CC_CWD_SENTENCE`), drops the Glob/Grep lines
+ * (`CC_SEARCH_LINES`) and appends One
+ * Code's own short note about the deferred task tools and the `Start-Sleep`
+ * guard, after the captured text, the way the bash tool does.
  */
 
 export type PowerShellEditionName = "core" | "desktop" | "unknown";
@@ -126,14 +128,44 @@ Usage notes:
 
 /** One Code's addendum: where the harness differs from Claude Code's runtime (task tools are deferred, the sleep guard). */
 export const ONE_CODE_ADDENDUM =
-	" A background run returns a task id immediately; completion arrives as a task notification, and the output is retrievable with task_output / stoppable with task_stop (both deferred — load them with tool_search; in a one-shot print/json session the call runs to completion and returns the output directly). A foreground command that LEADS with `Start-Sleep` is blocked; to wait on a condition use the monitor tool (deferred — load it with tool_search select:monitor).";
+	" A background run returns a task id immediately; completion arrives as a task notification, and the output is retrievable with task_output / stoppable with task_stop (both deferred — load them with tool_search; in a one-shot print/json session the call runs to completion within the foreground timeout and returns the output directly). A foreground command that LEADS with `Start-Sleep` is blocked; to wait on a condition use the monitor tool (deferred — load it with tool_search select:monitor).";
 
 /** Claude Code's description for the detected edition, verbatim, without One Code's addendum. */
 export function claudeCodePowerShellDescription(edition: PowerShellEditionName): string {
 	return TEMPLATE.replace("{{EDITION}}", EDITION_SECTIONS[edition]);
 }
 
-/** The description the `powershell` tool ships: Claude Code's text plus One Code's addendum. */
+/**
+ * Claude Code's shell keeps its working directory between calls; pi's
+ * PowerShell tool spawns a fresh process per call in the session's directory,
+ * so a `Set-Location` ends with its command. A model that trusts the captured
+ * sentence would `cd` in one call and resolve relative paths against the
+ * wrong folder in the next, so the shipped text swaps it.
+ */
+export const CC_CWD_SENTENCE = "Working directory persists between commands; shell state (variables, functions) does not.";
+export const ONE_CODE_CWD_SENTENCE =
+	"Each command starts in the session's working directory; neither a directory change (`cd`, `Set-Location`) nor shell state (variables, functions) carries over to the next command.";
+
+/**
+ * Claude Code's PowerShell prompt names Glob and Grep even in its native
+ * builds, which ship neither (their Bash prompt drops the same two lines).
+ * One Code ships no search tools outside the tiny tier, so the lines would
+ * forbid the only search route left (`Get-ChildItem -Recurse`,
+ * `Select-String`); they are dropped on every tier. A tiny model still sees
+ * `find` and `grep` in its tool list.
+ */
+export const CC_SEARCH_LINES =
+	"    - File search: Use Glob (NOT Get-ChildItem -Recurse)\n    - Content search: Use Grep (NOT Select-String)\n";
+
+/** The same reason takes searching out of the file operations the tool is told to leave alone. */
+export const CC_FILE_OPERATIONS = "(reading, writing, editing, searching, finding files)";
+export const ONE_CODE_FILE_OPERATIONS = "(reading, writing, editing files)";
+
+/** The description the `powershell` tool ships: Claude Code's text with the corrections above, plus One Code's addendum. */
 export function powerShellToolDescription(edition: PowerShellEditionName): string {
-	return `${claudeCodePowerShellDescription(edition)}${ONE_CODE_ADDENDUM}`;
+	const text = claudeCodePowerShellDescription(edition)
+		.replace(CC_CWD_SENTENCE, ONE_CODE_CWD_SENTENCE)
+		.replace(CC_SEARCH_LINES, "")
+		.replace(CC_FILE_OPERATIONS, ONE_CODE_FILE_OPERATIONS);
+	return `${text}${ONE_CODE_ADDENDUM}`;
 }

package/extensions/powershell/guards.ts

@@ -64,7 +64,7 @@ export function powershellGuardReason(command: string, opts: { background: boole
 			// finds "rebase" instead of misreading the flag's value as the
 			// subcommand and missing the interactive-editor guard entirely.
 			const words = statement.trim().split(/\s+/).slice(1);
-			const { sub, rest } = gitSubcommand(words.map((value) => ({ value, hadExpansion: false })));
+			const { sub, rest } = gitSubcommand(words.map((value) => ({ value })));
 			const flags = new Set(rest.map((t) => t.value));
 			if (sub === "rebase" && (flags.has("-i") || flags.has("--interactive"))) {
 				return (

package/extensions/powershell/index.ts

@@ -1,13 +1,13 @@
 /**
  * powershell extension — Claude Code's PowerShell tool on top of pi's own
- * `powershell` built-in (docs/decisions/windows.md, findings §22).
+ * `powershell` built-in (working-docs/decisions/windows.md, findings §22).
  *
  * Registering a tool named `powershell` overrides pi's built-in (findings §2),
  * exactly as `extensions/bash` overrides `bash`, and the shared body in
  * lib/shell-tool.ts supplies the `run_in_background` orchestration for both.
  * The foreground path delegates to pi's real definition
- * (`createPowerShellToolDefinition`) so schema, cwd handling, truncation and
- * streaming stay upstream's — with One Code's own `operations`
+ * (`createPowerShellToolDefinition`) so schema, cwd handling and streaming
+ * stay upstream's (a long output is cut Claude Code's way, as for bash) — with One Code's own `operations`
  * (lib/shell-spawn.ts), because pi's local operations throw off Windows and
  * this tool is developed against a `pwsh` on this Mac. The description is
  * Claude Code's captured text (description.ts); the guards are the PowerShell
@@ -25,7 +25,7 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { createPowerShellToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { perCwd } from "../lib/per-cwd.ts";
-import { bashSpawn, createPowerShellOperations, POWERSHELL_UTF8_PREFIX, powerShellEdition, powerShellSpawn } from "../lib/shell-spawn.ts";
+import { bashSpawn, createPowerShellOperations, POWERSHELL_TOOL_PREFIX, powerShellEdition, powerShellSpawn } from "../lib/shell-spawn.ts";
 import { registerShellTool } from "../lib/shell-tool.ts";
 import { powerShellToolDescription } from "./description.ts";
 import { powershellGuardReason } from "./guards.ts";
@@ -40,6 +40,11 @@ const PowerShellParams = Type.Object({
 });
 
 export default function powershellExtension(pi: ExtensionAPI) {
+	powershellTool(pi, { announce: true });
+}
+
+/** The tool itself; `announce: false` is the in-process child's shape (powershell/child.ts), which prints no notices. */
+export function powershellTool(pi: ExtensionAPI, { announce }: { announce: boolean }) {
 	const spec = powerShellSpawn();
 	const operations = createPowerShellOperations(() => spec);
 	const base = createPowerShellToolDefinition(process.cwd(), { operations });
@@ -66,8 +71,8 @@ export default function powershellExtension(pi: ExtensionAPI) {
 		foreground: perCwd((cwd: string) => createPowerShellToolDefinition(cwd, { operations })),
 		guard: powershellGuardReason,
 		backgroundShell: () => spec,
-		// The foreground path prepends pi's UTF-8 prefix inside the operations; the background spawn needs it too.
-		wrapBackgroundCommand: (command) => `${POWERSHELL_UTF8_PREFIX}${command}`,
+		// The foreground path prepends the tool's prefix inside the operations; the background spawn needs it too.
+		wrapBackgroundCommand: (command) => `${POWERSHELL_TOOL_PREFIX}${command}`,
 	});
 
 	let noticesShown = false;
@@ -76,7 +81,7 @@ export default function powershellExtension(pi: ExtensionAPI) {
 		const active = pi.getActiveTools();
 		const next = withShellTools(active, current);
 		if (next.join(" ") !== active.join(" ")) pi.setActiveTools(next);
-		if (noticesShown || current.notices.length === 0) return;
+		if (!announce || noticesShown || current.notices.length === 0) return;
 		noticesShown = true;
 		for (const notice of current.notices) {
 			if (ctx?.hasUI) ctx.ui.notify(notice, "warning");

package/extensions/recap/index.ts

@@ -8,30 +8,34 @@
  * most one recap per user turn (firedSinceTurn), matching CC's
  * hasSummarySinceLastUserTurn guard.
  *
- * Generation mirrors CC's awaySummary.ts: a cheap same-containment model
- * (pickEconomicalContainedModel — the getSmallFastModel analog), CC's verbatim
- * prompt, and only the last 30 messages. It deliberately does NOT reuse the
- * session prompt cache the way compaction does — CC makes a small standalone
- * call here (skipCacheWrite). The result is a display-only entry (appendEntry,
+ * Generation is Claude Code 2.1.261's: the session's last provider request
+ * replayed unchanged on the session model, the reply that answered it, then
+ * the verbatim prompt, so the call reads the cache the session wrote and
+ * writes the reply for the user's next turn (lib/request-replay.ts; the
+ * compaction extension publishes the capture). Without a capture for the
+ * session model, or on a provider API the replay does not cover, it falls back
+ * to a small standalone call on a cheap same-containment model
+ * (pickEconomicalContainedModel): the last 30 messages and name-only stubs of
+ * the active tools (some providers reject a history carrying tool_use blocks
+ * with no tools declared). The result is a display-only entry (appendEntry,
  * not in LLM context). Best-effort throughout: any failure just shows nothing.
  *
- * Deviations from CC, logged in docs/decisions: the session-memory block is
- * omitted (decoupling), and name-only stubs of the active tools are sent
- * rather than an empty tool list — some providers reject a history carrying
- * tool_use blocks with no tools declared, and the small-token instruction keeps
- * the model answering in text rather than calling one. A failed recap does not
- * retry until the next turn (one attempt per turn, success or not). CC_RECAP=0
- * opts out; CC_RECAP_IDLE_MS overrides the 5-minute delay.
+ * Deviations from CC, logged in working-docs/decisions: the session-memory block is
+ * omitted (decoupling). A failed recap does not retry until the next turn (one
+ * attempt per turn, success or not). CC_RECAP=0 opts out; CC_RECAP_IDLE_MS
+ * overrides the 5-minute delay.
  */
 
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
 import type { Api, Model } from "@earendil-works/pi-ai";
-import { completeSimple } from "@earendil-works/pi-ai/compat";
 import { convertToLlm, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { withReasoningFallback } from "../lib/model-policy.ts";
+import { followLastExchange, replaySideCall } from "../lib/replay-call.ts";
 import { recordUsage } from "../lib/usage-bus.ts";
 import { pickEconomicalContainedModel } from "../lib/model-tier.ts";
-import { answerText, stripImageBlocks, toolStubs } from "../lib/side-call.ts";
+import { CONVERSATION_CACHE_PLACEMENT } from "../lib/side-call-cache.ts";
+import { releaseSideCalls, runSideCall } from "../lib/side-call-run.ts";
+import { answerText, stripImageBlocks, toolStubs, withoutSystemMessages } from "../lib/side-call.ts";
+import { unrefTimers } from "../lib/timer-ops.ts";
 import { dimMarkedLine } from "../lib/tui-render.ts";
 import { RECAP_PROMPT, recapLine, recentForRecap, REFERENCE_MARK } from "./prompt.ts";
 import { RecapScheduler } from "./scheduler.ts";
@@ -66,6 +70,8 @@ export default function recapExtension(pi: ExtensionAPI) {
 	pi.on("context", (event) => {
 		capturedMessages = event.messages;
 	});
+	// The same request as it went on the wire, and the reply that answered it.
+	const exchange = followLastExchange(pi);
 
 	let lastCtx: ExtensionContext | undefined;
 	let inFlight: AbortController | undefined;
@@ -77,19 +83,47 @@ export default function recapExtension(pi: ExtensionAPI) {
 	};
 
 	const scheduler = new RecapScheduler(
-		{
-			set: (cb, ms) => {
-				const handle = setTimeout(cb, ms);
-				handle.unref?.();
-				return handle;
-			},
-			clear: (handle) => clearTimeout(handle as ReturnType<typeof setTimeout>),
-		},
+		unrefTimers,
 		idleMs,
 		() => process.env.CC_RECAP !== "0",
 		() => void generate(),
 	);
 
+	/** The fallback: a small standalone call on a cheap same-containment model. */
+	async function standaloneRecap(ctx: ExtensionContext, model: Model<Api>, messages: AgentMessage[], signal: AbortSignal): Promise<string> {
+		const choice = pickEconomicalContainedModel(ctx.modelRegistry.getAvailable(), model);
+		if (!choice) return "";
+		const auth = await ctx.modelRegistry.getApiKeyAndHeaders(choice.model);
+		if (!auth.ok) return "";
+		// Name-only stubs of the active tools, so a history carrying tool_use
+		// blocks stays valid on strict providers (see the header note) without
+		// shipping every full schema (~6k tokens) to a call that must answer
+		// in text.
+		const tools = toolStubs(pi.getActiveTools(), STUB_REASON);
+
+		const recent = recentForRecap(withoutSystemMessages(messages));
+		// The cheap reader may be a text-only model, and the recap does not need
+		// images — strip them so a pasted image or one a Read returned cannot break
+		// the call (working-docs/decisions/model-policy.md).
+		const recapMessages = [...stripImageBlocks(convertToLlm(recent)), { role: "user" as const, content: RECAP_PROMPT, timestamp: Date.now() }];
+		// Thinking off unless the model cannot disable it; withReasoningFallback
+		// sends a level up front for catalog-marked models and retries on the 400
+		// for the rest. Fires on a 5-min idle timer, so no cross-call memo.
+		const result = await runSideCall({
+			kind: "recap",
+			model: choice.model,
+			auth,
+			sessionId: ctx.sessionManager.getSessionId(),
+			context: { systemPrompt: "", messages: recapMessages, tools },
+			signal,
+			timeoutMs: RECAP_TIMEOUT_MS,
+			maxTokens: RECAP_MAX_TOKENS,
+			cache: CONVERSATION_CACHE_PLACEMENT,
+			onUsage: (usage) => recordUsage(pi, "recap", usage),
+		});
+		return answerText(result.content);
+	}
+
 	async function generate() {
 		const ctx = lastCtx;
 		const messages = capturedMessages;
@@ -100,43 +134,13 @@ export default function recapExtension(pi: ExtensionAPI) {
 		try {
 			const model = ctx.model;
 			if (!model) return;
-			const choice = pickEconomicalContainedModel(ctx.modelRegistry.getAvailable(), model);
-			if (!choice) return;
-			const auth = await ctx.modelRegistry.getApiKeyAndHeaders(choice.model);
-			if (!auth.ok) return;
-			const baseUrl = (auth as { baseUrl?: string }).baseUrl;
-
-			// Name-only stubs of the active tools, so a history carrying tool_use
-			// blocks stays valid on strict providers (see the header note) without
-			// shipping every full schema (~6k tokens) to a call that must answer
-			// in text.
-			const tools = toolStubs(pi.getActiveTools(), STUB_REASON);
-
-			const recent = recentForRecap(messages);
-			// The cheap reader may be a text-only model, and the recap does not need
-			// images — strip them so a pasted image or one a Read returned cannot break
-			// the call (docs/decisions/model-policy.md).
-			const recapMessages = [...stripImageBlocks(convertToLlm(recent)), { role: "user" as const, content: RECAP_PROMPT, timestamp: Date.now() }];
-			// Thinking off unless the model cannot disable it; withReasoningFallback
-			// sends a level up front for catalog-marked models and retries on the 400
-			// for the rest. Fires on a 5-min idle timer, so no cross-call memo.
-			const result = await withReasoningFallback(choice.model, (reasoning) => {
-				const timeout = AbortSignal.timeout(RECAP_TIMEOUT_MS);
-				return completeSimple(
-					baseUrl ? ({ ...choice.model, baseUrl } as Model<Api>) : choice.model,
-					{ systemPrompt: "", messages: recapMessages, tools },
-					{
-						apiKey: auth.apiKey,
-						headers: auth.headers,
-						env: auth.env,
-						signal: AbortSignal.any([controller.signal, timeout]),
-						maxTokens: RECAP_MAX_TOKENS,
-						...(reasoning ? { reasoning } : {}),
-					},
-				);
-			}, undefined, (usage) => recordUsage(pi, "recap", usage));
+			const replayed = await replaySideCall(ctx, model as Model<Api>, exchange, RECAP_PROMPT, {
+				signal: controller.signal,
+				timeoutMs: RECAP_TIMEOUT_MS,
+				onUsage: (usage) => recordUsage(pi, "recap", usage),
+			});
+			const content = replayed ?? (await standaloneRecap(ctx, model as Model<Api>, messages, controller.signal));
 			if (controller.signal.aborted) return;
-			const content = answerText(result.content);
 			if (!content) return;
 			scheduler.markFired();
 			pi.appendEntry<RecapData>(ENTRY_TYPE, { content });
@@ -194,8 +198,9 @@ export default function recapExtension(pi: ExtensionAPI) {
 		scheduler.turnEnded();
 	});
 
-	pi.on("session_shutdown", () => {
+	pi.on("session_shutdown", (_event, ctx) => {
 		scheduler.reset();
 		abortInFlight();
+		releaseSideCalls(ctx.sessionManager.getSessionId());
 	});
 }

package/extensions/recap/prompt.ts

@@ -18,9 +18,9 @@ export const REFERENCE_MARK = "※";
  */
 export const RECENT_MESSAGE_WINDOW = 30;
 
-/** The away-summary instruction, verbatim from CC's buildAwaySummaryPrompt (no memory block). */
+/** The away-summary instruction, verbatim from Claude Code 2.1.261's request (no memory block). */
 export const RECAP_PROMPT =
-	"The user stepped away and is coming back. Write exactly 1-3 short sentences. Start by stating the high-level task — what they are building or debugging, not implementation details. Next: the concrete next step. Skip status reports and commit recaps.";
+	"The user stepped away and is coming back. Recap in under 40 words, 1-2 plain sentences, no markdown. Lead with the overall goal and current task, then the one next action. Skip root-cause narrative, fix internals, secondary to-dos, and em-dash tangents.";
 
 /** The transcript text after the ※ mark, matching CC's shipped "recap: …" line. */
 export function recapLine(content: string): string {

package/extensions/recap/scheduler.ts

@@ -14,11 +14,9 @@
  * async model call it triggers stays in the extension.
  */
 
-export interface TimerOps {
-	/** Schedule `cb` after `ms`; return a handle for `clear`. */
-	set(cb: () => void, ms: number): unknown;
-	clear(handle: unknown): void;
-}
+import type { TimerOps } from "../lib/timer-ops.ts";
+
+export type { TimerOps };
 
 export class RecapScheduler {
 	private turnRunning = false;

package/extensions/search-tools/grep-merge.ts

@@ -0,0 +1,39 @@
+/**
+ * pi's grep tool prints one context window per match, so with `context` set,
+ * nearby matches repeat the lines their windows share (a line once as context,
+ * again as context, again as the next match). Merged here (pure): each file
+ * line appears once, in the order first seen, and a line that is a match in
+ * any window shows as the match. Rows are `path:N: text` (match) and
+ * `path-N- text` (context); two rows are the same line only when path, number
+ * and text all agree, so lines of different files are never merged. Anything
+ * else (pi's notices) passes through.
+ */
+
+const MATCH_ROW = /^(.+?):(\d+): (.*)$/s;
+const CONTEXT_ROW = /^(.+?)-(\d+)- (.*)$/s;
+
+export function mergeGrepWindows(text: string): string {
+	const out: string[] = [];
+	/** Each line's context form → its index in `out`. */
+	const at = new Map<string, number>();
+	for (const line of text.split("\n")) {
+		// The separator that comes first decides: a row's text may itself hold
+		// `:N: ` or `-N- ` (`a.ts-12- k:3: v` is a context row).
+		const asMatch = MATCH_ROW.exec(line);
+		const asContext = CONTEXT_ROW.exec(line);
+		const match = asMatch && (!asContext || asMatch[1].length < asContext[1].length) ? asMatch : null;
+		const key = match ? `${match[1]}-${match[2]}- ${match[3]}` : asContext ? line : undefined;
+		if (key === undefined) {
+			out.push(line);
+			continue;
+		}
+		const index = at.get(key);
+		if (index === undefined) {
+			at.set(key, out.length);
+			out.push(line);
+		} else if (match) {
+			out[index] = line;
+		}
+	}
+	return out.join("\n");
+}

package/extensions/send-now/chord.ts

@@ -0,0 +1,62 @@
+/**
+ * Claude Code's "send now" chord, `ctrl+x ctrl+s` (its `chat:sendNow` action),
+ * read from raw terminal input. Pure: the extension feeds it every key.
+ *
+ * Keys arrive in any of three encodings: the legacy control byte (`\x18`,
+ * `\x13`), the kitty keyboard protocol's CSI u form, which pi-tui turns on
+ * with flags 7 (disambiguate, event types, alternate keys) where the terminal
+ * supports it, or xterm's modifyOtherKeys form (`\x1b[27;5;120~`), which
+ * pi-tui turns on otherwise and tmux sends with `extended-keys on`.
+ * `lib/key-input.ts` names all three alike. With event types on, a release
+ * follows every press, so releases never change the chord's state.
+ *
+ * pi binds `ctrl+x` alone to "copy the last assistant message". The chord
+ * takes a `ctrl+x` only while send now applies (a turn runs with something to
+ * send), where it is the chord's prefix as in Claude Code: one the chord does
+ * not complete (another key, or the extension's timeout) is dropped. At every
+ * other time `ctrl+x` reaches pi and copies.
+ */
+
+import { isKeyRelease, keyId } from "../lib/key-input.ts";
+
+export type ChordKey = "ctrl+x" | "ctrl+s" | "release" | "other";
+
+export function classifyKey(data: string): ChordKey {
+	if (isKeyRelease(data)) return "release";
+	const id = keyId(data);
+	if (id === "ctrl+x" || id === "ctrl+s") return id;
+	return "other";
+}
+
+/**
+ * What the extension does with a key: let it through, hold it (a `ctrl+x`
+ * that may start the chord, consumed), or send now (the `ctrl+s`, consumed).
+ */
+export type ChordAction = "pass" | "hold" | "send";
+
+export class SendNowChord {
+	private armed = false;
+
+	/** Feed one key; `active` is whether send now applies (a turn is running with something to send). */
+	feed(data: string, active: boolean): ChordAction {
+		const key = classifyKey(data);
+		if (key === "release") return "pass";
+		const armed = this.armed;
+		this.armed = false;
+		// A second ctrl+x, or the kitty protocol's auto-repeat of a held one, keeps the chord armed.
+		if (key === "ctrl+x" && active) {
+			this.armed = true;
+			return "hold";
+		}
+		if (armed && key === "ctrl+s" && active) return "send";
+		return "pass";
+	}
+
+	/** The chord timed out: its `ctrl+x` is dropped. */
+	expire(): void {
+		this.armed = false;
+	}
+}
+
+/** The hint under the queued messages, Claude Code's wording. */
+export const SEND_NOW_HINT = "ctrl+x ctrl+s to send now";