one-code-extension 0.4.1 → 0.5.0

package/extensions/doctor/models.ts

@@ -4,23 +4,30 @@
  * The doctor does not re-decide anything: it calls the SAME resolvers the
  * session uses — `resolveSubagentModel` for delegated work, `classifierCandidates`
  * for auto mode's screener, `pickEconomicalContainedModel` for the web-fetch /
- * recap reader, `resolveModelTier` for the prompt register — and reports their
- * answers next to their sources. A user who asks "why did my subagent run on
- * Haiku?" gets the resolver's own notice, not a paraphrase.
+ * recap reader — and reports their answers next to their sources. The prompt
+ * register comes from the session's frozen tier, or `resolveModelTier` in the
+ * CLI. A user who asks "why did my subagent run on Haiku?" gets the resolver's
+ * own notice, not a paraphrase.
  */
 
 import type { Api, Model } from "@earendil-works/pi-ai";
 import { modeCycleKey } from "../lib/keys.ts";
 import { loadAutoModeConfig } from "../auto-mode/config.ts";
 import { classifierCandidates, describeCandidate, type ClassifierNotice } from "../auto-mode/model-select.ts";
-import { ATTRIBUTION, capabilityFloor, configuredCapabilityKey, type FloorRole, type FloorVerdict, KEY_ADVICE, snapshotAgeMs } from "../lib/capability-index.ts";
-import { modelSpec, pricedInput } from "../lib/model-policy.ts";
+import { chosenModelWarnings, type ChosenModelWarning } from "../lib/model-choice-warnings.ts";
+import { loadCatalogSources, readCatalogRefreshEnabled } from "../lib/model-catalog-data.ts";
+import { autoSelectSkipReason, catalogModelFor } from "../lib/model-catalog.ts";
+import { DAY_MS, modelsContainedToSession, modelSpec, pricedInput, supportsImageInput } from "../lib/model-policy.ts";
+import { newerModelSuggestion, type NewerModelSuggestion } from "../lib/newer-model.ts";
+import { oneCodeSettingsPath, readSuggestNewerModels } from "../lib/one-code-settings.ts";
+import { oneCodeStateDir } from "../lib/paths.ts";
 import {
-	currentCapabilitySnapshot,
+	classifyModelTier,
 	intrinsicTier,
 	pickEconomicalContainedModel,
 	type PromptTier,
 	resolveModelTier,
+	servedCatalogIds,
 	tierOverride,
 } from "../lib/model-tier.ts";
 import { applicableSubagentDefault, loadSubagentDefault, type SubagentDefault } from "../subagents/default-model.ts";
