one-code-extension 0.1.3 → 0.3.0

package/extensions/auto-mode/model-picker.ts

@@ -15,6 +15,8 @@
  * assume (see model-select.ts).
  */
 
+import { truncateLine } from "../lib/tui-render.ts";
+
 export interface PickerEntry {
 	provider: string;
 	id: string;
@@ -143,7 +145,7 @@ export function modelPickerComponent(
 	tui: { requestRender(): void },
 	theme: unknown,
 	done: (choice: PickerEntry | null) => void,
-): { render(): string[]; handleInput(data: string): void; invalidate(): void } {
+): { render(width: number): string[]; handleInput(data: string): void; invalidate(): void } {
 	const paint: Paint = (color, text) => {
 		const themed = theme as { fg?(c: string, t: string): string } | undefined;
 		try {
@@ -155,23 +157,34 @@ export function modelPickerComponent(
 	let query = "";
 	let index = 0;
 	let filtered = options.entries;
+	// pi calls render(width) every frame and the picker repaints per keystroke;
+	// memoize by width and clear on any state change so a wide default subtitle
+	// (115 columns) never reaches the wire uncut — an overwide line crashes pi
+	// in regular TUI mode (TUI-REVIEW H2).
+	let cache: { width: number; lines: string[] } | undefined;
 	return {
-		render: () => [
-			"",
-			...renderModelPicker(
-				{
-					entries: filtered,
-					index,
-					query,
-					total: options.entries.length,
-					current: options.current,
-					title: options.title,
-					subtitle: options.subtitle,
-				},
-				paint,
-			),
-			"",
-		],
+		render: (width: number) => {
+			if (cache && cache.width === width) return cache.lines;
+			const lines = [
+				"",
+				...renderModelPicker(
+					{
+						entries: filtered,
+						index,
+						query,
+						total: options.entries.length,
+						current: options.current,
+						title: options.title,
+						subtitle: options.subtitle,
+					},
+					paint,
+					width,
+				),
+				"",
+			];
+			cache = { width, lines };
+			return lines;
+		},
 		handleInput: (data: string) => {
 			const key = decodePickerKey(data);
 			if (!key) return;
@@ -184,27 +197,36 @@ export function modelPickerComponent(
 				filtered = filterEntries(options.entries, query);
 				index = 0;
 			}
+			cache = undefined;
 			tui.requestRender();
 		},
-		invalidate: () => {},
+		invalidate: () => {
+			cache = undefined;
+		},
 	};
 }
 
-export function renderModelPicker(view: PickerView, paint: Paint): string[] {
+/** Key hint, kept on its own line so it survives at narrow widths. */
+const PICKER_HINT = "type to filter · ↑/↓ · enter · esc";
+/** Default privacy note for the classifier picker (the key hint rides its own line below). */
+const CLASSIFIER_SUBTITLE = "It reads your prompts and CLAUDE.md — picking another provider sends them there.";
+
+export function renderModelPicker(view: PickerView, paint: Paint, width = Infinity): string[] {
 	const maxVisible = view.maxVisible ?? 10;
+	// Every line is cut to `width` — pi-tui crashes the whole app on a rendered
+	// line wider than the terminal (TUI-REVIEW H2). The default Infinity leaves
+	// lines uncut (truncateLine returns them unchanged) for unit tests.
+	const cut = (line: string): string => truncateLine(line, width);
 	const lines: string[] = [];
-	lines.push(paint("accent", view.title ?? "Select the auto-mode classifier model"));
-	lines.push(
-		paint(
-			"dim",
-			view.subtitle ??
-				"It reads your prompts and CLAUDE.md — picking another provider sends them there. type to filter · ↑/↓ · enter · esc",
-		),
-	);
-	lines.push(`  filter: ${view.query}${paint("dim", "▏")}`);
+	lines.push(cut(paint("accent", view.title ?? "Select the auto-mode classifier model")));
+	lines.push(cut(paint("dim", view.subtitle ?? CLASSIFIER_SUBTITLE)));
+	// The key hint is always its own line, so a narrow terminal never clips the
+	// only place the keys are documented.
+	lines.push(cut(paint("dim", `  ${PICKER_HINT}`)));
+	lines.push(cut(`  filter: ${view.query}${paint("dim", "▏")}`));
 
 	if (view.entries.length === 0) {
-		lines.push(paint("warning", "  (no available model matches)"));
+		lines.push(cut(paint("warning", "  (no available model matches)")));
 		return lines;
 	}
 
@@ -216,10 +238,10 @@ export function renderModelPicker(view: PickerView, paint: Paint): string[] {
 			.filter(Boolean)
 			.join("  ");
 		const suffix = annotations ? `  ${paint("dim", annotations)}` : "";
-		lines.push(at === view.index ? `${paint("accent", `❯ ${spec}`)}${suffix}` : `  ${spec}${suffix}`);
+		lines.push(cut(at === view.index ? `${paint("accent", `❯ ${spec}`)}${suffix}` : `  ${spec}${suffix}`));
 	}
 	if (view.entries.length > maxVisible || view.entries.length < view.total) {
-		lines.push(paint("dim", `  ${view.entries.length} of ${view.total} models${view.query ? " match" : ""}`));
+		lines.push(cut(paint("dim", `  ${view.entries.length} of ${view.total} models${view.query ? " match" : ""}`)));
 	}
 	return lines;
 }

package/extensions/auto-mode/model-select.ts

@@ -26,22 +26,22 @@
  * match" is arbitrary. Cost is the one signal every provider carries.
  */
 
-import type { Api, Model } from "@earendil-works/pi-ai";
+import type { Api, AssistantMessage, Model } from "@earendil-works/pi-ai";
 import {
+	crossesProvider,
 	findConfigured,
-	findRoleProfileModel,
-	hintRank,
+	isStaleContainmentStamp,
 	modelIdentity,
-	modelsContainedToSession,
-	pricedInput,
+	modelSpec as spec,
 } from "../lib/model-policy.ts";
+import { capableContainedCandidates } from "../lib/model-tier.ts";
 
 export { findConfigured } from "../lib/model-policy.ts";
 
 export interface Candidate {
 	model: Model<Api>;
 	/** How this candidate was arrived at, for the notice shown to the user. */
-	source: "configured" | "role-profile" | "cheapest-in-provider" | "session";
+	source: "configured" | "economical" | "session";
 }
 
 export interface SelectInput {
@@ -50,92 +50,141 @@ export interface SelectInput {
 	sessionModel: Model<Api> | undefined;
 	/** `autoMode.classifierModel`, if set. May name any provider. */
 	configured?: string;
+	/**
+	 * The containment identity (`modelIdentity().containment`) the `classifierModel`
+	 * setting was stamped for when set via `/auto-mode model`. When it differs from
+	 * the current session's containment, a cross-provider setting is treated as
+	 * stale (set for a session since left) and overridden with a warning — the same
+	 * shape as the subagent `subagentModelSetFor` stamp. Undefined for a hand-edited
+	 * setting.
+	 */
+	configuredSetForContainment?: string;
+}
+
+/** A user-facing selection notice, tagged so an informational one is not shown as a warning. */
+export interface ClassifierNotice {
+	level: "info" | "warning";
+	text: string;
 }
 
 /**
- * The ordered candidate chain. More than one is returned so a candidate that
- * turns out to be unusable at call time (not entitled on this account, withdrawn
- * by the provider) can be stepped over instead of failing every tool call — the
- * same shape as pi's subagent `fallbackModels`.
+ * The ordered candidate chain plus any user-facing notices. More than one
+ * candidate is returned so one that turns out to be unusable at call time (not
+ * entitled on this account, withdrawn by the provider) can be stepped over
+ * instead of failing every tool call — the same shape as pi's subagent
+ * `fallbackModels`.
  *
  * The chain always ends at the session model when there is one, so auto mode
  * degrades to "correct but not cheap" rather than to "broken".
+ *
+ * The automatic pick is the SAME floor-gated selector the subagent default uses
+ * (`capableContainedCandidates`): the cheapest same-provider model (cheap →
+ * workhorse → frontier, never `tiny`) at or above `automaticTierFloor` — a
+ * session on a workhorse-or-better model is screened by a workhorse-or-better
+ * model, Claude Code's `min(main, sonnet)`. `docs/decisions/auto-mode.md`
+ * measured the same `rm -rf` grading stage-1 62 on Sonnet and ~22 on Haiku —
+ * "a weak classifier is a weak boundary" — yet until 2026-09-05 the selector
+ * picked Haiku even when the session itself was Sonnet, so the gate's threshold
+ * behaviour depended on which model happened to be cheapest
+ * (PERMISSIONS-REVIEW-2026-09-05 M6). A cheap session keeps a cheap screener
+ * (nothing cheaper and capable exists), and `autoMode.classifierModel`
+ * overrides either way. The `tiny` exclusion is the capability floor
+ * `auto-mode.md` recorded as still-missing. Since 2026-09-11 subagents share
+ * the floor, so a session screens and delegates on one model.
+ *
+ * The floor governs the AUTOMATIC pick only; the terminal fallback is never
+ * refused, so the chain is empty only when there is no session model and nothing
+ * available at all.
  */
-export function classifierCandidates({ available, sessionModel, configured }: SelectInput): Candidate[] {
+export function classifierCandidates({
+	available,
+	sessionModel,
+	configured,
+	configuredSetForContainment,
+}: SelectInput): { candidates: Candidate[]; notices: ClassifierNotice[] } {
 	const candidates: Candidate[] = [];
+	const notices: ClassifierNotice[] = [];
 	const push = (model: Model<Api> | undefined, source: Candidate["source"]) => {
 		if (!model) return;
 		if (candidates.some((entry) => entry.model.provider === model.provider && entry.model.id === model.id)) return;
 		candidates.push({ model, source });
 	};
 
-	// 1. What the user asked for, wherever it lives. Naming a provider is choosing it.
-	if (configured) push(findConfigured(available, configured), "configured");
-
-	/**
-	 * Containment is shared with subagents. For a direct provider it is the
-	 * provider itself; gateways additionally preserve a reliable route/family;
-	 * opaque routers expose only the session model.
-	 */
-	const inProvider = sessionModel ? modelsContainedToSession(available, sessionModel) : [];
-
-	/**
-	 * No candidate may cost more per token than the model doing the actual work.
-	 * Screening a call more expensively than making it is indefensible, and it
-	 * happened: on an OpenRouter session at `z-ai/glm-4.6` ($0.50/M) the table's
-	 * `anthropic/claude-haiku-4.5` ($1/M) was selected, because this ceiling was
-	 * originally applied only to the cost-ranked branch and not to the table.
-	 */
-	const sessionPrice = sessionModel ? pricedInput(sessionModel) : undefined;
-	const withinBudget = (model: Model<Api>) => {
-		if (sessionPrice === undefined) return true;
-		const price = pricedInput(model);
-		return price === undefined || price <= sessionPrice;
-	};
+	// 1. What the user asked for. Naming a provider is choosing it — but a setting
+	//    stamped for a provider this session has since left is stale and overridden
+	//    with a warning (parity with the subagent setting); a genuine cross-provider
+	//    choice made for THIS session is honored with an announcement, because the
+	//    classifier reads the user's prompts and CLAUDE.md.
+	const resolved = configured ? findConfigured(available, configured) : undefined;
+	if (resolved) {
+		if (sessionModel && crossesProvider(resolved, sessionModel)) {
+			if (isStaleContainmentStamp(configuredSetForContainment, sessionModel)) {
+				notices.push({
+					level: "warning",
+					text:
+						`autoMode.classifierModel ${spec(resolved)} was set for a different provider than this session (${spec(sessionModel)}); ` +
+						"a same-provider model screens calls instead. Re-set it with /auto-mode model on this session to use it here.",
+				});
+			} else {
+				// Informational, not a warning: the user deliberately set this for this
+				// session, so it is doing exactly what they asked.
+				notices.push({
+					level: "info",
+					text:
+						`autoMode.classifierModel ${spec(resolved)} is a different provider than this session (${spec(sessionModel)}) — ` +
+						"it reads your prompts and CLAUDE.md, so those go to that provider. It was set for this session, so it is honored.",
+				});
+				push(resolved, "configured");
+			}
+		} else {
+			push(resolved, "configured");
+		}
+	}
 
-	// 2. A reviewed small-but-capable model for this provider/family. The
-	//    profile is short and applied to the live catalog; price alone never
-	//    promotes a model into the classifier role.
+	// 2. The cheapest capable same-provider model, no dearer than the work being
+	//    screened — screening a call more expensively than making it is
+	//    indefensible. The shared gate excludes `tiny`, unpriced/opaque rows, and
+	//    the session model itself, so an unpriced provider yields nothing here and
+	//    the session model (step 3) screens the calls.
+	//    With an Artificial Analysis snapshot (an optional user key —
+	//    lib/capability-index.ts) the floor is MEASURED: a candidate whose coding
+	//    index reaches min(session, Sonnet 5), on the thinking-off variant the
+	//    classifier actually runs, screens — Claude Code's min(main, Sonnet) taken
+	//    literally, so a flash-class model that measurably matches its vendor's
+	//    flagship may screen it. A measured failure is never admitted; an
+	//    unscored candidate (no key, no confirmed match) is judged by the
+	//    name-class tier floor below, exactly as before the snapshot existed.
 	if (sessionModel) {
-		// Reuse the containment set computed above instead of recomputing it inside.
-		push(findRoleProfileModel(available, sessionModel, "classifier", withinBudget, inProvider), "role-profile");
+		for (const model of capableContainedCandidates(available, sessionModel, "classifier")) push(model, "economical");
 	}
 
-	// 3. The cheapest genuinely-priced model in the provider.
-	const cheaper = inProvider
-		.map((model) => ({ model, price: pricedInput(model) }))
-		.filter((entry): entry is { model: Model<Api>; price: number } => entry.price !== undefined)
-		.filter((entry) => withinBudget(entry.model))
-		.sort((a, b) => a.price - b.price || hintRank(a.model) - hintRank(b.model));
-	const cheapest = cheaper[0]?.model;
-
-	/**
-	 * 4. The session's own model, ahead of the cost-ranked pick.
-	 *
-	 * Price is not evidence of suitability, and a name is barely better. On
-	 * OpenRouter the cheapest model in the catalog is `inclusionai/ling-2.6-flash`
-	 * at $0.01/M, which would otherwise become the security boundary for being
-	 * cheap. An attempt to gate that on the name carrying a known small-model word
-	 * failed on the same example — "flash" is in the name, because any vendor may
-	 * put it there; the word means "someone called this small", not "this family is
-	 * known good".
-	 *
-	 * So nothing chosen on price alone leads. Providers that *are* vetted get their
-	 * saving from the table above (which covers OpenRouter and every mainstream
-	 * provider); anywhere else the model the user already trusted for the real work
-	 * screens the calls — correct, merely not cheap — and `classifierModel` is
-	 * there for someone who wants otherwise.
-	 */
+	// 3. The session's own model: always correct, just not cheap. Terminal
+	//    fallback, so the gate degrades to screening on it rather than to broken.
+	//    No tier floor here: a floor that refused a `tiny` session model would
+	//    disarm auto mode on exactly the sessions least able to do without it,
+	//    on a price-and-name heuristic rather than measured competence. The
+	//    circumvention of a permission rule that motivated one is handled by
+	//    giving the classifier the user's own deny rules to judge by effect
+	//    (permissions/rule-prose.ts), not by picking a different screener.
 	push(sessionModel, "session");
 
-	// 5. Last resort, for when even the session model cannot serve.
-	push(cheapest, "cheapest-in-provider");
-
 	// Nothing configured and no session model (a headless run with a bare
 	// registry) — take anything available rather than refusing outright.
 	if (candidates.length === 0) push(available[0], "session");
 
-	return candidates;
+	// A configured spec that matched nothing available would otherwise fall through
+	// in silence, leaving the user believing their setting is in force.
+	if (configured && !resolved) {
+		const instead = candidates[0];
+		notices.push({
+			level: "warning",
+			text:
+				`autoMode.classifierModel is set to "${configured}", which is not an available model — check the name and that its provider is authenticated.` +
+				(instead ? ` Auto mode is using ${describeCandidate(instead)} instead.` : ""),
+		});
+	}
+
+	return { candidates, notices };
 }
 
 /**
@@ -149,30 +198,52 @@ export function classifierCandidates({ available, sessionModel, configured }: Se
  * model for the whole session over a blip. Misreading billing as transient
  * merely retries and blocks noisily; misreading a blip as permanent bricks the
  * candidate — so uncertainty goes to transient.
+ *
+ * "not supported" is here because a plan/entitlement refusal is often phrased
+ * that way rather than as a 403: Codex answers a classifier call on
+ * `gpt-5.3-codex-spark` with "The 'gpt-5.3-codex-spark' model is not supported
+ * when using Codex with a ChatGPT account." Without the match that read as a
+ * substantive error, so the chain never stepped past the cheapest-capable pick
+ * and auto mode blocked every call of the session (findings §10.19). It is
+ * anchored to the word "model" ahead of it, because plenty of REQUEST-shape
+ * complaints are phrased the same way ("streaming is not supported",
+ * "response_format is not supported for this model") and those are fixable
+ * quirks of one call, not a model this account can never use.
  */
 export function isModelUnavailableError(message: string): boolean {
-	return /\b(401|403|404)\b|not_found|not found|does not exist|(no|have|lacks?)\s+access|unauthoriz|forbidden|invalid[_ -]?model|model[_ -]?not|unsupported[_ -]?model|no such model|entitl|insufficient[_ -]?quota|exceeded your current quota|billing/i.test(
+	return /\b(401|403|404)\b|not_found|not found|does not exist|(no|have|lacks?)\s+access|unauthoriz|forbidden|invalid[_ -]?model|model[_ -]?not|unsupported[_ -]?model|\bmodel\b[^.\n]{0,40}not supported|no such model|entitl|insufficient[_ -]?quota|exceeded your current quota|billing/i.test(
 		message,
 	);
 }
 
 /** One-line description for the notice and `/auto-mode config`. */
 export function describeCandidate(candidate: Candidate): string {
-	const name = `${candidate.model.provider}/${candidate.model.id}`;
+	const name = spec(candidate.model);
+	const where = modelIdentity(candidate.model).profile ?? candidate.model.provider;
 	switch (candidate.source) {
 		case "configured":
 			return `${name} (from autoMode.classifierModel)`;
-		case "role-profile": {
-			const where = modelIdentity(candidate.model).profile ?? candidate.model.provider;
-			return `${name} (classifier profile for ${where})`;
-		}
-		case "cheapest-in-provider": {
-			const where = modelIdentity(candidate.model).profile ?? candidate.model.provider;
-			return `${name} (cheapest available within ${where})`;
-		}
-		case "session": {
-			const where = modelIdentity(candidate.model).profile ?? candidate.model.provider;
-			return `${name} (this session's model — no vetted smaller model within ${where})`;
-		}
+		case "economical":
+			return `${name} (cheapest model within ${where} that meets the capability floor — measured coding index when an Artificial Analysis snapshot is cached, else the session's tier)`;
+		case "session":
+			return `${name} (this session's model — nothing cheaper within ${where} meets the capability floor)`;
 	}
 }
+
+/** Concatenated text blocks of a one-shot reply (classifier verdicts, setup drafts). */
+export function replyText(reply: AssistantMessage): string {
+	return reply.content
+		.filter((block): block is { type: "text"; text: string } => block.type === "text")
+		.map((block) => block.text)
+		.join("");
+}
+
+/**
+ * Some pi builds resolve a per-provider baseUrl alongside the API key; it is
+ * not in every published version of the auth type, so it is read defensively
+ * and, when present, carried onto the model for the call.
+ */
+export function withAuthBaseUrl(model: Model<Api>, auth: unknown): Model<Api> {
+	const baseUrl = (auth as { baseUrl?: string }).baseUrl;
+	return baseUrl ? ({ ...model, baseUrl } as Model<Api>) : model;
+}

package/extensions/auto-mode/paths.ts

@@ -17,6 +17,7 @@
 
 import { lstatSync, readlinkSync, realpathSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { expandTilde } from "../lib/paths.ts";
 
 /**
  * Tools whose calls write to a path. Lives here — the lowest shared layer both
@@ -29,6 +30,17 @@ export function isWritingTool(toolName: string): boolean {
 	return WRITING_TOOLS.has(toolName);
 }
 
+/**
+ * The path a file tool call targets (`path` for pi's built-ins, `file_path`
+ * for Claude Code-shaped calls, `notebook_path` for notebook_edit), or
+ * undefined. The one place that knows the field names, shared by every
+ * path-based gate.
+ */
+export function pathArgument(input: Record<string, unknown> | undefined): string | undefined {
+	const path = input?.path ?? input?.file_path ?? input?.notebook_path;
+	return typeof path === "string" ? path : undefined;
+}
+
 /** Case-folded on darwin/win32, where the filesystem is case-insensitive. */
 function normalize(target: string): string {
 	const normalized = resolve(target).replace(/\\/g, "/").replace(/\/+$/, "");
@@ -103,7 +115,7 @@ export function isWithin(base: string, target: string): boolean {
  */
 export function toAbsolute(cwd: string, token: string, home: string): string {
 	if (token === "~") return home;
-	if (token.startsWith("~/")) return resolve(home, token.slice(2));
+	if (token === "~" || token.startsWith("~/")) return resolve(expandTilde(token, home));
 	if (isAbsolute(token)) return resolve(token);
 	return resolve(cwd, token);
 }

package/extensions/auto-mode/pause.ts

@@ -76,6 +76,14 @@ export class PauseTracker {
 		return this.paused;
 	}
 
+	/** Forget everything — a new session (`/clear`, `/resume`) starts with a clean record. */
+	reset(): void {
+		this.consecutive = 0;
+		this.total = 0;
+		this.paused = false;
+		this.denials.length = 0;
+	}
+
 	/** Most recent first, for the `/permissions` "recently denied" listing. */
 	recentDenials(limit = 10): Denial[] {
 		return this.denials.slice(-limit).reverse();