one-code-extension 0.4.1 → 0.5.0

package/extensions/lib/tui-render.ts

@@ -15,8 +15,11 @@
  * every line goes through `truncateLine` — never skip it.
  */
 
+import { isAbsolute, relative } from "node:path";
 import { framesToText, notificationBody, parseNotificationFrames } from "./notifications.ts";
 import { fitPainted, hardWrapColumns, sliceColumns, visibleWidth } from "./text-width.ts";
+import { sanitizeDisplayText } from "./terminal-text.ts";
+import { userDenialKind } from "./user-denial.ts";
 export { notificationBody };
 export { visibleWidth } from "./text-width.ts";
 
@@ -148,6 +151,41 @@ export function cutPlainText(text: string, width: number): string {
 	return `${sliceColumns(text, Math.max(0, width - 1)).text}…`;
 }
 
+/**
+ * Fit a key-hint row (`a · b · c`) into `width` columns by breaking it at its
+ * ` · ` separators onto as many lines as it needs, so a narrow terminal shows
+ * every key instead of cutting the last ones off. A single hint wider than
+ * the row is cut with an ellipsis.
+ */
+export function wrapHints(text: string, width: number, separator = " · "): string[] {
+	if (width <= 0) return [""];
+	if (visibleWidth(text) <= width) return [text];
+	const lines: string[] = [];
+	let current = "";
+	for (const hint of text.split(separator)) {
+		const joined = current ? `${current}${separator}${hint}` : hint;
+		if (!current || visibleWidth(joined) <= width) {
+			current = joined;
+			continue;
+		}
+		lines.push(cutPlainText(current, width));
+		current = hint;
+	}
+	if (current) lines.push(cutPlainText(current, width));
+	return lines;
+}
+
+/**
+ * A panel's key-hint rows: each hint line wrapped at its separators to fit
+ * `width` after `indent`, so no key is cut off on a narrow terminal, and
+ * returned indented (plain; the caller paints). A list panel counts the rows
+ * in its body budget.
+ */
+export function hintLines(hints: string | readonly string[], width: number, indent = ""): string[] {
+	const room = Math.max(1, width - visibleWidth(indent));
+	return (typeof hints === "string" ? [hints] : hints).flatMap((line) => wrapHints(line, room).map((part) => `${indent}${part}`));
+}
+
 /** Cut then pad plain (unpainted) text to exactly `width` terminal columns. */
 export function padPlainText(text: string, width: number): string {
 	const shortened = cutPlainText(text, width);
@@ -172,17 +210,19 @@ export function panelTopRule(paint: (color: string, text: string) => string, wid
  * A rounded, bordered single-line search input, Claude Code style. Returns three
  * lines (top border, the input row, bottom border), already indented one column.
  * The placeholder shows dim until the user types. `paint` colors the border with
- * the "border" token; the query text stays in the default foreground.
+ * the "border" token; the query text stays in the default foreground. `icon`
+ * leads the text (a plain text input passes ""); the box keeps its width.
  */
 export function searchBoxLines(
 	query: string,
 	placeholder: string,
 	paint: (color: string, text: string) => string,
 	width: number,
+	icon = "⌕ ",
 ): string[] {
 	const boxWidth = Math.max(12, width - 2); // one column of margin each side
 	const inner = boxWidth - 2; // space between the vertical borders
-	const label = query ? `⌕ ${query}` : `⌕ ${placeholder}`;
+	const label = `${icon}${query || placeholder}`;
 	const cut = cutPlainText(label, inner - 2); // one space padding each side
 	const content = ` ${cut}${" ".repeat(Math.max(0, inner - 2 - visibleWidth(cut)))} `;
 	const v = paint("border", "│");
@@ -251,6 +291,50 @@ export function wrapPlainText(text: string, width: number): string[] {
 	return out;
 }
 
+/**
+ * Word-aware wrap for prose (task text, assistant text, the dim transcript lines, a plan): breaks at spaces,
+ * hard-breaking only words longer than the width; preserves blank lines. A
+ * line's leading indent stays and its continuation lines hang under it (a
+ * nested list, an indented code line), unless the indent takes half the width.
+ * Plain text in, plain lines out — painting happens after, per line.
+ */
+export function wrapProse(text: string, width: number): string[] {
+	const columns = Math.max(1, width);
+	const out: string[] = [];
+	for (const raw of text.replace(/\r\n/g, "\n").split("\n")) {
+		if (raw.trim() === "") {
+			out.push("");
+			continue;
+		}
+		const lead = /^[ \t]*/.exec(raw)![0];
+		const indent = lead.replace(/\t/g, "  ");
+		const hang = visibleWidth(indent) * 2 < columns ? indent : "";
+		const room = columns - visibleWidth(hang);
+		const push = (part: string) => out.push(`${hang}${part}`);
+		let line = "";
+		for (const word of raw.slice(lead.length).split(" ")) {
+			if (visibleWidth(word) > room) {
+				// A word wider than the screen (path, hash): flush, then hard-break it.
+				// The last chunk becomes the running line so later words can join it.
+				if (line) push(line);
+				const chunks = hardWrapColumns(word, room);
+				line = chunks.pop() ?? "";
+				for (const chunk of chunks) push(chunk);
+				continue;
+			}
+			const candidate = line ? `${line} ${word}` : word;
+			if (visibleWidth(candidate) > room) {
+				push(line);
+				line = word;
+			} else {
+				line = candidate;
+			}
+		}
+		push(line);
+	}
+	return out;
+}
+
 /**
  * Cut a painted line to `width` terminal columns without splitting ANSI escape
  * sequences or a wide/emoji grapheme, ending with an ellipsis and a reset so
@@ -296,13 +380,18 @@ export function linesComponent(build: (width: number) => string[]): TuiComponent
 }
 
 /**
- * A single dim transcript line led by a dim mark ("✻ Cooked for 5m 12s",
+ * A dim transcript line led by a dim mark ("✻ Cooked for 5m 12s",
  * "※ recap: …") — the shared shape behind the turn-duration and recap
- * display-only entries. Width-memoized via linesComponent.
+ * display-only entries. Text wider than the terminal word-wraps under itself
+ * (a hanging indent past the mark) instead of being cut at the edge.
+ * Width-memoized via linesComponent.
  */
 export function dimMarkedLine(theme: unknown, mark: string, text: string): TuiComponent {
 	const paint = safeThemePaint(theme);
-	return linesComponent(() => [`${paint("dim", mark)} ${paint("dim", text)}`]);
+	return linesComponent((width) => {
+		const indent = visibleWidth(mark) + 1;
+		return wrapProse(text, width - indent).map((line, index) => `${index === 0 ? paint("dim", mark) : " ".repeat(indent - 1)} ${paint("dim", line)}`);
+	});
 }
 
 /**
@@ -329,9 +418,9 @@ const PRIMARY_ARG_KEYS = [
 	"task",
 ] as const;
 
-/** Collapse whitespace/newlines so a summary always fits on one line. */
+/** Collapse whitespace/newlines so a summary always fits on one line (control characters removed). */
 function oneLine(text: string, max = 96): string {
-	const flat = text.replace(/\s+/g, " ").trim();
+	const flat = sanitizeDisplayText(text).replace(/\s+/g, " ").trim();
 	return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
 }
 
@@ -445,16 +534,20 @@ export function callLine(
 	bulletColorOverride?: string,
 ): string {
 	const bullet = theme.fg(bulletColorOverride ?? bulletColor(isPartial, isError), "●");
-	const name = theme.bold(label);
-	return summary ? `${bullet} ${name}(${theme.fg("muted", summary)})` : `${bullet} ${name}`;
+	// A label can carry an MCP server's or tool's own name, a summary the model's arguments.
+	const name = theme.bold(sanitizeDisplayText(label));
+	const shown = sanitizeDisplayText(summary);
+	return shown ? `${bullet} ${name}(${theme.fg("muted", shown)})` : `${bullet} ${name}`;
 }
 
 /**
  * `  ⎿  line…` — the result lines. First line carries the elbow, the rest are
  * aligned under it; a `… +N lines` trailer advertises ctrl+o when collapsed.
+ * The text is a tool's output (a shell, an MCP server, a web page), so its
+ * escape sequences and control characters are removed before it is painted.
  */
 export function resultLines(theme: ThemeLike, text: string, expanded: boolean, isError: boolean, maxCollapsed = 5): string[] {
-	const { lines, hidden } = collapseLines(text, expanded, maxCollapsed);
+	const { lines, hidden } = collapseLines(sanitizeDisplayText(text), expanded, maxCollapsed);
 	const color = isError ? "error" : "muted";
 	const out = lines.map((line, i) => (i === 0 ? `  ⎿  ${theme.fg(color, line)}` : `     ${theme.fg(color, line)}`));
 	if (hidden > 0) out.push(`     ${theme.fg("dim", `… +${hidden} lines (${EXPAND_HINT})`)}`);
@@ -471,6 +564,47 @@ export function textContent(result: { content?: Array<{ type: string; text?: str
 		.trim();
 }
 
+/** The file operation a rejected file tool names: "User rejected write to …", "User rejected update to …". */
+export type RejectedFileOp = "write" | "update";
+
+/** Claude Code's transcript line for a call the user rejected with a reason, or for a tool with no line of its own. */
+export const TOOL_USE_REJECTED = "Tool use rejected";
+
+/**
+ * A file tool's `path` for the transcript, as Claude Code shows it: relative to
+ * the working directory when it is absolute, as the model wrote it otherwise.
+ */
+export function displayToolPath(raw: string, cwd: string | undefined): string {
+	if (!cwd || !isAbsolute(raw)) return raw;
+	return relative(cwd, raw) || raw;
+}
+
+/**
+ * The result line for a call the user rejected, or undefined when the result
+ * is not a rejection. The model reads the whole rejection text; the transcript
+ * shows Claude Code's short line instead: "User rejected write to <path>" for a
+ * file tool rejected without a reason, "Tool use rejected" otherwise. A
+ * rejection without a reason also stops the turn, and the turn's own
+ * "Interrupted" line follows it.
+ */
+export function rejectionLine(
+	theme: ThemeLike,
+	result: { content?: Array<{ type: string; text?: string }> },
+	isError: boolean,
+	file?: { op: RejectedFileOp; path: string | undefined },
+): string | undefined {
+	if (!isError) return undefined;
+	const kind = userDenialKind(textContent(result));
+	if (!kind) return undefined;
+	if (kind === "stop" && file?.path) return `  ⎿  ${rejectedFileHead(theme, file.op, file.path)}`;
+	return `  ⎿  ${theme.fg("dim", TOOL_USE_REJECTED)}`;
+}
+
+/** "User rejected <op> to <path>", dimmed with the path in bold: a file tool's reasonless rejection, before the `⎿` elbow. */
+export function rejectedFileHead(theme: ThemeLike, op: RejectedFileOp, path: string): string {
+	return `${theme.fg("dim", `User rejected ${op} to `)}${theme.bold(theme.fg("dim", sanitizeDisplayText(path)))}`;
+}
+
 export interface CcRenderSpec<TArgs = unknown, TDetails = unknown> {
 	/** One-line arg summary shown in parentheses. Default: `summarizeArgs`. */
 	title?: (args: TArgs | undefined) => string | undefined;
@@ -485,6 +619,12 @@ export interface CcRenderSpec<TArgs = unknown, TDetails = unknown> {
 	) => string | undefined;
 	/** Lines shown before the `… +N lines` trailer kicks in. Default 5. */
 	maxCollapsedLines?: number;
+	/**
+	 * Already-painted text (an OSC 8 hyperlink, say) appended to the first
+	 * result line after the result is sanitized. Build it only from values the
+	 * tool controls, never from its output: nothing strips its escapes.
+	 */
+	link?: (result: { details?: TDetails }, isError: boolean) => string | undefined;
 }
 
 /**
@@ -524,15 +664,33 @@ export function ccToolRenderers<TArgs = any, TDetails = any>(
 			theme: ThemeLike,
 			context: { args?: TArgs; isError: boolean },
 		) {
+			const stripped = stripReminderBlocks(result);
+			const rejected = rejectionLine(theme, stripped, context.isError);
+			if (rejected) return linesComponent(() => [rejected]);
 			let text: string | undefined;
 			try {
 				text = spec.result?.(result, context.args, context.isError);
 			} catch {
 				text = undefined;
 			}
-			text ??= textContent(stripReminderBlocks(result));
+			text ??= textContent(stripped);
 			if (!text) return linesComponent(() => []);
-			return linesComponent(() => resultLines(theme, text, options.expanded, context.isError, spec.maxCollapsedLines));
+			let link: string | undefined;
+			try {
+				link = spec.link?.(result, context.isError);
+			} catch {
+				link = undefined;
+			}
+			return linesComponent((width) => {
+				const lines = resultLines(theme, text, options.expanded, context.isError, spec.maxCollapsedLines);
+				if (link && lines.length > 0) {
+					// Truncation drops a cut link's closing escape and leaves the
+					// hyperlink open, so a link that does not fit goes in as plain text.
+					const joined = `${lines[0]} ${link}`;
+					lines[0] = visibleWidth(joined) <= width ? joined : `${lines[0]} ${sanitizeDisplayText(link)}`;
+				}
+				return lines;
+			});
 		},
 	};
 }
@@ -558,6 +716,8 @@ export interface CcWrapOptions<TArgs = any> {
 	 * content below the header (edit's diff preview, shown before approval).
 	 */
 	keepBaseCall?: boolean;
+	/** A file tool: a rejection without a reason reads "User rejected <op> to <path>" (the path from `title`). */
+	rejectedAs?: RejectedFileOp;
 }
 
 /**
@@ -620,6 +780,17 @@ export function stripReminderBlocks<T extends { content?: unknown }>(result: T):
 	return changed ? { ...result, content: kept } : result;
 }
 
+/**
+ * The context pi's built-in renderers get under the wrapper. pi 1.1.0 added
+ * two fields that would change our rows: the shell's `durationMs` prints a
+ * "Took Ns" line Claude Code's rows do not have, and `outputPad` sets the edit
+ * preview's and diff's indent. Hide the first and pin the second to the 1 pi
+ * hard-coded before, so a row looks the same on every pi and setting.
+ */
+function baseContext(context: any, lastComponent: unknown): any {
+	return { ...context, durationMs: undefined, outputPad: 1, lastComponent };
+}
+
 export function ccWrapBuiltinRenderers<TArgs = any>(
 	label: string,
 	base: {
@@ -632,14 +803,16 @@ export function ccWrapBuiltinRenderers<TArgs = any>(
 	renderCall: (args: TArgs, theme: any, context: any) => TuiComponent;
 	renderResult: (result: any, options: { expanded: boolean; isPartial: boolean }, theme: any, context: any) => TuiComponent;
 } {
-	const titleOf = (args: TArgs | undefined): string => {
+	const rawTitle = (args: TArgs | undefined): string | undefined => {
 		try {
-			const custom = opts.title?.(args);
-			if (custom !== undefined) return summarizeArgs(custom);
+			return opts.title?.(args);
 		} catch {
-			// fall through to the generic summary
+			return undefined;
 		}
-		return summarizeArgs(args);
+	};
+	const titleOf = (args: TArgs | undefined): string => {
+		const custom = rawTitle(args);
+		return summarizeArgs(custom !== undefined ? custom : args);
 	};
 
 	return {
@@ -652,7 +825,7 @@ export function ccWrapBuiltinRenderers<TArgs = any>(
 			}
 			let inner: any;
 			try {
-				inner = base.renderCall(args, theme, { ...context, lastComponent: context.state.ccInnerCall });
+				inner = base.renderCall(args, theme, baseContext(context, context.state.ccInnerCall));
 				context.state.ccInnerCall = inner;
 			} catch {
 				return linesComponent(() => [head()]);
@@ -683,9 +856,15 @@ export function ccWrapBuiltinRenderers<TArgs = any>(
 		},
 		renderResult(rawResult: any, options: { expanded: boolean; isPartial: boolean }, theme: ThemeLike, context: any) {
 			const result = stripReminderBlocks(rawResult);
+			const path = rawTitle(context.args);
+			const rejected = rejectionLine(theme, result, context.isError, opts.rejectedAs && {
+				op: opts.rejectedAs,
+				path: path ? displayToolPath(path, context.cwd) : undefined,
+			});
+			if (rejected) return linesComponent(() => [rejected]);
 			let inner: any;
 			try {
-				inner = base.renderResult?.(result, options, theme, { ...context, lastComponent: context.state.ccInnerResult });
+				inner = base.renderResult?.(result, options, theme, baseContext(context, context.state.ccInnerResult));
 				context.state.ccInnerResult = inner;
 			} catch {
 				inner = undefined;
@@ -744,9 +923,9 @@ export function formatFireTime(ms: number): string {
  * `✻ Running scheduled task (Sep 11 12:03pm)` line, the prompt itself under it
  * on ctrl+o (the prompt is the turn's input, verbatim — findings §21).
  */
-export function scheduledTaskComponent(theme: ThemeLike, prompt: string, firedAt: number, expanded: boolean): TuiComponent {
-	const lines = prompt.trim().split("\n");
-	const headline = `Running scheduled task (${formatFireTime(firedAt)})`;
+export function scheduledTaskComponent(theme: ThemeLike, prompt: string, firedAt: number, expanded: boolean, label = "Running scheduled task", suffix = ""): TuiComponent {
+	const lines = sanitizeDisplayText(prompt).trim().split("\n");
+	const headline = `${label} (${formatFireTime(firedAt)})${suffix}`;
 	return linesComponent(() => {
 		if (!expanded) {
 			return [`${theme.fg("dim", "✻")} ${theme.fg("dim", headline)}${theme.fg("dim", ` (+${lines.length} lines, ${EXPAND_HINT})`)}`];
@@ -764,10 +943,48 @@ export function scheduledTaskComponent(theme: ThemeLike, prompt: string, firedAt
  * wire frames (`<task-notification>`, the agent-message envelope) are
  * model-only; `parseNotificationFrames` takes them apart for display.
  */
-export function notificationComponent(theme: ThemeLike, text: string, expanded: boolean): TuiComponent {
+/** An agent task's `<summary>`: `Agent "<description>" finished` / `failed: …` / `was stopped…` (findings §24). */
+function isAgentCompletion(summary: string): boolean {
+	return summary.startsWith('Agent "');
+}
+
+/**
+ * A notification that opens a session's first turn goes out as a user message
+ * (lib/notifications.ts, "First turn of a session"), and pi draws a user
+ * message as markdown with no per-message renderer, so the wire frames would
+ * show in full. This is that message's display text: the headlines
+ * `notificationComponent` shows collapsed, one paragraph per frame, without
+ * the expand hint (a user message does not expand). `undefined` when the text
+ * is not wholly harness frames, so a real prompt renders as typed.
+ */
+export function notificationUserMarkdown(text: string): string | undefined {
+	// Every user message renders through here: a typed prompt skips the parse.
+	if (!text.includes("<task-notification>") && !text.includes("<agent-message ")) return undefined;
+	const parsed = parseNotificationFrames(sanitizeDisplayText(text));
+	if (parsed.length === 0 || parsed.some((frame) => frame.kind === "text")) return undefined;
+	const frames = parsed.filter((frame) => !(frame.kind === "task" && frame.pointer));
+	return (frames.length > 0 ? frames : parsed)
+		.map((frame) => {
+			if (frame.kind === "agent-message") return `› Message from @${frame.from}`;
+			if (frame.kind === "task" && isAgentCompletion(frame.summary)) {
+				const took = frame.durationMs === undefined ? "" : ` · ${formatDuration(0, frame.durationMs)}`;
+				return `● ${oneLine(frame.summary)}${took}`;
+			}
+			return frame.kind === "task" ? `✳ ${oneLine(frame.summary)}` : "";
+		})
+		.join("\n\n");
+}
+
+/**
+ * `agentName` names the agent a message comes from (its task id is the
+ * wire address): the headline reads `› Message from @<name>`, falling back to
+ * the address when the name is unknown.
+ */
+export function notificationComponent(theme: ThemeLike, text: string, expanded: boolean, agentName?: (from: string) => string | undefined): TuiComponent {
 	// An agent's completion pointer says nothing the message above it does not;
-	// CC's transcript shows the message alone.
-	const parsed = parseNotificationFrames(text);
+	// CC's transcript shows the message alone. Bodies carry shell output and
+	// agent replies, so control characters are removed before parsing.
+	const parsed = parseNotificationFrames(sanitizeDisplayText(text));
 	const frames = parsed.filter((frame) => !(frame.kind === "task" && frame.pointer));
 	if (frames.length === 0) frames.push({ kind: "text", text: framesToText(parsed) });
 	const dim = (s: string) => theme.fg("dim", s);
@@ -785,8 +1002,19 @@ export function notificationComponent(theme: ThemeLike, text: string, expanded:
 				// the header, then the body as delivered (preamble, indented report),
 				// indented under it, when expanded. The guard is never shown.
 				const bodyLines = frame.body.split("\n");
-				if (expanded) out.push(dim(`› Message from ${frame.from}`), ...body(bodyLines));
-				else out.push(dim(`› Message from @${frame.from}`) + hint(bodyLines));
+				const sender = agentName?.(frame.from) ?? frame.from;
+				if (expanded) out.push(dim(`› Message from ${sender}`), ...body(bodyLines));
+				else out.push(dim(`› Message from @${sender}`) + hint(bodyLines));
+				continue;
+			}
+			if (frame.kind === "task" && isAgentCompletion(frame.summary)) {
+				// Claude Code 2.1.283's line for an agent's turn: `⏺ Agent "<desc>"
+				// finished · 3s`, the dot tinted by outcome, no expand hint (findings
+				// §40). ctrl+o still shows the report under it.
+				const dot = theme.fg(frame.status === "failed" ? "error" : frame.status === "completed" ? "success" : "dim", "●");
+				const took = frame.durationMs === undefined ? "" : dim(` · ${formatDuration(0, frame.durationMs)}`);
+				out.push(`${dot} ${oneLine(frame.summary)}${took}`);
+				if (expanded && frame.body) out.push(...body(frame.body.split("\n")));
 				continue;
 			}
 			const headline = frame.kind === "task" ? frame.summary : oneLine(frame.text.split("\n")[0] ?? "");

package/extensions/lib/turn-budget-layout.ts

@@ -0,0 +1,143 @@
+/**
+ * Claude Code's per-turn `<total_tokens>` placements (pure). One Code stores
+ * the line the way it always has, so a resumed session rebuilds the same
+ * bytes: a raw marker block after the text of every user message after the
+ * first (context-budget's `sticky-append`), and the countdown as its own
+ * block at the end of every tool result (persisted by system-reminder). Two
+ * steps turn those into Claude Code's shapes:
+ *
+ * - at `context` time, while a tool result's blocks are still separate and
+ *   keyed by its call id (`resolveCountdowns`): on a model that takes a
+ *   mid-conversation system message the countdown block leaves the result and
+ *   its value is kept by call id; elsewhere it is framed, a blank line after
+ *   the output once pi joins the blocks (Claude Code's Haiku shape);
+ * - on the final body (`withTurnBudgetMessages`): on a system-role model a
+ *   system message with the line follows each later prompt and each
+ *   tool-result message (the lowest countdown it carries), and on first-party
+ *   Fable the `clear_at` nudge follows the latter; elsewhere the framed block
+ *   goes before the text of each later prompt, with a trailing newline.
+ *
+ * Nothing is parsed out of joined text, so a tool's own output that contains
+ * such a line is never touched.
+ */
+
+import { reseatMessageMark } from "./anthropic-payload.ts";
+import { wrapReminder } from "./reminders.ts";
+import { messagesKey, type SystemRoleLayout, systemMessage, type WireMessage, type WirePart, byWireCallId, withoutParts } from "./system-role.ts";
+
+/** The stored line, exactly. */
+const LINE = /^<total_tokens>(\d+) tokens left<\/total_tokens>$/;
+
+/** Claude Code's Fable nudge after a tool result's budget message. */
+export const CLEAR_AT_NUDGE =
+	"First privately list what you need next; then request every item that doesn't depend on another's result in this one response.";
+
+type StoredBlock = { type?: string; text?: string };
+type StoredMessage = { role: string; toolCallId?: string; content?: unknown };
+
+/**
+ * The context-time step over pi's messages: each tool result's countdown block
+ * (the last whole block that is the line) is lifted out on a system-role model,
+ * its value kept under the call id, or framed elsewhere. Returns the messages
+ * (the input when nothing changed) and the countdowns by call id.
+ */
+export function resolveCountdowns<T extends StoredMessage>(messages: T[], systemRole: boolean): { messages: T[]; left: Map<string, number> } {
+	const left = new Map<string, number>();
+	let changed = false;
+	const out = messages.map((message) => {
+		if (message.role !== "toolResult" || !Array.isArray(message.content) || !message.toolCallId) return message;
+		const blocks = message.content as StoredBlock[];
+		const at = blocks.findLastIndex((block) => block?.type === "text" && typeof block.text === "string" && LINE.test(block.text));
+		if (at === -1) return message;
+		const line = blocks[at].text as string;
+		changed = true;
+		if (systemRole) {
+			left.set(message.toolCallId, Number(LINE.exec(line)?.[1]));
+			return { ...message, content: blocks.filter((_, index) => index !== at) };
+		}
+		return { ...message, content: blocks.map((block, index) => (index === at ? { ...block, text: `\n${wrapReminder(line)}` } : block)) };
+	});
+	return { messages: changed ? out : messages, left };
+}
+
+export interface TurnBudgetOptions {
+	/** The wire shape. */
+	shape: SystemRoleLayout;
+	/** True on a model that takes a mid-conversation system message. */
+	systemRole: boolean;
+	/** The role a system message takes on the OpenAI APIs. */
+	role: "system" | "developer";
+	/** The countdowns `resolveCountdowns` lifted, by call id. */
+	left: ReadonlyMap<string, number>;
+	/** Send Claude Code's `clear_at` nudge after a tool result's budget message (first-party Fable). */
+	nudge?: boolean;
+	/** False when the budget is off: no prompt carries a marker, so a user's own tag stays text. */
+	markers?: boolean;
+}
+
+/** The call ids a wire message answers: Anthropic `tool_result` blocks, an OpenAI output item or tool message. */
+function answeredCalls(message: WireMessage): string[] {
+	if (message?.role === "user" && Array.isArray(message.content)) {
+		return (message.content as WirePart[]).flatMap((part) => (part?.type === "tool_result" && typeof part.tool_use_id === "string" ? [part.tool_use_id] : []));
+	}
+	if (message?.type === "function_call_output" && typeof message.call_id === "string") return [message.call_id];
+	if (message?.role === "tool" && typeof message.tool_call_id === "string") return [message.tool_call_id];
+	return [];
+}
+
+export function withTurnBudgetMessages(payload: Record<string, unknown>, opts: TurnBudgetOptions): Record<string, unknown> | undefined {
+	const key = messagesKey(opts.shape);
+	const messages = payload[key];
+	if (!Array.isArray(messages)) return undefined;
+	const out: WireMessage[] = [];
+	let changed = false;
+	/** The lowest countdown of the tool results not yet followed by their message. */
+	let pending: number | undefined;
+	/** The first user message carries the context stack, never a marker (context-budget's `skipStackCarrier`). */
+	let stackCarrierSeen = false;
+	for (let i = 0; i < messages.length; i++) {
+		let message = messages[i] as WireMessage;
+		const after: WireMessage[] = [];
+		const stackCarrier = !stackCarrierSeen && message?.role === "user";
+		if (stackCarrier) stackCarrierSeen = true;
+		// A later prompt's marker: a system message after it, or the framed block before its text.
+		// The marker comes after the user's text, so the last match is it: a
+		// prompt that is itself such a tag stays the user's, and so does the
+		// first prompt, which has no marker to find.
+		if (opts.markers !== false && !stackCarrier && message?.role === "user" && Array.isArray(message.content)) {
+			const parts = message.content as WirePart[];
+			const at = parts.findLastIndex((part) => typeof part?.text === "string" && LINE.test(part.text));
+			// The marker ends the message, so it carries pi's cache mark; withoutParts keeps it.
+			const rest = at === -1 ? undefined : withoutParts(parts, (_, index) => index === at);
+			if (rest) {
+				const line = parts[at].text as string;
+				if (opts.systemRole) {
+					message = { ...message, content: rest };
+					after.push(systemMessage(opts.shape, opts.role, line));
+				} else {
+					message = { ...message, content: [{ type: opts.shape === "responses" ? "input_text" : "text", text: `${wrapReminder(line)}\n` }, ...rest] };
+				}
+			}
+		}
+		if (opts.systemRole) {
+			for (const id of answeredCalls(message)) {
+				const value = byWireCallId(opts.left, id);
+				if (value !== undefined) pending = pending === undefined ? value : Math.min(pending, value);
+			}
+			// On the OpenAI APIs a batch of results is a run of items; one message follows the run.
+			const next = messages[i + 1] as WireMessage | undefined;
+			const runContinues = opts.shape !== "anthropic" && (next?.type === "function_call_output" || next?.role === "tool");
+			if (pending !== undefined && !runContinues) {
+				after.push(systemMessage(opts.shape, opts.role, `<total_tokens>${pending} tokens left</total_tokens>`));
+				if (opts.nudge) {
+					after.push(opts.shape === "anthropic" ? ({ role: "system", content: CLEAR_AT_NUDGE, clear_at: "next_user_message" } as WireMessage) : systemMessage(opts.shape, opts.role, CLEAR_AT_NUDGE));
+				}
+				pending = undefined;
+			}
+		}
+		if (message !== messages[i] || after.length > 0) changed = true;
+		out.push(message, ...after);
+	}
+	if (!changed) return undefined;
+	return { ...payload, [key]: opts.shape === "anthropic" ? reseatMessageMark(out) : out };
+}

package/extensions/lib/update-check.mjs

@@ -23,13 +23,26 @@ export const APP_PACKAGE = "@one-ai/one-code";
 export const EXTENSION_PACKAGE = "one-code-extension";
 /** The Homebrew formula (IsuruMaduranga/homebrew-one-ai), renamed from one-code at 0.3.0. */
 export const HOMEBREW_FORMULA = "onecode";
-/** How each install method upgrades the app; the doctor and the update notice quote these. */
+/**
+ * How each install method upgrades One Code; the doctor and the update notice
+ * quote these. On the user's own pi a bare `pi update` updates pi itself and
+ * skips packages, so the package is named.
+ */
 export const UPGRADE_COMMANDS = {
 	npm: `npm install -g ${APP_PACKAGE}`,
 	brew: `brew upgrade ${HOMEBREW_FORMULA}`,
-	"pi-package": "pi update",
+	"pi-package": `pi update npm:${EXTENSION_PACKAGE}`,
 };
 
+/**
+ * The upgrade command for a running install: the pi package's, or the app's by
+ * the install method the launcher published (`ONECODE_INSTALL_METHOD`).
+ */
+export function upgradeCommandFor(install, env = process.env) {
+	if (install !== "app") return UPGRADE_COMMANDS["pi-package"];
+	return env.ONECODE_INSTALL_METHOD === "brew" ? UPGRADE_COMMANDS.brew : UPGRADE_COMMANDS.npm;
+}
+
 /**
  * The registry packument for a package (scoped slash percent-encoded). The
  * full document, not `/latest`: its `time` map dates every version, which

package/extensions/lib/usage-bus.ts

@@ -22,7 +22,7 @@ export const USAGE_CHANNEL = "one-code:usage-recorded";
  */
 export const USAGE_ENTRY_TYPE = "one-code:usage";
 
-export type UsageSource = "subagent" | "classifier" | "reader" | "recap" | "session-title" | "setup" | "btw";
+export type UsageSource = "subagent" | "classifier" | "reader" | "web-fetch" | "web-search" | "recap" | "session-title" | "setup" | "btw";
 
 export interface UsageRecord {
 	source: UsageSource;

package/extensions/lib/user-denial.ts

@@ -0,0 +1,38 @@
+/**
+ * The result a tool call gets when the user rejects it (pure): Claude Code's
+ * denial text, shared by the permission prompt and plan-mode approval. With
+ * the user's typed reason it carries their words (decisions/tools.md, "Denial
+ * feedback carries the user's words") in Claude Code's "To tell you how to
+ * proceed, the user said:" form; without one it tells the model to stop and
+ * wait for the user.
+ */
+
+const REJECTED =
+	"The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file).";
+
+const MEMORY_NOTE =
+	"Note: The user's next message may contain a correction or preference. Pay close attention — if they explain what went wrong or how they'd prefer you to work, consider saving that to memory for future sessions.";
+
+const STOP = "STOP what you are doing and wait for the user to tell you how to proceed.";
+const USER_SAID = "To tell you how to proceed, the user said:\n";
+
+/** Claude Code's rejection text, with the user's reason when they typed one. */
+export function userDenialText(feedback?: string): string {
+	const said = feedback?.trim();
+	const next = said ? `${USER_SAID}${said}` : STOP;
+	return `${REJECTED} ${next}\n\n${MEMORY_NOTE}`;
+}
+
+/**
+ * Whether a tool result is the user's rejection, for the transcript: `stop`
+ * when they rejected without a reason, `reason` when they gave one, undefined
+ * for anything else. The transcript shows a short line for either (Claude
+ * Code's); the model still reads the whole text.
+ */
+export function userDenialKind(text: string): "stop" | "reason" | undefined {
+	if (!text.startsWith(`${REJECTED} `)) return undefined;
+	const next = text.slice(REJECTED.length + 1);
+	if (next.startsWith(STOP)) return "stop";
+	if (next.startsWith(USER_SAID)) return "reason";
+	return undefined;
+}