@iowarp/clio-coder 0.4.4 → 0.4.6

package/src/cli/context-map.ts

@@ -1,8 +1,10 @@
 import { execFileSync } from "node:child_process";
-import { mkdirSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { CLIO_ARTIFACT_DIR } from "../core/artifact-paths.js";
-import { readCodewiki } from "../domains/context/codewiki/artifact.js";
+import { type CodewikiCoordinatedResult, coordinateCodewikiWrite } from "../domains/context/codewiki/coordinator.js";
+import type { Codewiki } from "../domains/context/codewiki/schema.js";
 import { buildArchitectureSeed, serializeArchitectureSeed } from "../domains/context/wiki/map-seed.js";
 
 const HELP = `Usage:
@@ -11,7 +13,8 @@ const HELP = `Usage:
 Write an archify architecture seed for the current repository from the codewiki
 index, without model calls. The seed is the starting spec for the archify skill:
 components are the largest directory areas, connections are collapsed import
-edges, and sources point at indexed files and lines.
+edges. The index is reconciled with current files before mapping; sources are
+pinned only when clean Git evidence matches those files.
 
 Options:
   --out <path>    where to write the seed (default: ${CLIO_ARTIFACT_DIR}/maps/<repo>.architecture.json)
@@ -28,21 +31,53 @@ function gitValue(cwd: string, args: string[]): string | null {
 		const out = execFileSync("git", args, { cwd, timeout: 5000, stdio: ["ignore", "pipe", "ignore"] })
 			.toString("utf8")
 			.trim();
-		return out.length > 0 ? out : null;
+		return out;
 	} catch {
 		return null;
 	}
 }
 
