one-code-extension 0.4.1 → 0.6.0

package/extensions/recap/index.ts

@@ -8,30 +8,35 @@
  * 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 current branch's last 30 messages (read
+ * from the session when the recap runs) 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, branchMessages, 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";
@@ -60,12 +65,8 @@ export default function recapExtension(pi: ExtensionAPI) {
 		return dimMarkedLine(theme, REFERENCE_MARK, recapLine(content));
 	});
 
-	// The exact request messages the session last sent (after every extension's
-	// mutations), captured like the compaction extension does.
-	let capturedMessages: AgentMessage[] | undefined;
-	pi.on("context", (event) => {
-		capturedMessages = event.messages;
-	});
+	// The session's last 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,66 +78,67 @@ 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;
-		if (!ctx?.hasUI || !messages?.length || scheduler.hasFiredSinceTurn) return;
+		if (!ctx?.hasUI || scheduler.hasFiredSinceTurn) return;
+		// The current branch, read now: a /tree or a compaction since the last
+		// request changed it, and pi fires no `context` event for either.
+		const messages = branchMessages(ctx);
+		if (!messages.length) return;
 		abortInFlight();
 		const controller = new AbortController();
 		inFlight = controller;
 		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 });
@@ -155,11 +157,10 @@ export default function recapExtension(pi: ExtensionAPI) {
 	pi.on("session_start", (_event, ctx) => {
 		lastCtx = ctx;
 		// A new session (including after /clear): drop any timer armed by the
-		// previous session and its captured messages, so a stale recap can never
-		// surface against the fresh conversation.
+		// previous session, so a stale recap can never surface against the
+		// fresh conversation.
 		scheduler.reset();
 		abortInFlight();
-		capturedMessages = undefined;
 		if (!ctx.hasUI) return;
 		// Reset the idle clock on any keystroke — the closest signal to CC's
 		// terminal-blur trigger pi exposes. Registered ONCE (session_start fires
@@ -194,8 +195,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";

package/extensions/send-now/index.ts

@@ -0,0 +1,133 @@
+/**
+ * send-now extension — Claude Code's "send now" for messages queued mid-turn.
+ *
+ * A message typed while a turn runs waits in pi's queue until the current
+ * response and its tool calls finish. `ctrl+x ctrl+s` (chord.ts) delivers it
+ * at once: the running turn is aborted, which makes pi move every queued
+ * message and the draft back into the editor (its abort handler), and once the
+ * session is idle that text is sent as the next prompt (a pasted image is its
+ * file path in the text, so nothing is lost). Running tools are cancelled, as in Claude Code before 2.1.283, which moves
+ * them to the background instead. A dim `ctrl+x ctrl+s to send now` line sits
+ * above the editor while anything is queued.
+ *
+ * pi binds `ctrl+x` alone to copy; while send now applies, `ctrl+x` is only the
+ * chord's prefix (chord.ts), and one the chord does not complete (another key,
+ * or CHORD_TIMEOUT_MS without one) is dropped. Only public extension API.
+ *
+ * pi exposes no read of its queue to extensions, only `hasPendingMessages()`,
+ * so the hint asks on every render rather than tracking queue events (a
+ * dequeue with alt+up fires none). TUI only.
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { SEND_NOW_CHANNEL } from "../lib/send-now-channel.ts";
+import { safeThemePaint, truncateLine } from "../lib/tui-render.ts";
+import { SEND_NOW_HINT, SendNowChord } from "./chord.ts";
+
+/** How long send now waits for the aborted turn to settle before giving up. */
+const IDLE_WAIT_MS = 10_000;
+/** How long a held `ctrl+x` waits for its `ctrl+s` before the chord is dropped. */
+const CHORD_TIMEOUT_MS = 1_000;
+
+export default function sendNowExtension(pi: ExtensionAPI) {
+	let unsubscribe: (() => void) | undefined;
+	// Bumped on every session start and shutdown, so a send now still waiting
+	// for the aborted turn never acts on a replaced or closed session.
+	let epoch = 0;
+	/** Resolves a send now waiting for the aborted turn to settle. */
+	let onSettled: (() => void) | undefined;
+	const wakeSettled = () => {
+		const wake = onSettled;
+		onSettled = undefined;
+		wake?.();
+	};
+	pi.on("agent_settled", wakeSettled);
+
+	pi.on("session_shutdown", () => {
+		epoch++;
+		wakeSettled();
+		unsubscribe?.();
+		unsubscribe = undefined;
+	});
+
+	pi.on("session_start", (_event, ctx) => {
+		unsubscribe?.();
+		unsubscribe = undefined;
+		const session = ++epoch;
+		const current = () => epoch === session;
+		if (!ctx.hasUI || ctx.mode !== "tui") return;
+
+		const queued = () => !ctx.isIdle() && ctx.hasPendingMessages();
+		// Claude Code sends the draft too, so a draft alone is enough to send now.
+		const active = () => !ctx.isIdle() && (ctx.hasPendingMessages() || ctx.ui.getEditorText().trim() !== "");
+
+		let sending = false;
+		const sendNow = async (turnCtx: ExtensionContext) => {
+			if (sending) return;
+			sending = true;
+			try {
+				pi.events.emit(SEND_NOW_CHANNEL, {});
+				turnCtx.abort();
+				if (!turnCtx.isIdle()) {
+					await new Promise<void>((resolve) => {
+						const fallback = setTimeout(resolve, IDLE_WAIT_MS);
+						fallback.unref?.();
+						onSettled = () => {
+							clearTimeout(fallback);
+							resolve();
+						};
+					});
+				}
+				if (!current() || !turnCtx.isIdle()) return;
+				const text = turnCtx.ui.getEditorText().trim();
+				if (!text) return;
+				turnCtx.ui.setEditorText("");
+				// followUp: an async UserPromptSubmit hook runs before pi's busy
+				// check, and on pi 1.2.0 a run starting meanwhile would reject a
+				// bare send after the editor was cleared.
+				pi.sendUserMessage(text, { deliverAs: "followUp" });
+			} finally {
+				sending = false;
+			}
+		};
+
+		const chord = new SendNowChord();
+		let timer: ReturnType<typeof setTimeout> | undefined;
+		const stopUnsubscribe = ctx.ui.onTerminalInput((data) => {
+			clearTimeout(timer);
+			switch (chord.feed(data, active())) {
+				case "hold":
+					timer = setTimeout(() => chord.expire(), CHORD_TIMEOUT_MS);
+					timer.unref?.();
+					return { consume: true };
+				case "send":
+					void sendNow(ctx);
+					return { consume: true };
+				default:
+					return undefined;
+			}
+		});
+		unsubscribe = () => {
+			clearTimeout(timer);
+			stopUnsubscribe();
+		};
+
+		ctx.ui.setWidget("send-now", (_tui, theme) => {
+			const paint = safeThemePaint(theme);
+			let cache: { key: string; lines: string[] } | undefined;
+			return {
+				render: (width: number) => {
+					const shown = queued();
+					const key = `${width}:${shown}`;
+					if (cache?.key === key) return cache.lines;
+					const lines = shown ? [truncateLine(paint("dim", ` ↳ ${SEND_NOW_HINT}`), width)] : [];
+					cache = { key, lines };
+					return lines;
+				},
+				invalidate: () => {
+					cache = undefined;
+				},
+			};
+		});
+	});
+}

package/extensions/session-title/index.ts

@@ -27,6 +27,7 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { withReasoningFallback } from "../lib/model-policy.ts";
 import { pickEconomicalContainedModel } from "../lib/model-tier.ts";
 import { sessionOutlivesTurn } from "../lib/notifications.ts";
+import { isUserRun } from "../lib/prompt-options.ts";
 import { recordUsage } from "../lib/usage-bus.ts";
 import { firstUserText, isNameableText, parseTitle, SESSION_TITLE_PROMPT, sessionTitleInput } from "./title.ts";
 
@@ -61,6 +62,8 @@ export default function sessionTitleExtension(pi: ExtensionAPI) {
 		// message never changes, so it is examined once: a first message that is
 		// not prose (a breadcrumb, a slash command sent as text) leaves the
 		// session unnamed rather than re-scanning the entries every turn.
+		// A run an extension opened (pi 1.2.0) carries no prompt: wait for the user's.
+		if (!isUserRun(event)) return;
 		attempted = true;
 		const text = firstUserText(ctx.sessionManager.getEntries() as never) ?? event.prompt;
 		if (!isNameableText(text)) return;

package/extensions/session-title/title.ts

@@ -14,6 +14,7 @@
 
 import { LOCAL_COMMAND_TAG_PREFIXES } from "../lib/local-command.ts";
 import { customMessageText } from "../lib/tui-render.ts";
+import { sanitizeTitle } from "../lib/terminal-text.ts";
 
 /** CC's naming instruction (system prompt), verbatim from the 2.1.278 capture. */
 export const SESSION_TITLE_PROMPT =
@@ -86,7 +87,9 @@ function titleFromJson(text: string): string | undefined {
 }
 
 function normalizeTitle(raw: string): string | undefined {
-	const title = raw.replace(/\s+/g, " ").trim();
+	// The title becomes the terminal title inside pi's own OSC 0: an embedded
+	// BEL or ESC would end that sequence and run the rest as terminal output.
+	const title = sanitizeTitle(raw);
 	if (!title || title.length > MAX_TITLE_LENGTH) return undefined;
 	// CC: "Capitalize the first letter of the title."
 	return title[0].toUpperCase() + title.slice(1);

package/extensions/skill/announce.ts

@@ -0,0 +1,30 @@
+/**
+ * What to tell the model when the skill set changes (pure).
+ *
+ * The skills listing is a `first-prepend` reminder on message 1, so once a
+ * request has gone out it is the record every later request in the epoch
+ * replays (extensions/ledger); rewriting it would also break the binding of
+ * every earlier signed thinking block (findings §46). As in Claude Code, a
+ * skill that becomes listable later is announced on the request's tail under
+ * the listing's own header, and a skill that leaves the listing is not
+ * announced: the skill tool refuses it by name. A compaction opens an epoch
+ * and re-lists every skill.
+ */
+
+import { skillListingVisibility } from "../lib/skill-overrides.ts";
+import type { ListedSkill } from "./listing.ts";
+
+/** The header Claude Code puts over its skills listing, initial or later. */
+export const SKILL_LISTING_HEADER = "The following skills are available for use with the Skill tool:";
+
+/**
+ * The names the listing shows. `readable` is the read-the-file framing for a
+ * session without the skill tool, which also leaves out plugin commands and
+ * skills without a file (listing.ts `readableSkillListing`).
+ */
+export function listableSkillNames(skills: ReadonlyArray<ListedSkill & { path?: string; kind?: string }>, readable: boolean): string[] {
+	return skills
+		.filter((skill) => !skill.disableModelInvocation && skillListingVisibility(skill.state) !== "hidden")
+		.filter((skill) => !readable || (!skill.kind && skill.path))
+		.map((skill) => skill.name);
+}

package/extensions/skill/code-review.ts

@@ -0,0 +1,97 @@
+/**
+ * Which `/code-review` body a session gets (pure apart from reading the cell
+ * files). Claude Code no longer has one body: it picks a "cell" by the model
+ * and the effort level, from one table per model family. One Code keys the
+ * same choice by prompt tier:
+ *
+ * - frontier takes Claude Code's default table, the one its Opus 5.5,
+ *   Sonnet 5.5 and Fable sessions use (minimal prompt at medium, inline
+ *   angles at high and xhigh, a verified fan-out at max);
+ * - workhorse, cheap and tiny take its Sonnet 5 table: the long, explicit
+ *   recipe (finder angles fanned out over the Agent tool, a verify vote)
+ *   written for the one model below that line Claude Code tunes a table for.
+ *   Claude Code's default table reaches its older models only because they
+ *   have no table of their own; its medium cell leaves the whole review to
+ *   the model's judgment, which the lower tiers' registers exist to avoid.
+ *
+ * The effort is the level the user typed first (`/code-review high 123`),
+ * else the session's (`/effort`). Claude Code runs Opus 5.5's medium cell as
+ * a background fork; here every cell runs in the session's own turn.
+ *
+ * The cells are Claude Code's text in `skills/code-review/cells/`; the minimal
+ * prompt reports through the JSON array the other cells use, since One Code
+ * has no findings tool. Every cell is followed by One Code's "Arguments and
+ * flags" section.
+ */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { PromptTier } from "../lib/model-tier.ts";
+
+export const REVIEW_EFFORTS = ["low", "medium", "high", "xhigh", "max"] as const;
+export type ReviewEffort = (typeof REVIEW_EFFORTS)[number];
+
+/** Claude Code's default table (`cells/<name>.md`). */
+const DEFAULT_TABLE: Record<ReviewEffort, string> = {
+	low: "low-1-pass-max4",
+	medium: "minimal-prompt",
+	high: "high-8-inline",
+	xhigh: "xhigh-10-inline-sweep",
+	max: "max-5x5-verify-sweep",
+};
+
+/** Claude Code's Sonnet 5 table. */
+const SONNET5_TABLE: Record<ReviewEffort, string> = {
+	low: "low-1-pass-min-files-4",
+	medium: "medium-3x5-verify",
+	high: "high-3x5-recall-verify",
+	xhigh: "xhigh-5x5-verify-sweep",
+	max: "max-5x5-verify-sweep",
+};
+
+export const ARGUMENTS_AND_FLAGS = "arguments-and-flags";
+
+export function codeReviewCell(tier: PromptTier, effort: ReviewEffort): string {
+	return (tier === "frontier" ? DEFAULT_TABLE : SONNET5_TABLE)[effort];
+}
+
+/** The review effort for a session thinking level: below low reads as low, unknown as medium (Claude Code's default). */
+export function reviewEffortFor(thinkingLevel: string | undefined): ReviewEffort {
+	switch (thinkingLevel) {
+		case "off":
+		case "minimal":
+		case "low":
+			return "low";
+		case "high":
+		case "xhigh":
+		case "max":
+			return thinkingLevel;
+		default:
+			return "medium";
+	}
+}
+
+/** A typed level as the first argument (`/code-review high 123`) and what follows it. */
+export function parseCodeReviewArgs(args: string): { effort?: ReviewEffort; rest: string } {
+	const match = /^\s*(\S+)(?:\s+([\s\S]*))?$/.exec(args);
+	const first = match?.[1]?.toLowerCase();
+	if (!first || !(REVIEW_EFFORTS as readonly string[]).includes(first)) return { rest: args.trim() };
+	return { effort: first as ReviewEffort, rest: (match?.[2] ?? "").trim() };
+}
+
+/**
+ * The body for a session: the chosen cell, then the flags section. `args`
+ * comes back without the typed level, which the cell already reflects.
+ */
+export function codeReviewBody(
+	cellsDir: string,
+	tier: PromptTier,
+	thinkingLevel: string | undefined,
+	args: string,
+): { body: string; args: string; cell: string } {
+	const { effort, rest } = parseCodeReviewArgs(args);
+	const cell = codeReviewCell(tier, effort ?? reviewEffortFor(thinkingLevel));
+	// A checkout that turned line endings into CRLF still sends Claude Code's bytes.
+	const read = (name: string) => readFileSync(join(cellsDir, `${name}.md`), "utf-8").replace(/\r\n/g, "\n").trimEnd();
+	return { body: `${read(cell)}\n\n${read(ARGUMENTS_AND_FLAGS)}`, args: rest, cell };
+}