one-code-extension 0.4.1 → 0.6.0

package/extensions/subagents/live-runs.ts

@@ -11,7 +11,9 @@
  */
 
 import { basename } from "node:path";
+import { unwrapUserMessage } from "../lib/agent-view.ts";
 import { cutPlainText, firstNonEmptyLine } from "../lib/tui-render.ts";
+import { sanitizeDisplayText } from "../lib/terminal-text.ts";
 import { normalizeToolName } from "../permissions/matcher.ts";
 import { emptyUsage, sumUsage, type UsageTotals } from "./usage.ts";
 
@@ -22,7 +24,7 @@ export type FinishOutcome = boolean | "stopped";
 
 /** One rendered block of a child's transcript, mirroring the main-session marks. */
 export interface TranscriptBlock {
-	kind: "task" | "text" | "call" | "result";
+	kind: "task" | "text" | "call" | "result" | "user";
 	/** For a call: the tool name; for a result: the tool it belongs to. */
 	tool?: string;
 	/** Rendered short content (args summary, result summary, or assistant text). */
@@ -79,6 +81,8 @@ export interface LiveRun {
 	parentTaskId?: string;
 	/** Nesting level: 0 = spawned by main, 1 = spawned by a child (CC's `└` rows). */
 	depth: number;
+	/** The user opened this run's view: `/tasks` then lists it under Completed (findings §40). */
+	viewed?: boolean;
 }
 
 /** Keep memory bounded for long/chatty children; the viewer scrolls the tail. */
@@ -129,6 +133,8 @@ export function deriveActivity(toolName: string | undefined, args: unknown, last
 export interface RegisterInput {
 	taskId: string;
 	name: string;
+	/** Claude Code's `description` (AgentRunRecord.description): the row and chip label when set. */
+	description?: string;
 	agentType: string;
 	model?: string;
 	thinking?: string;
@@ -163,20 +169,22 @@ export class LiveRunRegistry {
 	}
 
 	register(input: RegisterInput): void {
+		// Display state only: the prompt reaches the terminal, so its control characters go.
+		const task = sanitizeDisplayText(input.task);
 		const run: LiveRun = {
 			taskId: input.taskId,
 			name: input.name,
 			agentType: input.agentType,
 			model: input.model,
 			thinking: input.thinking,
-			label: deriveLabel(input.task, input.name),
+			label: input.description ? cutPlainText(sanitizeDisplayText(input.description), 60) : deriveLabel(task, input.name),
 			status: "running",
 			startedAt: input.startedAt,
 			toolCalls: 0,
 			tokens: emptyUsage(),
 			activity: "Starting…",
 			// The child's prompt opens the transcript, like Claude Code's viewer.
-			blocks: input.task.trim() ? [{ kind: "task", text: input.task }] : [],
+			blocks: task.trim() ? [{ kind: "task", text: task }] : [],
 			baseToolCalls: 0,
 			baseTokens: emptyUsage(),
 			parentTaskId: input.parentTaskId,
@@ -203,7 +211,10 @@ export class LiveRunRegistry {
 		// stats() keeps them instead of regressing the displayed cost.
 		run.baseToolCalls = run.toolCalls;
 		run.baseTokens = { ...run.tokens };
-		if (task.trim()) this.block(taskId, { kind: "task", text: task });
+		// A message the user typed in the agent's view is its `❯` row, not a task.
+		const typed = unwrapUserMessage(task);
+		if (typed !== undefined) this.block(taskId, { kind: "user", text: typed });
+		else if (task.trim()) this.block(taskId, { kind: "task", text: task });
 		this.changed(taskId);
 		return true;
 	}
@@ -229,7 +240,7 @@ export class LiveRunRegistry {
 	setActivity(taskId: string, activity: string): void {
 		const run = this.byId.get(taskId);
 		if (!run) return;
-		run.activity = activity;
+		run.activity = sanitizeDisplayText(activity);
 		this.wake(run);
 		this.changed(taskId);
 	}
@@ -238,11 +249,20 @@ export class LiveRunRegistry {
 	block(taskId: string, block: TranscriptBlock): void {
 		const run = this.byId.get(taskId);
 		if (!run) return;
-		run.blocks.push(block);
+		// Display state only: the text reaches the terminal, so its control characters go.
+		run.blocks.push({ ...block, text: sanitizeDisplayText(block.text) });
 		if (run.blocks.length > MAX_BLOCKS) run.blocks.splice(0, run.blocks.length - MAX_BLOCKS);
 		this.changed(taskId);
 	}
 
+	/** The user opened this run's view (it joins `/tasks`' Completed list once settled). */
+	markViewed(taskId: string): void {
+		const run = this.byId.get(taskId);
+		if (!run || run.viewed) return;
+		run.viewed = true;
+		this.changed(taskId);
+	}
+
 	/** The in-flight assistant message (or undefined at message_end). O(1) per delta. */
 	setStreaming(taskId: string, message: StreamingMessage | undefined): void {
 		const run = this.byId.get(taskId);

package/extensions/subagents/model-select.ts

@@ -33,8 +33,8 @@
  *   same-provider profile serves instead.
  * - A configured default or agent-file model that cannot resolve degrades, with
  *   a notice naming the knob, to the automatic same-provider pick — the
- *   cheapest contained model at the session's capability floor, the SAME floor
- *   the auto-mode classifier applies (`capableContainedCandidates`) — and only
+ *   cheapest contained model in the session's tier or above, the SAME rule
+ *   the auto-mode classifier applies (`sameTierContainedCandidates`) — and only
  *   then to the session model. Only an explicit `inherit` names the session
  *   model outright. A bad *per-call* request first falls through to the agent's
  *   own model and the configured default (running the subagent on its intended
@@ -61,7 +61,8 @@ import {
 	pricedInput,
 	supportsImageInput,
 } from "../lib/model-policy.ts";
-import { atLeastTier, capableContainedCandidates, economicalContainedCandidates, intrinsicTier, type PromptTier } from "../lib/model-tier.ts";
+import { pairedModel } from "../lib/model-pairings.ts";
+import { atLeastTier, economicalContainedCandidates, intrinsicTier, type PromptTier, sameTierContainedCandidates } from "../lib/model-tier.ts";
 
 /**
  * Cross-extension channel carrying the resolved default subagent model, so the
@@ -135,7 +136,7 @@ export interface ResolveInput {
 	 * upgraded with a notice (a standing setting or agent-file model). The
 	 * `/subagent` set command leaves this false — a saved default may be meant for
 	 * another (text) session, and is gated at spawn instead. See
-	 * `docs/decisions/model-policy.md`.
+	 * `working-docs/decisions/model-policy.md`.
 	 */
 	requireImageInput?: boolean;
 }
@@ -206,7 +207,7 @@ interface AliasResolution {
  * Resolve a Claude Code alias within the session's provider family: by name
  * first (preferring undated alias ids, then the newest id), else as the tier
  * the alias names — the cheapest contained model at or above it
- * (`economicalContainedCandidates` order: never tiny, prior-generation or
+ * (`economicalContainedCandidates` order: never tiny, superseded or
  * tool-less; cheap → workhorse → frontier, then price), `frontier` meaning the
  * session model itself, the strongest model the user chose on this provider.
  * Never off-family: "sonnet" on a Codex session is the cheapest workhorse-class
@@ -236,9 +237,6 @@ function resolveAlias(
 	const tier = ALIAS_TIER[alias];
 	// The session model carries the caller's own modality, so frontier is always safe.
 	if (tier === "frontier") return { model: sessionModel, how: "tier" };
-	// Name-class only, deliberately: an explicit alias asks for a *class* of model,
-	// so a measured pass (which lets a strong flash serve the automatic default)
-	// does not lift a lean-named model into "sonnet" here.
 	const byTier = economicalContainedCandidates(available, sessionModel, contained, requireImageInput).find((model) => atLeastTier(intrinsicTier(model), tier));
 	return byTier ? { model: byTier, how: "tier" } : undefined;
 }
@@ -398,23 +396,26 @@ export function resolveSubagentModel(input: ResolveInput): SubagentModelResoluti
 	// Automatic selection is a cost optimisation, so it needs price evidence:
 	// with the session price unknown there is no demonstrable saving, and picking
 	// a cheap-tier model could silently *upgrade* an (unpriced) cheap session. The
-	// floor-gated selector — the cheapest same-provider model at the session's
-	// capability floor (workhorse-or-better for a workhorse-or-better session,
-	// Claude Code's min(main, sonnet); never `tiny`) — is the SAME one the
-	// auto-mode classifier uses, so a session screens and delegates on one
-	// model. A delegated worker writes code and calls tools for many turns; a
-	// weaker one spends the saving on retries (2026-09-11 — before, subagents
-	// took the cheapest capable model with no floor). It excludes unpriced/opaque
-	// providers by construction, which subsumes the old dynamic-selection gate;
-	// those degrade to the session model below.
+	// selector — the cheapest same-provider model in the session's tier or above
+	// (never `tiny`) — is the SAME rule the auto-mode classifier uses. A
+	// delegated worker writes code and calls tools for many turns; a weaker one
+	// spends the saving on retries. It excludes unpriced and uncatalogued
+	// models by construction; those sessions degrade to the session model below.
 	if (sessionModel && !suppressAutomatic) {
-		// `strict` requires a genuinely cheaper model and yields nothing when the
-		// session price is unknown, so a cheap-tier pick never silently upgrades an
-		// unpriced session. Reuse the `contained` set computed above for the hot path.
-		// With an Artificial Analysis snapshot (lib/capability-index.ts) the floor
-		// is measured — coding index ≥ min(session, Sonnet 5), no tolerance —
-		// and passers rank by price; unscored candidates are judged by name-class tier.
-		const cheaper = capableContainedCandidates(available, sessionModel, "subagent", { strict: true, contained, requireImageInput })[0];
+		// The pairing table speaks first for the models it names
+		// (lib/model-pairings.ts): a measured smaller model of the session's
+		// vendor, never dearer than the session where both are priced. Reuse the
+		// `contained` set computed above for the hot path.
+		const paired = pairedModel("subagent", available, sessionModel, { contained, requireImageInput });
+		if (paired?.kind === "session") return { model: sessionModel, source: "session", notices };
+		if (paired) return { model: paired.model, source: "automatic", notices };
+		// Otherwise the candidates are always strictly cheaper than the session
+		// model, and there are none when the session price is unknown, so a
+		// cheap-tier pick never silently upgrades an unpriced session.
+		// Experimental builds are never auto-selectable (model-tier.ts
+		// isAutoSelectable); a moving alias stays allowed here (Mistral serves
+		// most models only as `-latest`).
+		const cheaper = sameTierContainedCandidates(available, sessionModel, { contained, requireImageInput })[0];
 		if (cheaper) return { model: cheaper, source: "automatic", notices };
 	}
 
@@ -427,7 +428,7 @@ export function resolveSubagentModel(input: ResolveInput): SubagentModelResoluti
  * gated: the per-call `model` field is the one input the main model chooses for
  * itself. User knobs (setting, env var, agent files the user installed,
  * "inherit") are never gated — naming a model is choosing it — and the
- * automatic default can only ever pick cheaper. With either price unknown the
+ * automatic default never picks a dearer model. With either price unknown the
  * gate stays open: a gate that fails closed on an unpriced catalog blocks the
  * feature outright.
  *
@@ -567,6 +568,18 @@ export function settingOverrideNotice({ sessionModel, defaultModel, defaultSourc
 	);
 }
 
+/**
+ * The one-shot that corrects the menu once message 1 is frozen: a model this
+ * account refused, and the subagent default it leaves (undefined: the
+ * session's own model).
+ */
+export function refusedModelNote(refused: string, defaultModel: Model<Api> | undefined): string {
+	return (
+		`Model ${refused} is not usable on this account, so automatic selection skips it and the subagent/workflow \`model\` field should not name it. ` +
+		`The subagent default is now ${defaultModel ? spec(defaultModel) : "this session's model"}.`
+	);
+}
+
 /** The every-turn reminder body. Kept short: its tokens are paid on every call. */
 export function subagentModelsReminder(options: MenuOptions): string {
 	const menu = subagentModelMenu(options);

package/extensions/subagents/outcome.ts

@@ -5,6 +5,7 @@
  */
 
 import type { ChildAction } from "../auto-mode/actions.ts";
+import type { FireConversation } from "../lib/agent-cron.ts";
 import type { UsageTotals } from "./usage.ts";
 
 export const OUTPUT_CAP = 50_000;
@@ -20,7 +21,7 @@ export interface ForkIsolation {
  * entire transcript; without this, a weaker model tends to abandon its assigned
  * task and continue (or confabulate about) the inherited topic — then its output
  * returns to the parent looking like independent confirmation. See
- * docs/features/tools/records/tool-ambiguity-hardening.md (fork confabulation).
+ * working-docs/features/tools/records/tool-ambiguity-hardening.md (fork confabulation).
  *
  * With `isolation`, the fork is told that its working directory moved: the
  * inherited system prompt and transcript name the parent's checkout in every
@@ -30,7 +31,7 @@ export interface ForkIsolation {
  */
 export function forkTaskMessage(task: string, isolation?: ForkIsolation): string {
 	const lines = [
-		"You are a forked subagent. The conversation above is inherited context, for reference only — do NOT continue its open threads, verify its claims, or act on its plans. Do ONLY the task below; your final message is returned to the parent conversation verbatim, as data. You cannot see the parent's background tasks: its task ids are not addressable from here.",
+		"You are a forked subagent. The conversation above is inherited context, for reference only — do NOT continue its open threads, verify its claims, or act on its plans. Do ONLY the task below; the report you hand back through SubagentHandback is returned to the parent conversation verbatim, as data. You cannot see the parent's background tasks: its task ids are not addressable from here.",
 	];
 	if (isolation) {
 		lines.push(
@@ -72,6 +73,8 @@ export interface RpcChildHandle {
 	 * the caller never reports a delivery that did not happen.
 	 */
 	send(message: string): Promise<"started" | "steered">;
+	/** The agent's own session: a cron fire's `/loop` sentinel reads and records its delivery there (lib/agent-cron.ts). */
+	conversation: FireConversation;
 	busy(): boolean;
 	exited(): boolean;
 	/**

package/extensions/subagents/panel-keys.ts

@@ -1,41 +1,83 @@
 /**
  * Pure key decoding for the below-editor panel — Claude Code's agent-tree
- * keys. Their meaning depends on whether a transcript view is open (index.ts
- * owns that split): with no view open, arrows select and Enter opens the
- * selected agent's transcript; while a view IS open the panel is in "read"
- * mode, where arrows scroll it a line at a time, PageUp/PageDown scroll a page,
- * `switch` (Tab) retargets to the next agent, `left` (←) closes the transcript
- * back to agent selection, and Enter closes it. `x` stops, the `ctrl+x ctrl+k`
- * chord stops all, esc leaves. `left` also serves the shell-panel stages (back)
- * and `space` (close); the agents branch uses `left` in read mode (above) and
- * treats `space` like typing. Raw terminal bytes in, intents out — no side
- * effects, fully unit-testable.
+ * keys: arrows select, Enter views the selected agent (or `main`), PageUp and
+ * PageDown scroll an open view, `x` stops, the `ctrl+x ctrl+k` chord stops
+ * all, esc hands focus back to the editor (index.ts owns what each does; an
+ * open view stays open while the editor addresses its agent). Raw terminal
+ * bytes in, intents out — no side effects, fully unit-testable. Keys are named
+ * through `lib/key-input.ts`, so the legacy, kitty and modifyOtherKeys
+ * encodings decode alike, and a kitty key release (sent after every press) is
+ * never mistaken for typing.
  */
 
-const UP = new Set(["\x1b[A", "\x1bOA"]);
-const DOWN = new Set(["\x1b[B", "\x1bOB"]);
-const LEFT = new Set(["\x1b[D", "\x1bOD"]);
+import { isKeyRelease, keyId, keyText } from "../lib/key-input.ts";
 
-export type StripKey = "up" | "down" | "left" | "space" | "switch" | "open" | "leave" | "stop" | "stopAll" | "pageUp" | "pageDown";
+export type StripKey = "up" | "down" | "open" | "leave" | "stop" | "stopAll" | "pageUp" | "pageDown";
+
+const STRIP_KEYS: Record<string, StripKey> = {
+	up: "up",
+	down: "down",
+	enter: "open",
+	escape: "leave",
+	pageUp: "pageUp",
+	pageDown: "pageDown",
+};
 
 /**
- * Decoder with chord state: `ctrl+x` (\x18) arms the chord (consumed, no key);
- * a following `ctrl+k` (\x0b) completes it into `stopAll`; any other key
- * cancels the chord and is decoded normally. A byte that decodes to nothing
- * (typing) is the caller's signal to drop focus and let the byte through.
+ * Decoder with chord state: `ctrl+x` arms the chord (consumed, no key); a
+ * following `ctrl+k` completes it into `stopAll`; any other key cancels the
+ * chord and is decoded normally. A key release decodes to `release`, which
+ * changes nothing (the caller lets it through). Any other chunk that decodes
+ * to nothing (typing) is the caller's signal to drop focus and let the byte
+ * through.
  */
-export function decodeStripKey(data: string, chordArmed: boolean): { key?: StripKey; chordArmed: boolean } {
-	if (chordArmed && data === "\x0b") return { key: "stopAll", chordArmed: false };
-	if (data === "\x18") return { chordArmed: true };
-	if (UP.has(data)) return { key: "up", chordArmed: false };
-	if (DOWN.has(data)) return { key: "down", chordArmed: false };
-	if (LEFT.has(data)) return { key: "left", chordArmed: false };
-	if (data === "\t") return { key: "switch", chordArmed: false };
-	if (data === " ") return { key: "space", chordArmed: false };
-	if (data === "\r" || data === "\n") return { key: "open", chordArmed: false };
-	if (data === "\x1b") return { key: "leave", chordArmed: false };
-	if (data === "x" || data === "X") return { key: "stop", chordArmed: false };
-	if (data === "\x1b[5~") return { key: "pageUp", chordArmed: false };
-	if (data === "\x1b[6~") return { key: "pageDown", chordArmed: false };
+export function decodeStripKey(data: string, chordArmed: boolean): { key?: StripKey; chordArmed: boolean; release?: true } {
+	if (isKeyRelease(data)) return { chordArmed, release: true };
+	const id = keyId(data);
+	if (chordArmed && id === "ctrl+k") return { key: "stopAll", chordArmed: false };
+	if (id === "ctrl+x") return { chordArmed: true };
+	const key = id ? STRIP_KEYS[id] : undefined;
+	if (key) return { key, chordArmed: false };
+	const text = keyText(data);
+	if (text === "x" || text === "X") return { key: "stop", chordArmed: false };
 	return { chordArmed: false };
 }
+
+/** A ↓ press (in any encoding, never its release): the key that enters the strip. */
+export function isStripEntryKey(data: string): boolean {
+	return !isKeyRelease(data) && keyId(data) === "down";
+}
+
+/** The slice of pi's editor the strip reads (structural; every member optional). */
+export interface EditorLike {
+	getLines?(): string[];
+	getCursor?(): { line: number; col: number };
+	isShowingAutocomplete?(): boolean;
+	/** pi-tui's history position: -1 when no recalled entry is shown. */
+	historyIndex?: unknown;
+}
+
+/**
+ * Whether ↓ belongs to the strip rather than the editor. In a draft the
+ * editor needs ↓ to move the cursor down, to walk forward through recalled
+ * history, and to move in the autocomplete list, so the strip takes ↓ only
+ * with the cursor on the draft's last line, no history entry shown and no
+ * autocomplete open (Claude Code's footer rule). An editor without the
+ * expected methods keeps the old behaviour (the strip takes ↓).
+ */
+export function editorYieldsDown(editor: unknown): boolean {
+	if (!editor || typeof editor !== "object") return true;
+	const e = editor as EditorLike;
+	try {
+		if (e.isShowingAutocomplete?.()) return false;
+		// Read-only use of a private pi-tui field; if a pi bump renames it, the
+		// history case falls back to taking ↓ (the behaviour before this check).
+		if (typeof e.historyIndex === "number" && e.historyIndex > -1) return false;
+		const lines = e.getLines?.();
+		const cursor = e.getCursor?.();
+		if (!lines || !cursor) return true;
+		return cursor.line >= lines.length - 1;
+	} catch {
+		return true;
+	}
+}