-/** The origin remote as an https URL and HEAD as a full sha, when git can say. */
-function repositoryFacts(cwd: string): { url: string; revision: string } | undefined {
-	const remote = gitValue(cwd, ["remote", "get-url", "origin"]);
+type SourceState = "clean" | "dirty" | "unknown";
+
+/** A successful empty status means clean; unavailable Git evidence never does. */
+function repositoryFacts(
+	cwd: string,
+	codewiki: Codewiki,
+	indexedHead: string | null,
+): { sourceState: SourceState; repository?: { url: string; revision: string } } {
 	const revision = gitValue(cwd, ["rev-parse", "--verify", "HEAD"]);
-	if (!remote || !revision) return undefined;
+	const status = gitValue(cwd, ["status", "--porcelain", "--untracked-files=normal"]);
+	if (!revision || status === null) return { sourceState: "unknown" };
+	if (status !== "" || revision !== indexedHead) return { sourceState: "dirty" };
+	// Source paths in the seed are workspace-relative. A nested workspace has
+	// no proven repository-relative path mapping, so cannot supply citations.
+	if (gitValue(cwd, ["rev-parse", "--show-prefix"]) !== "") return { sourceState: "unknown" };
+	const tree = gitValue(cwd, ["ls-tree", "-r", "-z", revision]);
+	if (tree === null) return { sourceState: "unknown" };
+	const blobs = new Map<string, string>();
+	for (const entry of tree.split("\0")) {
+		const match = /^100[0-7]{3} blob ([a-f0-9]{40})\t([\s\S]+)$/.exec(entry);
+		if (match) blobs.set(match[2] as string, match[1] as string);
+	}
+	try {
+		for (const file of codewiki.files) {
+			const contents = readFileSync(path.join(cwd, file.path));
+			// Verify both parser input identity and immutable Git blob identity.
+			// This also catches ignored/untracked inputs and assume-unchanged files
+			// that a successful `git status` alone cannot certify.
+			const indexedHash = createHash("sha256").update(contents.toString("utf8")).digest("hex").slice(0, 16);
+			const blob = createHash("sha1").update(`blob ${contents.length}\0`).update(contents).digest("hex");
+			if (indexedHash !== file.hash || blobs.get(file.path) !== blob) return { sourceState: "dirty" };
+		}
+	} catch {
+		return { sourceState: "unknown" };
+	}
+	const remote = gitValue(cwd, ["remote", "get-url", "origin"]);
+	if (!remote) return { sourceState: "clean" };
 	let url = remote.endsWith(".git") ? remote.slice(0, -4) : remote;
 	const ssh = /^git@([^:]+):(.+)$/.exec(url);
 	if (ssh) url = `https://${ssh[1]}/${ssh[2]}`;
-	return { url, revision };
+	return { sourceState: "clean", repository: { url, revision } };
 }
 
 export async function runContextMapCommand(args: string[]): Promise<number> {
@@ -72,16 +107,40 @@ export async function runContextMapCommand(args: string[]): Promise<number> {
 		return 2;
 	}
 	const cwd = process.cwd();
-	const codewiki = readCodewiki(cwd);
-	if (!codewiki) {
+	let reconciled: CodewikiCoordinatedResult | null;
+	try {
+		reconciled = await coordinateCodewikiWrite(
+			cwd,
+			(current, workspace) =>
+				current
+					? {
+							kind: "ensure",
+							cwd: workspace,
+							current,
+							language: current.language,
+							// Map evidence must reconcile actual inputs, even if a state file
+							// happens to carry a matching fingerprint from another operation.
+							previous: null,
+						}
+					: null,
+			{ requireExisting: true },
+		);
+	} catch (error) {
+		process.stderr.write(
+			`clio-coder context map: index refresh failed: ${error instanceof Error ? error.message : String(error)}\n`,
+		);
+		return 1;
+	}
+	if (!reconciled) {
 		process.stderr.write(
 			"clio-coder context map: no codewiki index in .clio-coder/codewiki.json; run `clio-coder context index` first\n",
 		);
 		return 1;
 	}
-	const seed = buildArchitectureSeed(codewiki, {
+	const facts = repositoryFacts(cwd, reconciled.codewiki, reconciled.worker.fingerprint.gitHead);
+	const seed = buildArchitectureSeed(reconciled.codewiki, {
 		title: path.basename(cwd),
-		repository: repositoryFacts(cwd),
+		repository: facts.repository,
 	});
 	const target = out ? path.resolve(cwd, out) : defaultMapSeedPath(cwd);
 	mkdirSync(path.dirname(target), { recursive: true });
@@ -91,6 +150,8 @@ export async function runContextMapCommand(args: string[]): Promise<number> {
 		components: seed.components.length,
 		connections: seed.connections.length,
 		repository: seed.meta.repository ?? null,
+		index: "reconciled",
+		sourceState: facts.sourceState,
 	};
 	if (json) {
 		process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
@@ -102,7 +163,7 @@ export async function runContextMapCommand(args: string[]): Promise<number> {
 			`  ${payload.components} components, ${payload.connections} connections${
 				payload.repository
 					? `, sources pinned at ${payload.repository.revision.slice(0, 12)}`
-					: "; no GitHub origin at a full revision, so no source citations"
+					: `; no source citations (source state: ${payload.sourceState}; requires verified clean files and a GitHub origin at a full revision)`
 			}`,
 			payload.repository
 				? "  next: validate and deliver it with the archify skill, passing --repo-root ."

package/src/cli/context.ts

@@ -1,12 +1,15 @@
 import { join, resolve } from "node:path";
 import type { BootstrapProgressEvent } from "../domains/context/index.js";
 import type { BootstrapGenerationState } from "../domains/context/state.js";
+import type { RunWikiGenerateResult } from "../domains/context/wiki/generate.js";
+import type { WikiMeta } from "../domains/context/wiki/meta.js";
+import { MAX_PAGE_ATTEMPTS } from "../domains/context/wiki/plan-store.js";
 
 const HELP = `Usage:
   clio-coder context
   clio-coder context init [--yes] [--preview|--heuristic] [--adopt] [--propose|--apply|--rewrite]
   clio-coder context refresh [--wiki]
-  clio-coder context wiki [--update] [--status] [--depth auto|simple|medium|detailed]
+  clio-coder context wiki [--update|--retry-pending] [--status] [--depth auto|simple|medium|detailed]
                     [--target <id>] [--model <id>] [--thinking off|low|medium|high]
   clio-coder context reset [--all] [--yes]
   clio-coder context index [--json]
@@ -32,6 +35,36 @@ function printWikiProgress(event: BootstrapProgressEvent): void {
 	process.stderr.write(`clio-coder context wiki: ${event.message}${detail}\n`);
 }
 
+function wikiRecoveryLines(meta: WikiMeta | null): string[] {
+	const pending = meta?.plan?.pages.filter((page) => page.status !== "written") ?? [];
+	if (pending.length === 0) return [];
+	const exhausted = pending.filter((page) => page.attempts >= MAX_PAGE_ATTEMPTS).length;
+	const failures = pending.filter((page) => page.lastFailure);
+	return [
+		`pending: ${pending.length} page(s)${exhausted > 0 ? `; ${exhausted} exhausted ordinary writer attempts` : ""}`,
+		...failures.slice(0, 8).map((page) => `${page.path}: ${page.lastFailure?.phase}: ${page.lastFailure?.detail}`),
+		...(failures.length > 8 ? [`${failures.length - 8} more page failures retained in wiki metadata`] : []),
+		"Run `clio-coder context wiki --retry-pending` to retry pending pages once, including exhausted pages, without replanning.",
+	];
+}
+
+function printWikiOutcome(prefix: string, result: RunWikiGenerateResult, meta: WikiMeta | null): void {
+	const pending = result.pending ?? meta?.plan?.pages.filter((page) => page.status !== "written").length ?? 0;
+	const complete = meta?.plan
+		? meta.plan.pages.filter((page) => page.status === "written").length
+		: (meta?.generation?.pagesWritten ?? Math.max(0, result.pages - pending));
+	const published = `${result.pages} published page${result.pages === 1 ? "" : "s"}`;
+	const progress = `${complete} complete, ${pending} pending`;
+	const outcome = pending > 0 ? "incomplete" : result.status === "noop" ? "unchanged" : "generated";
+	process.stdout.write(`${prefix}: ${outcome} (${published}; ${progress})\n`);
+	if (pending > 0) {
+		const recovery = wikiRecoveryLines(meta);
+		process.stdout.write(
+			`${recovery.length > 0 ? recovery.join("\n") : "Run `clio-coder context wiki --update` to continue pending pages."}\n`,
+		);
+	}
+}
+
 function compactMetric(value: number, suffix: string): string {
 	if (value < 1000) return `${value}${suffix}`;
 	return `${(value / 1000).toFixed(1)}k${suffix}`;
@@ -82,10 +115,7 @@ async function printContextStatus(): Promise<number> {
 					: "ok";
 
 	const prompt = context.renderPromptContext(cwd);
-	const preloadClass = preload.classifyProjectPreload({
-		hasClioMd: prompt.clioMd !== null,
-		text: prompt.text,
-	});
+	const preloadClass = preload.selectProjectPreload(prompt, null).classification;
 
 	const codewiki = context.readCodewiki(cwd);
 	const codewikiCount = codewiki ? context.codewikiEntries(codewiki).length : 0;
@@ -134,7 +164,7 @@ async function runRefreshCommand(args: string[]): Promise<number> {
 		return 2;
 	}
 	try {
-		const { runContextRefresh } = await import("../domains/context/index.js");
+		const { runContextRefresh, readWikiMeta } = await import("../domains/context/index.js");
 		const wikiEntry = updateWiki ? await import("./wiki-generate.js") : null;
 		const result = await runContextRefresh({
 			cwd: process.cwd(),
@@ -155,11 +185,7 @@ async function runRefreshCommand(args: string[]): Promise<number> {
 				);
 				return 1;
 			}
-			process.stdout.write(
-				result.wiki.status === "noop"
-					? `clio-coder context refresh: wiki unchanged (${result.wiki.pages} page${result.wiki.pages === 1 ? "" : "s"})\n`
-					: `clio-coder context refresh: wiki updated (${result.wiki.pages} page${result.wiki.pages === 1 ? "" : "s"})\n`,
-			);
+			printWikiOutcome("clio-coder context refresh: wiki", result.wiki, readWikiMeta(process.cwd()));
 		}
 		return 0;
 	} catch (err) {
@@ -189,10 +215,11 @@ async function runWikiStatusCommand(): Promise<number> {
 			`depth: ${depth} (requested ${requestedDepth}; ${sourceFiles} source files; ` +
 				`${pagesWritten}/${pagesPlanned} planned pages written)`,
 		);
-		if (pagesWritten < pagesPlanned) {
+		if (pagesWritten < pagesPlanned && !meta.plan) {
 			lines.push(`pending: ${pagesPlanned - pagesWritten} page(s); run \`clio-coder context wiki --update\` to finish`);
 		}
 	}
+	lines.push(...wikiRecoveryLines(meta));
 	if (currentHead !== meta.gitHead) {
 		lines.push(`staleness: gitHead differs from current HEAD (${currentHead ?? "none"})`);
 	}
@@ -215,6 +242,7 @@ function isThinkingLevel(value: unknown): value is WikiCliThinking {
 
 async function runWikiCommand(args: string[]): Promise<number> {
 	let forceUpdate = false;
+	let retryPending = false;
 	let status = false;
 	let depth: WikiCliDepth = "auto";
 	let target: string | undefined;
@@ -230,6 +258,10 @@ async function runWikiCommand(args: string[]): Promise<number> {
 			forceUpdate = true;
 			continue;
 		}
+		if (arg === "--retry-pending") {
+			retryPending = true;
+			continue;
+		}
 		if (arg === "--status") {
 			status = true;
 			continue;
@@ -277,6 +309,7 @@ async function runWikiCommand(args: string[]): Promise<number> {
 		const result = await context.runWikiGenerate({
 			cwd: process.cwd(),
 			...(forceUpdate ? { mode: "update" as const } : {}),
+			...(retryPending ? { retryPending: true } : {}),
 			depth,
 			model: await resolveDocumenterModelId(route),
 			generate: modelWikiGenerate({ route }),
@@ -286,11 +319,7 @@ async function runWikiCommand(args: string[]): Promise<number> {
 			process.stderr.write(`clio-coder context wiki failed: ${(result.problems ?? ["unknown failure"]).join("; ")}\n`);
 			return 1;
 		}
-		process.stdout.write(
-			result.status === "noop"
-				? `clio-coder context wiki: unchanged (${result.pages} page${result.pages === 1 ? "" : "s"})\n`
-				: `clio-coder context wiki: generated ${result.pages} page${result.pages === 1 ? "" : "s"}\n`,
-		);
+		printWikiOutcome("clio-coder context wiki", result, context.readWikiMeta(process.cwd()));
 		return 0;
 	} catch (err) {
 		process.stderr.write(`clio-coder context wiki failed: ${err instanceof Error ? err.message : String(err)}\n`);

package/src/cli/eval.ts

@@ -1,7 +1,9 @@
+import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { InvalidIdError } from "../core/safe-id.js";
+import { shellQuote } from "../core/shell-quote.js";
 import { clioDataDir } from "../core/xdg.js";
-import { loadEvalArtifactV4, writeEvalArtifactV4 } from "../domains/eval/artifacts/store.js";
+import { loadEvalArtifactV4, parseEvalArtifactV4, writeEvalArtifactV4 } from "../domains/eval/artifacts/store.js";
 import { compareEvalArtifactsV4 } from "../domains/eval/compare/compare.js";
 import { evaluateGate, renderGateFailure, renderInformationalBudget } from "../domains/eval/compare/gates.js";
 import { loadThresholds } from "../domains/eval/compare/thresholds.js";
@@ -50,6 +52,7 @@ interface ParsedEvalArgs {
 	out?: string;
 	clioEntry?: string;
 	evalId?: string;
+	artifact?: string;
 	format: EvalReportFormat;
 	compareIds: string[];
 	metric?: string;
@@ -133,6 +136,11 @@ function parseEvalArgs(args: ReadonlyArray<string>): ParsedEvalArgs {
 			throw new Error(`unknown eval run argument: ${arg}`);
 		}
 		if (parsed.command === "report") {
+			if (arg === "--artifact") {
+				parsed.artifact = requiredValue(args, index, "--artifact");
+				index += 1;
+				continue;
+			}
 			if (arg === "--format") {
 				parsed.format = reportFormat(requiredValue(args, index, "--format"));
 				index += 1;
@@ -189,7 +197,9 @@ function parseEvalArgs(args: ReadonlyArray<string>): ParsedEvalArgs {
 	if (parsed.command === "run" && (parsed.suite === undefined) === (parsed.taskFile === undefined)) {
 		throw new Error("run requires exactly one of --suite or --task-file");
 	}
-	if (parsed.command === "report" && parsed.evalId === undefined) throw new Error("report requires an eval id");
+	if (parsed.command === "report" && (parsed.evalId === undefined) === (parsed.artifact === undefined)) {
+		throw new Error("report requires exactly one of an eval id or --artifact <path>");
+	}
 	if (parsed.command === "compare" && parsed.compareIds.length !== 2) {
 		throw new Error("compare requires <baselineEvalId> <candidateEvalId>");
 	}
@@ -259,6 +269,7 @@ async function runEvalRun(parsed: ParsedEvalArgs): Promise<number> {
 		);
 		const artifactPath = await writeEvalArtifactV4(clioDataDir(), artifact, parsed.out);
 		process.stdout.write(`${renderEvalTextReportV4(artifact)}artifact: ${artifactPath}\n`);
+		process.stdout.write(`report: clio-coder eval report --artifact ${shellQuote(resolve(artifactPath))} --format md\n`);
 		// A suite that declares thresholds is gated by them here, on the artifact
 		// it just produced. Declaring a gate that only a later `eval gate`
 		// invocation enforces means the run that broke it still exited zero.
@@ -280,7 +291,10 @@ async function runEvalRun(parsed: ParsedEvalArgs): Promise<number> {
 async function runEvalReportCommand(parsed: ParsedEvalArgs): Promise<number> {
 	try {
 		const dataDir = clioDataDir();
-		const artifact = await loadEvalArtifactV4(dataDir, parsed.evalId ?? "");
+		const artifact =
+			parsed.artifact === undefined
+				? await loadEvalArtifactV4(dataDir, parsed.evalId ?? "")
+				: parseEvalArtifactV4(JSON.parse(await readFile(parsed.artifact, "utf8")) as unknown, parsed.artifact);
 		process.stdout.write(renderArtifactReport(artifact, parsed.format, dataDir));
 		return 0;
 	} catch (error) {

package/src/cli/modes/print.ts

@@ -12,7 +12,7 @@ import {
 import { getTerminationCoordinator } from "../../core/termination.js";
 import { ToolNames } from "../../core/tool-names.js";
 import { createRunReceiptQuality } from "../../domains/dispatch/receipt-findings.js";
-import { openLedger } from "../../domains/dispatch/state.js";
+import { newRunId, openLedger } from "../../domains/dispatch/state.js";
 import type { RunKind, RunOutcome, RunReceiptDraft, RunStatus, ToolCallStat } from "../../domains/dispatch/types.js";
 import type { AgentMessage, ImageContent } from "../../engine/types.js";
 import type { ChatLoop, ChatLoopEvent } from "../../interactive/chat-loop.js";
@@ -58,6 +58,8 @@ export interface HeadlessMainAgentOptions {
 }
 
 interface HeadlessMainAgentResult {
+	/** Latest assistant stop, superseded by subsequent continuation messages. */
+	outputExhausted: boolean;
 	text: string;
 	error: string | null;
 	/**
@@ -154,6 +156,7 @@ function resultFromEvent(event: ChatLoopEvent, current: HeadlessMainAgentResult)
 	if (event.type !== "message_end") return current;
 	const message = event.message;
 	if (message?.role !== "assistant") return current;
+	current = { ...current, outputExhausted: message.stopReason === "length", sawTerminatingToolResult: false };
 	const error = assistantError(message);
 	if (error) return { ...current, text: "", error };
 	const text = assistantText(message).trimEnd();
@@ -180,8 +183,15 @@ function recordToolEnd(stats: HeadlessMainAgentReceiptStats, event: ChatLoopEven
 	stat.count += 1;
 	const durationMs = durationMsFromEvent(event);
 	if (durationMs !== undefined) stat.totalDurationMs += durationMs;
-	if (event.isError) stat.errors += 1;
-	else stat.ok += 1;
+	// Registry settlement is authoritative; legacy producers only expose isError.
+	const outcome = (event as { outcome?: unknown }).outcome;
+	if (outcome === "blocked") stat.blocked += 1;
+	else if (outcome === "error") stat.errors += 1;
+	else if (outcome === "ok") stat.ok += 1;
+	else if (outcome === undefined) {
+		if (event.isError) stat.errors += 1;
+		else stat.ok += 1;
+	}
 	stats.toolStats.set(tool, stat);
 	if (tool === ToolNames.Context) {
 		const rawTurnId = (event as { turnId?: unknown }).turnId;
@@ -267,6 +277,7 @@ interface HeadlessTerminalOutcome {
 }
 
 async function recordHeadlessMainAgentReceipt(input: {
+	runId: string;
 	chat: ChatLoop;
 	task: string;
 	startedAt: string;
@@ -289,6 +300,7 @@ async function recordHeadlessMainAgentReceipt(input: {
 	const outcomeDetail = input.terminal.failureMessage;
 	const ledger = openLedger();
 	const envelope = ledger.create({
+		id: input.runId,
 		agentId: "main-agent",
 		executionRole: "builder",
 		requestOrigin: "user",
@@ -394,10 +406,14 @@ function defaultShutdownHooks(): HeadlessShutdownHooks {
 }
 
 export async function runHeadlessMainAgent(chat: ChatLoop, options: HeadlessMainAgentOptions): Promise<number> {
+	// Children need the authoritative parent before submit can invoke dispatch.
+	// The terminal writer reuses this identity whichever settlement path wins.
+	const runId = newRunId();
 	const mode = options.mode ?? "text";
 	const jsonEvents = options.jsonEvents ?? "full";
 	const startedAt = new Date().toISOString();
 	let result: HeadlessMainAgentResult = {
+		outputExhausted: false,
 		text: "",
 		error: null,
 		sawTerminatingToolResult: false,
@@ -422,6 +438,7 @@ export async function runHeadlessMainAgent(chat: ChatLoop, options: HeadlessMain
 		if (sealed !== null) return sealed;
 		const endedAt = new Date().toISOString();
 		sealed = recordHeadlessMainAgentReceipt({
+			runId,
 			chat,
 			task: options.prompt,
 			startedAt,
@@ -526,6 +543,7 @@ export async function runHeadlessMainAgent(chat: ChatLoop, options: HeadlessMain
 	try {
 		if (mode === "json" && jsonEvents === "terminal") writeTerminalTurnStart();
 		const submitOptions = {
+			hostRun: { runId, lineage: { parentRunId: null, rootRunId: runId, depth: 0, attempt: 0 } },
 			...(options.images && options.images.length > 0 ? { images: options.images } : {}),
 			...(options.workingContextPaths && options.workingContextPaths.length > 0
 				? { workingContextPaths: options.workingContextPaths }
@@ -573,6 +591,15 @@ export async function runHeadlessMainAgent(chat: ChatLoop, options: HeadlessMain
 	} else if (result.error) {
 		terminal = { exitCode: 1, outcome: "failed", status: "failed", failureMessage: result.error };
 		stderrMessage = prefixHeadlessFailure(chat, result.error);
+	} else if (result.outputExhausted && !result.sawTerminatingToolResult) {
+		// The provider returned normally, but generation exhausted its budget.
+		// Earlier chatter and partial prose cannot turn that terminal cause into
+		// success. A later assistant message or terminating tool supersedes it.
+		const failureMessage =
+			"clio-coder run: output token limit reached (stopReason=length); generation incomplete. Consider resuming with a narrower task, lower reasoning effort, or a larger output budget.";
+		terminal = { exitCode: 1, outcome: "failed", status: "failed", failureMessage };
+		stderrMessage = failureMessage;
+		if (mode === "text" && result.text.length > 0) stdoutMessage = result.text;
 	} else if (result.text.length === 0 && !result.sawTerminatingToolResult) {
 		const failureMessage =
 			result.lastNotice !== null
@@ -611,7 +638,8 @@ export async function runHeadlessMainAgent(chat: ChatLoop, options: HeadlessMain
 
 	if (stderrMessage !== null) {
 		process.stderr.write(`${stderrMessage}\n`);
-	} else if (stdoutMessage !== null) {
+	}
+	if (stdoutMessage !== null) {
 		writeRawStdout(`${stdoutMessage}\n`);
 	}
 	await flushRawStdout();

package/src/cli/oauth-manual-input.ts

@@ -6,7 +6,7 @@ export interface DelayedManualCodeInput {
 }
 
 export function createDelayedManualCodeInput(
-	rl: ReadlineInterface,
+	rl: Pick<ReadlineInterface, "question">,
 	prompt: string,
 	options?: { delayMs?: number },
 ): DelayedManualCodeInput {

package/src/cli/reset.ts

@@ -372,6 +372,8 @@ export async function runResetCommand(argv: ReadonlyArray<string>): Promise<numb
 		presenter.finish();
 		return 1;
 	}
+	if (args.config || args.all) presenter.commandAdvice("Set up a model again:", "clio-coder configure");
+	else if (args.auth) presenter.commandAdvice("Reconnect your providers:", "clio-coder configure --section targets");
 
 	presenter.done("Done");
 	return 0;

package/src/cli/run.ts

@@ -2,6 +2,7 @@ import { type ClioSettings, readSettings } from "../core/config.js";
 import { loadDomains } from "../core/domain-loader.js";
 import { readFileArgsAsync } from "../core/file-references.js";
 import { withRunOverrides } from "../core/run-overrides.js";
+import { readStrictLayeredSettings } from "../core/settings-layers.js";
 import { clioDataDir } from "../core/xdg.js";
 import type { AgentsContract } from "../domains/agents/contract.js";
 import { AgentsDomainModule } from "../domains/agents/index.js";
@@ -101,15 +102,15 @@ function hasDispatchOnlyOptions(parsed: RunCliArgs): boolean {
 
 /**
  * True when an explicit --target override names a target that is not in
- * settings.targets. `readSettings().targets` is the same source the runtime
- * resolver checks (providers.getTarget), so this mirrors its `target-not-found`
+ * effective settings.targets. Include project overlays just as the runtime
+ * resolver does (providers.getTarget), so this mirrors its `target-not-found`
  * verdict without booting the providers domain. Unreadable/invalid settings
  * fall through (returns false) so the normal boot path surfaces that error
  * instead of a misleading "target not found".
  */
-function explicitTargetMissing(targetId: string): boolean {
+export function explicitTargetMissing(targetId: string): boolean {
 	try {
-		return !readSettings().targets.some((target) => target.id === targetId);
+		return !readStrictLayeredSettings(process.cwd()).settings.targets.some((target) => target.id === targetId);
 	} catch {
 		return false;
 	}
@@ -163,9 +164,9 @@ function explicitSkillPathErrors(skillPaths: ReadonlyArray<string>): string[] {
 }
 
 /**
- * The TUI's verdict for a command-shaped token the registry does not own,
- * applied to a headless task. Returns the refusal message, or null when the
- * task is not an unknown command.
+ * Refuse commands the headless prompt path cannot execute. Skill invocations
+ * and prompt templates have production expansion paths; interactive commands
+ * do not, so accepting them would send their literal text to the model.
  *
  * `parseSlashCommand` is the canonical shape test and the canonical registry
  * walk, so a token that is one word of letters, digits, hyphens, or colons and
@@ -190,11 +191,14 @@ function explicitSkillPathErrors(skillPaths: ReadonlyArray<string>): string[] {
  * closure sits on. Boundaries rule6 in `tests/boundaries/check-boundaries.ts`
  * holds both halves of that.
  */
-async function unknownSlashCommandRefusal(task: string): Promise<string | null> {
+async function headlessSlashCommandRefusal(task: string): Promise<string | null> {
 	if (!task.trim().startsWith("/")) return null;
 	const { parseSlashCommand } = await import("../interactive/slash-commands.js");
 	const command = parseSlashCommand(task);
-	if (command.kind !== "unknown-command") return null;
+	if (command.kind === "skill-invocation" || command.kind === "unknown" || command.kind === "empty") return null;
+	if (command.kind !== "unknown-command") {
+		return "interactive commands are not supported by clio-coder run; use interactive chat or the corresponding CLI command";
+	}
 	const { loadPromptTemplates } = await import("../domains/resources/index.js");
 	const templates = loadPromptTemplates({ cwd: process.cwd() });
 	if (templates.items.some((template) => template.name === command.token)) return null;
@@ -260,11 +264,9 @@ export async function runClioRun(
 			if (!assembled) return 2;
 
 			if (parsed.agentId === undefined) {
-				// A mistyped slash command is a usage error, not a task. Refusing it
-				// here keeps it from booting a session and spending a model turn on a
-				// command that was never run, which is what the TUI has always done
-				// and what docs/guide/extensions-and-sharing.md documents for both surfaces.
-				const slashRefusal = await unknownSlashCommandRefusal(assembled.prompt);
+				// Reject unknown and unsupported interactive commands before boot;
+				// neither has a headless handler that could honor the request.
+				const slashRefusal = await headlessSlashCommandRefusal(assembled.prompt);
 				if (slashRefusal !== null) {
 					process.stderr.write(`clio-coder run: ${slashRefusal}\n`);
 					return 2;

package/src/cli/select.ts

@@ -48,6 +48,8 @@ export interface SelectOptions<T> {
 	backLabel?: string;
 	/** Rows to show at once. Defaults to what the terminal has room for. */
 	maxVisible?: number;
+	/** Filter a long list by typing; q/j/k are text in this mode. */
+	searchable?: boolean;
 	/**
 	 * Erase the menu once it is answered, leaving the caller's transcript to say
 	 * what was chosen. A wizard that redraws its own answer rows needs this; a
@@ -243,7 +245,7 @@ function viewportFor(output: NodeJS.WriteStream, overhead: number, total: number
 export async function promptSelect<T>(options: SelectOptions<T>): Promise<SelectResult<T>> {
 	const input = options.input ?? process.stdin;
 	const output = options.output ?? process.stdout;
-	const choices = options.choices;
+	let choices = options.choices;
 	if (choices.length === 0) return { kind: "back" };
 
 	const rail = options.railPrefix ?? "";
@@ -255,15 +257,25 @@ export async function promptSelect<T>(options: SelectOptions<T>): Promise<Select
 
 	let index = Math.min(Math.max(options.initialIndex ?? 0, 0), choices.length - 1);
 	let windowStart = 0;
+	let query = "";
+	const filter = () => {
+		choices = options.choices.filter((choice) => choice.label.toLowerCase().includes(query.toLowerCase()));
+		index = 0;
+		windowStart = 0;
+		render();
+	};
 
 	const render = (): void => {
-		const viewport = viewportFor(output, head.length + 5, choices.length, options.maxVisible);
+		const viewport = viewportFor(output, head.length + (options.searchable ? 6 : 5), choices.length, options.maxVisible);
 		if (index < windowStart) windowStart = index;
 		else if (index >= windowStart + viewport) windowStart = index - viewport + 1;
 		windowStart = Math.max(0, Math.min(windowStart, choices.length - viewport));
 		const lines: string[] = [];
 		for (const line of head) lines.push(`${rail}${line}`.trimEnd());
 		if (head.length > 0) lines.push(rail.trimEnd());
+		if (options.searchable)
+			lines.push(`${rail}${truncate(`Filter: ${query || "(type to search)"}`, terminalColumns(output) - railWidth)}`);
+		if (choices.length === 0) lines.push(`${rail}No matching models`);
 		lines.push(
 			...choiceRows(
 				{
@@ -284,7 +296,8 @@ export async function promptSelect<T>(options: SelectOptions<T>): Promise<Select
 		// "quit" reads as two different exits.
 		const legend = ["↑/↓ move", "enter select"];
 		if (options.backLabel !== undefined && options.backLabel !== "quit") legend.push(`esc ${options.backLabel}`);
-		legend.push(options.backLabel === "quit" ? "esc or q quit" : "q quit");
+		if (options.searchable) legend.push("type to filter", "ctrl-u clear", "ctrl-c quit");
+		else legend.push(options.backLabel === "quit" ? "esc or q quit" : "q quit");
 		lines.push(`${rail}${chalk.dim(legend.join(" · "))}`);
 		frame.draw(lines);
 	};
@@ -294,11 +307,29 @@ export async function promptSelect<T>(options: SelectOptions<T>): Promise<Select
 		output,
 		true,
 		render,
-		(_str, key, finish) => {
+		(str, key, finish) => {
 			if (key.ctrl && (key.name === "c" || key.name === "d")) {
 				finish({ kind: "quit" });
 				return;
 			}
+			if (options.searchable) {
+				if (key.ctrl && key.name === "u") {
+					query = "";
+					filter();
+					return;
+				}
+				if (key.name === "backspace") {
+					query = query.slice(0, -1);
+					filter();
+					return;
+				}
+				if (!key.ctrl && !key.meta && str?.length === 1 && str >= " " && str !== "\x7f") {
+					query += str;
+					filter();
+					return;
+				}
+				if (choices.length === 0 && !["escape", "left"].includes(key.name ?? "")) return;
+			}
 			switch (key.name) {
 				case "up":
 				case "k":