@@ -30,6 +37,7 @@ import { contextLabel, type Finding, priceLabel, type ReportLine, type ReportSec
 export interface ModelFacts {
 	session?: Model<Api>;
 	sessionTier?: PromptTier;
+	newerModel?: NewerModelSuggestion;
 	/** The register the system prompt is built in — the tier, or a CC_PROMPT_TIER override. */
 	promptTier: PromptTier;
 	promptTierForced: boolean;
@@ -37,20 +45,18 @@ export interface ModelFacts {
 	subagentConfigured?: SubagentDefault;
 	/** The configured default exists but does not apply to this session (Claude Code's env var on a non-Claude model). */
 	subagentConfiguredInapplicable: boolean;
+	/** What the configured subagent default costs (newer model, far weaker than the session), when it is in effect. */
+	subagentWarnings: ChosenModelWarning[];
+	/** `configured`: the user's `autoMode.classifierModel`, as written. */
 	classifier: { model?: Model<Api>; description?: string; notices: ClassifierNotice[]; configured?: string };
 	reader?: { model: Model<Api>; via: "tier" | "session" };
-	/**
-	 * The optional Artificial Analysis snapshot behind the measured capability
-	 * floor (lib/capability-index.ts): whether a key is configured, the snapshot's
-	 * age, and the verdict each automatic pick was judged on.
-	 */
-	capability: {
-		keyConfigured: boolean;
-		snapshot?: { fetchedAt: string; rows: number };
-		subagent?: FloorVerdict;
-		classifier?: FloorVerdict;
-		reader?: FloorVerdict;
-	};
+	/** The session model's own tier and the rule that decided it (`classifyModelTier`, no CC_PROMPT_TIER). */
+	tierReason?: string;
+	/** Whether the public model catalogs know the session model, and why automatic picks skip it, if they do. */
+	inCatalog: boolean;
+	skipReason?: string;
+	/** The model catalogs in use (lib/model-catalog-data.ts). */
+	catalog: { fetchedAt: string; refreshed: boolean; refreshEnabled: boolean };
 }
 
 export const TIER_LABEL: Record<PromptTier, string> = {
@@ -64,35 +70,42 @@ export function collectModelFacts(available: Model<Api>[], session: SessionView,
 	const sessionModel = session.model;
 	const configuredAll = loadSubagentDefault(home, env);
 	const configured = applicableSubagentDefault(configuredAll, sessionModel);
-	const subagent = resolveSubagentModel({ configuredDefault: configured, sessionModel, available });
+	// The live resolver's image gate (subagents/index.ts), so the preview names what a spawn gets.
+	const subagent = resolveSubagentModel({ configuredDefault: configured, sessionModel, available, requireImageInput: supportsImageInput(sessionModel) });
+	const suggestNewer = readSuggestNewerModels(home, env);
 	const autoConfig = loadAutoModeConfig(home);
 	const chain = classifierCandidates({
 		available,
 		sessionModel,
 		configured: autoConfig.classifierModel,
 		configuredSetForContainment: autoConfig.classifierModelSetFor,
+		suggestNewer,
 	});
 	const first = chain.candidates[0];
 	const reader = pickEconomicalContainedModel(available, sessionModel);
-	const snapshot = currentCapabilitySnapshot();
-	const verdict = (pick: Model<Api> | undefined, role: FloorRole): FloorVerdict | undefined =>
-		snapshot && sessionModel && pick && modelSpec(pick) !== modelSpec(sessionModel) ? capabilityFloor(snapshot, pick, sessionModel, role) : undefined;
-	const capability: ModelFacts["capability"] = {
-		keyConfigured: configuredCapabilityKey(home, env) !== undefined,
-		snapshot: snapshot ? { fetchedAt: snapshot.fetchedAt, rows: snapshot.rows.length } : undefined,
-		subagent: verdict(subagent.source === "automatic" ? subagent.model : undefined, "subagent"),
-		classifier: verdict(first?.source === "economical" ? first.model : undefined, "classifier"),
-		reader: verdict(reader?.via === "tier" ? reader.model : undefined, "reader"),
-	};
+	const sources = loadCatalogSources(oneCodeStateDir(env, home));
+	const entry = sessionModel ? catalogModelFor(sessionModel) : undefined;
 	return {
-		capability,
+		catalog: {
+			fetchedAt: sources.modelsDev.fetchedAt,
+			refreshed: sources.refreshed === true,
+			refreshEnabled: readCatalogRefreshEnabled(oneCodeSettingsPath(home, env), env),
+		},
+		tierReason: sessionModel ? classifyModelTier(sessionModel, {}, "capability").reason : undefined,
+		inCatalog: entry !== undefined,
+		skipReason: entry && sessionModel ? autoSelectSkipReason(entry, servedCatalogIds(modelsContainedToSession(available, sessionModel))) : undefined,
+		newerModel: suggestNewer ? newerModelSuggestion(available, sessionModel) : undefined,
 		session: sessionModel,
 		sessionTier: sessionModel ? intrinsicTier(sessionModel) : undefined,
-		promptTier: resolveModelTier(sessionModel, env),
+		promptTier: session.promptTier ?? resolveModelTier(sessionModel, env),
 		promptTierForced: tierOverride(env) !== undefined,
 		subagent,
 		subagentConfigured: configuredAll,
 		subagentConfiguredInapplicable: configuredAll !== undefined && configured === undefined,
+		subagentWarnings:
+			subagent.source === "default" && subagent.model
+				? chosenModelWarnings({ available, sessionModel, chosen: subagent.model, role: "subagent", suggestNewer })
+				: [],
 		classifier: {
 			model: first?.model,
 			description: first ? describeCandidate(first) : undefined,
@@ -107,8 +120,8 @@ const SUBAGENT_SOURCE: Record<SubagentModelResolution["source"], string> = {
 	call: "named per call",
 	agent: "from the agent file",
 	default: "the configured default",
-	automatic: "automatic: cheapest capable model on this provider, cheaper than the main model",
-	session: "the main model — nothing cheaper and capable on this provider",
+	automatic: "automatic: cheapest model on this provider in the main model's tier or above, cheaper than it",
+	session: "the main model — nothing cheaper on this provider in its tier or above",
 };
 
 export function modelsSection(facts: ModelFacts, session: SessionView, findings: Finding[]): ReportSection {
@@ -133,11 +146,25 @@ export function modelsSection(facts: ModelFacts, session: SessionView, findings:
 					: "";
 	const details = [priceLabel(main), contextLabel(main.contextWindow), sourceNote].filter(Boolean).join(" · ");
 	lines.push({ text: `Main: ${modelSpec(main)} — ${details}`, level: "ok" });
+	if (facts.newerModel) {
+		findings.push({ level: "warn", text: facts.newerModel.text, fix: facts.newerModel.fix });
+	}
 	lines.push({
 		text: `Prompt register: ${TIER_LABEL[facts.promptTier]}${facts.promptTierForced ? " (forced by CC_PROMPT_TIER)" : ""}`,
 		indent: 1,
 		level: "dim",
 	});
+	if (facts.sessionTier && facts.tierReason) {
+		lines.push({ text: `Tier: ${facts.sessionTier} — ${facts.tierReason}`, indent: 1, level: "dim" });
+	}
+	if (facts.skipReason) lines.push({ text: `Automatic picks skip this model: ${facts.skipReason}`, indent: 1, level: "dim" });
+	if (!facts.inCatalog && facts.tierReason !== "modelTiers setting" && facts.sessionTier !== "frontier") {
+		findings.push({
+			level: "warn",
+			text: `${modelSpec(main)} is not in the public model catalogs (models.dev, OpenRouter), so its tier is a guess (${facts.sessionTier}) and automatic picks never choose it.`,
+			fix: `Set its tier in ~/.onecode/settings.json: { "modelTiers": { "${modelSpec(main)}": "workhorse" } } (frontier, workhorse, cheap or tiny).`,
+		});
+	}
 	if (session.thinkingLevel) lines.push({ text: `Effort: ${session.thinkingLevel} (/effort or shift+tab to change)`, indent: 1, level: "dim" });
 
 	const sub = facts.subagent;
@@ -150,11 +177,23 @@ export function modelsSection(facts: ModelFacts, session: SessionView, findings:
 				indent: 1,
 				level: facts.subagentConfiguredInapplicable ? "warn" : "dim",
 			});
+			// A warning line is a finding too, so the summary never says "No issues found" beside it.
+			if (facts.subagentConfiguredInapplicable) {
+				findings.push({
+					level: "warn",
+					text: `${knob} sets "${facts.subagentConfigured.spec}" for subagents, but it applies only when the main model is a Claude model, so it is not used here.`,
+					fix: "Choose the subagent model with /subagent (it writes subagentModel in ~/.onecode/settings.json), or unset the variable.",
+				});
+			}
 		}
 		for (const notice of sub.notices) {
 			lines.push({ text: notice, indent: 1, level: "warn" });
 			findings.push({ level: "warn", text: `Subagent model: ${notice}`, fix: "Re-set the default with /subagent on this session, or /subagent clear." });
 		}
+		for (const warning of facts.subagentWarnings) {
+			lines.push({ text: warning.text, indent: 1, level: "warn" });
+			findings.push({ level: "warn", text: warning.text, fix: warning.fix });
+		}
 	} else {
 		lines.push({ text: "Subagents: no model resolves", level: "error" });
 	}
@@ -164,50 +203,50 @@ export function modelsSection(facts: ModelFacts, session: SessionView, findings:
 		const live = session.permission?.classifier;
 		const pinned = session.permission?.pinned && live ? ` — screening this session on ${live}` : "";
 		lines.push({ text: `Auto-mode classifier: ${classifier.description ?? modelSpec(classifier.model)}${pinned}`, level: "ok" });
+		if (classifier.configured) {
+			lines.push({ text: `Setting: "${classifier.configured}" via autoMode.classifierModel in ~/.onecode/settings.json (/auto-mode model clear returns to automatic)`, indent: 1, level: "dim" });
+		}
+		lines.push({
+			text: "Classifier policy: for the models One Code's pairing table names, the table's pick on this provider (or this session's model), unless it costs more than this session's model or its window is smaller; otherwise the cheapest model on this provider in this session's tier or above, strictly cheaper than it, with a context window at least as large, not an experimental build and not a moving -latest alias, else this session's model; /auto-mode model chooses one by hand.",
+			indent: 1,
+			level: "dim",
+		});
 	} else {
 		lines.push({ text: "Auto-mode classifier: none — auto mode stays out of the mode cycle until a model is available", level: "warn" });
+		findings.push({
+			level: "warn",
+			text: "No auto-mode classifier model resolves, so auto mode stays out of the mode cycle.",
+			fix: "Choose one with /auto-mode model, or connect a provider with /login.",
+		});
 	}
 	for (const notice of classifier.notices) {
 		lines.push({ text: notice.text, indent: 1, level: notice.level === "warning" ? "warn" : "dim" });
 		if (notice.level === "warning") {
-			findings.push({ level: "warn", text: `Classifier: ${notice.text}`, fix: "Pick a model with /auto-mode model, or /auto-mode model clear for the automatic choice." });
+			findings.push({
+				level: "warn",
+				text: `Classifier: ${notice.text}`,
+				fix: classifier.configured
+					? "Change it with /auto-mode model, or /auto-mode model clear for the automatic choice."
+					: "Check provider authentication and model availability, or choose one with /auto-mode model.",
+			});
 		}
 	}
 
 	if (facts.reader) {
 		lines.push({
-			text: `Web-fetch and recap reader: ${modelSpec(facts.reader.model)} — ${facts.reader.via === "tier" ? "cheapest capable model on this provider" : "the main model"}`,
+			text: `Web-fetch and recap reader: ${modelSpec(facts.reader.model)} — ${facts.reader.via === "tier" ? "the cheapest cheap-tier model on this provider that costs no more than the main model (a workhorse or frontier one when there is none)" : "the main model"}`,
 			level: "dim",
 		});
 	}
 
-	// The measured capability floor: what each automatic pick was judged on, or
-	// how to switch it on. Scores shown carry the attribution the free API requires.
-	const cap = facts.capability;
-	const verdictLine = (label: string, v: FloorVerdict | undefined): ReportLine | undefined => {
-		if (!v) return undefined;
-		if (v.verdict === "unscored") return { text: `${label}: not measured — ${v.reason ?? "no confirmed score"}; the name-class rule decided`, indent: 1, level: "dim" };
-		const basis = v.candidate?.variant === "non-reasoning" ? "thinking-off" : "default-effort";
-		return {
-			text: `${label}: coding index ${v.candidate?.coding} vs floor ${v.floor?.toFixed(1)} (${basis}; session ${v.session?.coding}, Sonnet 5 ${v.reference?.coding}) — ${v.verdict === "pass" ? "measured capable" : "below the floor"}`,
-			indent: 1,
-			level: "dim",
-		};
-	};
-	if (cap.snapshot) {
-		const ageH = Math.round(snapshotAgeMs({ fetchedAt: cap.snapshot.fetchedAt, source: "", rows: [] }) / 3_600_000);
-		lines.push({ text: `Capability scores: Artificial Analysis snapshot, ${cap.snapshot.rows} models, ${ageH} h old — measured picks for subagents and the classifier`, level: "ok" });
-		for (const line of [verdictLine("Subagent pick", cap.subagent), verdictLine("Classifier pick", cap.classifier), verdictLine("Reader pick", cap.reader)]) {
-			if (line) lines.push(line);
-		}
-		lines.push({ text: ATTRIBUTION, indent: 1, level: "dim" });
-	} else if (cap.keyConfigured) {
-		lines.push({ text: "Capability scores: key configured, snapshot not fetched yet — it downloads in the background on the next interactive start", level: "dim" });
-	} else {
-		lines.push({ text: "Capability scores: none — automatic picks use model names and generations only", level: "warn" });
-		findings.push({ level: "warn", text: "No Artificial Analysis key: subagent and classifier picks cannot be judged by measured coding ability.", fix: KEY_ADVICE });
-	}
-
+	// The catalogs every tier below frontier comes from, and how fresh they are.
+	const cat = facts.catalog;
+	const ageDays = Math.floor((Date.now() - Date.parse(cat.fetchedAt)) / DAY_MS);
+	const age = ageDays <= 0 ? "today" : ageDays === 1 ? "1 day ago" : `${ageDays} days ago`;
+	lines.push({
+		text: `Model catalogs: models.dev, OpenRouter and Hugging Face, fetched ${age} (${cat.refreshed ? "refreshed by One Code" : "bundled with this release"})${cat.refreshEnabled ? "; refreshed daily from interactive sessions" : "; daily refresh off (refreshModelCatalog: false, or PI_OFFLINE)"}`,
+		level: "dim",
+	});
 	if (session.permission) {
 		const mode = session.permission.mode;
 		const from = session.permission.source ? ` (${session.permission.source})` : "";
@@ -217,7 +256,7 @@ export function modelsSection(facts: ModelFacts, session: SessionView, findings:
 	if (facts.sessionTier === "tiny") {
 		findings.push({
 			level: "warn",
-			text: `${modelSpec(main)} is classed as a tiny-tier model: One Code adds weak-model scaffolding and search tools, and never auto-selects a tiny model for subagents or the classifier.`,
+			text: `${modelSpec(main)} is classed as a tiny-tier model (a small model); automatic alternatives exclude tiny models, but the session model remains the classifier fallback.`,
 			fix: "For coding work pick a cheap- or workhorse-tier model with /model; see /doctor presets.",
 		});
 	}

package/extensions/doctor/presets.ts

@@ -6,30 +6,22 @@
  *
  * Presets never leave the current provider family: every automatic model choice
  * in One Code is contained to the session's provider (a subagent inherits the
- * transcript, the classifier reads the prompts — docs/decisions/model-policy.md),
+ * transcript, the classifier reads the prompts — working-docs/decisions/model-policy.md),
  * and a preset is a bundle of those same choices. A user who wants another
  * provider switches with /model first and reruns /doctor presets there.
  *
- * Each preset pins ONE thing — the main model — and sets the two secondary
- * knobs to the shape that matches its intent:
- *   economical        main = cheapest capable (cheap tier, never tiny); subagents inherit it;
- *                     classifier automatic (lands on the same model)
- *   balanced          main = cheapest workhorse-tier model; subagents automatic (the
- *                     cheapest model at the main's floor — often the main itself,
- *                     since subagents share the classifier's workhorse floor);
- *                     classifier automatic (workhorse floor)
- *   maximum quality   main = the strongest (frontier, else priciest workhorse);
- *                     subagents inherit it; classifier automatic
- * so applying a preset is three settings writes the user can each undo by hand
- * (/model, /subagent, /auto-mode model). The rows display what the resolvers
- * would pick for that main model, computed with the resolvers themselves.
+ * Each preset pins the main model, sets the subagent default to the shape that
+ * matches its intent, and returns the classifier to the automatic choice
+ * (clearing `autoMode.classifierModel`); the rows display what its resolver
+ * would pick for that main model.
  */
 
 import type { Api, Model } from "@earendil-works/pi-ai";
 import { classifierCandidates } from "../auto-mode/model-select.ts";
-import { isPriorGeneration, lacksToolCalls } from "../lib/model-facts.ts";
-import { isDatedDuplicate, modelsContainedToSession, modelSpec, pricedInput } from "../lib/model-policy.ts";
-import { intrinsicTier, type PromptTier } from "../lib/model-tier.ts";
+import { autoSelectable, catalogModelFor } from "../lib/model-catalog.ts";
+import { isDatedDuplicate, isExperimentalBuild, modelsContainedToSession, modelSpec, pricedInput, supportsImageInput } from "../lib/model-policy.ts";
+import { intrinsicTier, type PromptTier, servedCatalogIds } from "../lib/model-tier.ts";
+import { newerModelSuggestion } from "../lib/newer-model.ts";
 import { resolveSubagentModel } from "../subagents/model-select.ts";
 import type { ReportLine, ReportSection } from "./report.ts";
 
@@ -44,7 +36,7 @@ export const PRESET_LABEL: Record<PresetName, string> = {
 };
 
 export const PRESET_INTENT: Record<PresetName, string> = {
-	economical: "lowest cost — one cheap model for everything",
+	economical: "lowest-cost main model, with subagents inheriting it",
 	balanced: "a capable main model, delegated work on the cheapest model at its floor",
 	quality: "the strongest model for the main session and its subagents",
 };
@@ -71,10 +63,26 @@ export type PresetsUnavailable = "no-model" | "no-priced-models";
  * to `claude-haiku-4-5`). Tiny-tier rows stay in the pool only as a last resort.
  */
 export function presetPool(available: Model<Api>[], sessionModel: Model<Api>): Model<Api>[] {
-	const contained = modelsContainedToSession(available, sessionModel).filter(
-		// A preset recommends a MAIN model: never one a generation behind its family
-		// or one models.dev says cannot call tools (model-facts.ts), whatever its tier.
-		(m) => pricedInput(m) !== undefined && !isPriorGeneration(m) && !lacksToolCalls(m),
+	const all = modelsContainedToSession(available, sessionModel);
+	const served = servedCatalogIds(all);
+	// The newer-model check flags a main model with a newer model of its line at
+	// no more than 1.1× its price; supersession's band is 0.6–1.5×, so GPT-5.6
+	// Sol survives it against the half-price GPT-6.1 Sol. A preset never
+	// recommends a model /doctor would then call outdated, nor an alias of one
+	// (`gpt-daybreak-blue-latest` serves gpt-5.6-sol today).
+	const identity = (m: Model<Api>): string => catalogModelFor(m)?.id ?? modelSpec(m);
+	const outdated = new Set(all.filter((m) => newerModelSuggestion(available, m)).map(identity));
+	const contained = all.filter(
+		// A preset recommends a MAIN model: never one automatic selection skips
+		// (superseded by a model this provider serves, legacy, deprecated, unable
+		// to call tools, not a text model: model-catalog.ts), whatever its tier.
+		// A model no catalog knows stays, judged by its tier alone.
+		(m) => {
+			// An experimental build is out whether or not a catalog knows it.
+			if (pricedInput(m) === undefined || outdated.has(identity(m)) || isExperimentalBuild(m.id)) return false;
+			const entry = catalogModelFor(m);
+			return !entry || autoSelectable(entry, served);
+		},
 	);
 	return contained.filter((m) => !isDatedDuplicate(m, contained));
 }
@@ -97,7 +105,10 @@ function pickMain(name: PresetName, pool: Model<Api>[]): { model: Model<Api>; no
 			return tiny ? { model: tiny, note: "only tiny-tier models on this provider — expect weaker results" } : undefined;
 		}
 		case "balanced": {
-			const pick = cheapest(workhorse) ?? cheapest(frontier) ?? priciest(cheap);
+			// The cheapest workhorse-or-better model: a frontier model cheaper than
+			// every workhorse one (GPT-6.1 Sol against the GPT-5.5 Pro SKU) is the
+			// better buy, not a reason to pay for the premium SKU.
+			const pick = cheapest([...workhorse, ...frontier]) ?? priciest(cheap);
 			if (pick) return { model: pick, note: workhorse.length === 0 ? "no workhorse-tier model on this provider" : undefined };
 			const any = priciest(pool);
 			return any ? { model: any, note: "only tiny-tier models on this provider — expect weaker results" } : undefined;
@@ -139,7 +150,7 @@ export function computePresets(
 		// what applying the preset produces.
 		const subagentModel = inherit
 			? main.model
-			: (resolveSubagentModel({ sessionModel: main.model, available }).model ?? main.model);
+			: (resolveSubagentModel({ sessionModel: main.model, available, requireImageInput: supportsImageInput(main.model) }).model ?? main.model);
 		const classifier = classifierCandidates({ available, sessionModel: main.model }).candidates[0]?.model;
 		presets.push({
 			name,
@@ -173,6 +184,10 @@ export function presetsSection(result: ReturnType<typeof computePresets>, sessio
 		lines.push({ text: "No priced models on this provider, so tiers cannot be told apart and no preset is offered.", level: "dim" });
 		return { title: "Presets", lines };
 	}
+	lines.push({
+		text: "Classifier previews use each preset's main model: the cheapest model in its tier or above that is strictly cheaper than the main model, else the main model itself.",
+		level: "dim",
+	});
 	const family = sessionModel ? sessionModel.provider : "";
 	for (const preset of result.presets) {
 		const sub = preset.subagents.setting === "inherit" ? "same" : shortId(preset.subagents.model);
@@ -193,9 +208,9 @@ export function presetsSection(result: ReturnType<typeof computePresets>, sessio
 }
 
 /**
- * The three settings writes a preset amounts to, one line each with its undo —
- * the text `/doctor preset` reports after applying. `mainSwitched` false means
- * the session already ran the preset's main model, so that line says so.
+ * The three settings changes a preset makes, each with its undo — the text
+ * `/doctor preset` reports after applying. `mainSwitched` false means the
+ * session already ran the preset's main model, so that line says so.
  */
 export function describePresetChanges(preset: PresetPlan, mainSwitched = true): string[] {
 	return [

package/extensions/doctor/report.ts

@@ -9,17 +9,22 @@
  * Claude Code never has to explain: which provider is ready, which model each
  * role (main, subagents, classifier, reader) resolves to and why, what of the
  * imported Claude Code configuration is honoured, and which external programs
- * are missing. Rationale: docs/decisions/doctor.md.
+ * are missing. Rationale: working-docs/decisions/doctor.md.
  *
  * No pi imports. The wiring (index.ts, cli.ts) gathers the live inputs and hands
  * them to `buildDoctorReport`; everything below is deterministic given them.
  */
 
 import type { Api, Model } from "@earendil-works/pi-ai";
+import type { PromptTier } from "../lib/model-tier.ts";
 import { tildify } from "../lib/paths.ts";
 import type { McpStatusEvent } from "../lib/mcp-status.ts";
-import { wrapProse } from "../subagents/panel-render.ts";
+import type { ReplacedBuiltinsView } from "./builtins.ts";
+import type { CompactionKeepView } from "../lib/compaction-keep.mjs";
+import type { RegisteredServer } from "../mcp/config.ts";
+import { wrapProse } from "../lib/tui-render.ts";
 import { countNoun } from "../lib/tui-render.ts";
+import type { ConfigMode } from "../lib/config-mode.ts";
 export { countNoun };
 
 export type LineLevel = "ok" | "info" | "warn" | "error" | "dim";
@@ -63,6 +68,8 @@ export interface DoctorEnvironment {
 	agentDir: string;
 	/** One Code's own state dir (~/.onecode or ONECODE_STATE_DIR). */
 	stateDir: string;
+	/** Where configuration is read from (lib/config-mode.ts). */
+	configMode: ConfigMode;
 	env: NodeJS.ProcessEnv;
 	platform: string;
 	arch: string;
@@ -71,6 +78,14 @@ export interface DoctorEnvironment {
 	/** How One Code was launched: the bundled `onecode` app or the extension on the user's own pi. */
 	install: "app" | "pi-package";
 	piVersion?: string;
+	/** pi's built-ins One Code replaces and whether pi still loads them; undefined before pi 0.99 (doctor/builtins.ts). */
+	replacedBuiltins?: ReplacedBuiltinsView;
+	/** pi's compaction keep window and where it is set (lib/compaction-keep.mjs); undefined when the settings could not be read. */
+	compactionKeep?: CompactionKeepView & { paths: { user: string; project: string } };
+	/** pi's `CONFIG_DIR_NAME`, the project folder its own `mcp.json` sits in (`.pi` when absent). */
+	piConfigDirName?: string;
+	/** MCP servers other extensions registered in this session (`pi.getMcpServers()`); the CLI has none. */
+	registeredMcpServers?: RegisteredServer[];
 	/** Result of the registry lookup for the newest release, when one was attempted. */
 	latest?: { status: "current" | "behind" | "unknown" | "skipped"; version?: string; reason?: string };
 }
@@ -88,6 +103,8 @@ export interface RegistryView {
 /** Live session facts; the CLI fills what it can from settings and leaves the rest undefined. */
 export interface SessionView {
 	model?: Model<Api>;
+	/** The running session's frozen register; absent in the standalone CLI. */
+	promptTier?: PromptTier;
 	/** Where `model` came from: the running session, pi's saved default, or nowhere. */
 	modelSource: "session" | "default-setting" | "first-available" | "none";
 	thinkingLevel?: string;

package/extensions/doctor/viewer.ts

@@ -4,10 +4,13 @@
  * an undiscoverable key). The wiring owns repaint and the fix/close effects.
  */
 
-import { panelTopRule } from "../lib/tui-render.ts";
+import { panelTopRule, wrapHints } from "../lib/tui-render.ts";
+import { keyId, keyText } from "../lib/key-input.ts";
 
 export interface DoctorViewerState {
 	offset: number;
+	/** Body rows the last render showed (the hint row can wrap); the keys page by it. */
+	visibleRows?: number;
 }
 
 export type DoctorViewerKey =
@@ -21,38 +24,43 @@ export type DoctorViewerKey =
 	| { kind: "close" };
 
 export function decodeDoctorKey(data: string): DoctorViewerKey | undefined {
-	switch (data) {
-		case "\x1b[A":
-		case "\x1bOA":
+	switch (keyId(data)) {
+		case "up":
+			return { kind: "up" };
+		case "down":
+			return { kind: "down" };
+		case "pageUp":
+		case "ctrl+b":
+			return { kind: "pageUp" };
+		case "pageDown":
+		case "ctrl+f":
+		case "space":
+			return { kind: "pageDown" };
+		case "home":
+			return { kind: "home" };
+		case "end":
+			return { kind: "end" };
+		case "escape":
+		case "ctrl+c":
+		case "enter":
+			return { kind: "close" };
+		default:
+			break;
+	}
+	switch (keyText(data)) {
 		case "k":
 			return { kind: "up" };
-		case "\x1b[B":
-		case "\x1bOB":
 		case "j":
 			return { kind: "down" };
-		case "\x1b[5~":
-		case "\x02": // ctrl+b
 		case "b":
 			return { kind: "pageUp" };
-		case "\x1b[6~":
-		case "\x06": // ctrl+f
-		case " ":
-			return { kind: "pageDown" };
-		case "\x1b[H":
-		case "\x1b[1~":
 		case "g":
 			return { kind: "home" };
-		case "\x1b[F":
-		case "\x1b[4~":
 		case "G":
 			return { kind: "end" };
 		case "f":
 			return { kind: "fix" };
-		case "\x1b":
-		case "\x03": // ctrl+c
 		case "q":
-		case "\r":
-		case "\n":
 			return { kind: "close" };
 		default:
 			return undefined;
@@ -102,7 +110,7 @@ export interface DoctorViewerInput {
 	canFix: boolean;
 }
 
-/** Rows taken by the top rule and the footer hint. */
+/** Rows taken by the top rule, the blank above the hints and a one-line hint row. */
 export const VIEWER_CHROME_ROWS = 3;
 
 export function visibleBodyRows(height: number): number {
@@ -111,14 +119,28 @@ export function visibleBodyRows(height: number): number {
 
 export function renderDoctorViewer(input: DoctorViewerInput, paint: (color: string, text: string) => string): string[] {
 	const { lines, state, width, height } = input;
-	const visible = visibleBodyRows(height);
+	// PageUp/PageDown are pi-tui's own scrollback keys in fullscreen mode and never
+	// reach a component, so the hint names keys that do. On a narrow terminal the
+	// hints wrap at their separators (so "esc close" is never the part cut off)
+	// and the body gives up the rows; the position text depends on the body
+	// height, so the layout settles in a second pass.
+	const hintLines = (visible: number): string[] => {
+		const max = Math.max(0, lines.length - visible);
+		const offset = Math.min(state.offset, max);
+		const position = lines.length > visible ? ` · ${offset + 1}-${Math.min(lines.length, offset + visible)} of ${lines.length}` : "";
+		const hints = [`↑/↓ scroll · space/b page · g/G top/end${position}`, ...(input.canFix ? ["f run the checkup (the model fixes the findings)"] : []), "esc close"].join(" · ");
+		return wrapHints(hints, Math.max(1, width - 1));
+	};
+	let visible = visibleBodyRows(height);
+	let footer = hintLines(visible);
+	if (footer.length > 1) {
+		visible = Math.max(1, visible - (footer.length - 1));
+		footer = hintLines(visible);
+	}
+	state.visibleRows = visible;
 	const max = Math.max(0, lines.length - visible);
 	if (state.offset > max) state.offset = max;
 	const window = lines.slice(state.offset, state.offset + visible);
 	while (window.length < visible) window.push("");
-	const position = lines.length > visible ? ` · ${state.offset + 1}-${Math.min(lines.length, state.offset + visible)} of ${lines.length}` : "";
-	// PageUp/PageDown are pi-tui's own scrollback keys in fullscreen mode and never
-	// reach a component, so the hint names keys that do.
-	const hints = [`↑/↓ scroll · space/b page · g/G top/end${position}`, ...(input.canFix ? ["f run the checkup (the model fixes the findings)"] : []), "esc close"].join(" · ");
-	return [panelTopRule(paint, width), ...window, "", paint("dim", ` ${hints}`)];
+	return [panelTopRule(paint, width), ...window, "", ...footer.map((line) => paint("dim", ` ${line}`))];
 }