@sayknow-cli/coding-agent 0.2.6 → 0.3.0

package/src/skc-runtime/ultragoal-runtime.ts

@@ -898,32 +898,29 @@ function categorizeComputerChangePath(value: string): UltragoalChangeCategory {
 	return "other";
 }
 
-function isComputerChangePath(row: UltragoalChangeSetPath): boolean {
+function isComputerControlSurfaceCategory(category: UltragoalChangeCategory): boolean {
 	return (
-		categorizeComputerChangePath(row.path) !== "other" ||
-		(row.oldPath ? categorizeComputerChangePath(row.oldPath) !== "other" : false)
+		category === "code" || category === "generated-binding" || category === "tool" || category === "settings-registry"
 	);
 }
 
-function isDocsOnlyStaticComputerChangeSet(changeSet: UltragoalChangeSet | undefined): boolean {
-	if (!changeSet || changeSet.paths.length === 0) return false;
-	return changeSet.paths.every(row => {
-		const category = row.category ?? categorizeComputerChangePath(row.path);
-		const oldCategory = row.oldPath ? categorizeComputerChangePath(row.oldPath) : category;
-		return category === "docs-static" && oldCategory === "docs-static";
-	});
+function isComputerControlSurfaceChangePath(row: UltragoalChangeSetPath): boolean {
+	const category = row.category ?? categorizeComputerChangePath(row.path);
+	const oldCategory = row.oldPath ? categorizeComputerChangePath(row.oldPath) : category;
+	return isComputerControlSurfaceCategory(category) || isComputerControlSurfaceCategory(oldCategory);
 }
 
 function trustedChangeSetRequiresComputerSuite(changeSet: UltragoalChangeSet | undefined): boolean {
 	if (!changeSet?.trusted) return false;
-	if (isDocsOnlyStaticComputerChangeSet(changeSet)) return false;
-	return changeSet.paths.some(isComputerChangePath);
+	return changeSet.paths.some(isComputerControlSurfaceChangePath);
 }
 
 function requiresComputerRedTeamSuite(executorQa: JsonObject, changeSet: UltragoalChangeSet | undefined): boolean {
 	if (trustedChangeSetRequiresComputerSuite(changeSet)) return true;
 	const declaredPaths = Array.isArray(executorQa.changedPaths) ? executorQa.changedPaths : [];
-	return declaredPaths.some(value => typeof value === "string" && categorizeComputerChangePath(value) !== "other");
+	return declaredPaths.some(
+		value => typeof value === "string" && isComputerControlSurfaceCategory(categorizeComputerChangePath(value)),
+	);
 }
 
 function normalizeAdversarialCaseId(value: string): string {
@@ -2853,6 +2850,33 @@ export async function recordUltragoalReviewBlockers(input: {
 	return plan;
 }
 
+export type UltragoalBlockerClassification = "human_blocked" | "resolvable";
+
+/**
+ * Record an audited blocker triage classification in the durable ledger. A
+ * `human_blocked` classification is the only thing that authorizes
+ * `goal({"op":"pause"})` while an Ultragoal run is active; `resolvable` is an
+ * audit note and never unblocks pause.
+ */
+export async function recordUltragoalBlockerClassification(input: {
+	cwd: string;
+	classification: UltragoalBlockerClassification;
+	evidence: string;
+	goalId?: string;
+}): Promise<UltragoalLedgerEvent> {
+	const evidence = input.evidence.trim();
+	if (!evidence) throw new Error("classify-blocker --evidence is required");
+	if (input.classification !== "human_blocked" && input.classification !== "resolvable") {
+		throw new Error('classify-blocker --classification must be "human_blocked" or "resolvable"');
+	}
+	return appendLedger(input.cwd, {
+		event: "blocker_classified",
+		classification: input.classification,
+		...(input.goalId?.trim() ? { goalId: input.goalId.trim() } : {}),
+		evidence,
+	});
+}
+
 type UltragoalReviewMode = "review-only" | "review-start";
 type UltragoalReviewContractStrength = "strong" | "thin-derived";
 
@@ -2920,11 +2944,33 @@ async function spawnText(
 	}
 }
 
-async function resolveGitBase(cwd: string, branch?: string): Promise<string> {
-	const candidates = branch ? [branch] : ["origin/main", "origin/master", "main", "master"];
-	for (const candidate of candidates) {
-		const exists = await spawnText(["git", "rev-parse", "--verify", candidate], { cwd, timeoutMs: 3000 });
-		if (exists.ok) return candidate;
+export async function resolveGitBase(cwd: string, branch?: string): Promise<string> {
+	if (branch) {
+		const exists = await spawnText(["git", "rev-parse", "--verify", branch], { cwd, timeoutMs: 3000 });
+		if (exists.ok) return branch;
+	} else {
+		// Prefer the NEAREST integration base (the branch this work actually forks
+		// from) rather than always `main`. A branch opened against `dev` must be
+		// scoped to `dev`; using a stale `main` sweeps in unrelated trunk history
+		// and mis-attributes other people's changes to this story (e.g. falsely
+		// tripping change-scoped gates). Among existing candidates, pick the one
+		// whose merge-base with HEAD is closest to HEAD (fewest commits ahead).
+		const candidates = ["origin/dev", "dev", "origin/main", "origin/master", "main", "master"];
+		let best: { ref: string; ahead: number } | undefined;
+		for (const candidate of candidates) {
+			const exists = await spawnText(["git", "rev-parse", "--verify", candidate], { cwd, timeoutMs: 3000 });
+			if (!exists.ok) continue;
+			const mergeBase = await spawnText(["git", "merge-base", "HEAD", candidate], { cwd, timeoutMs: 3000 });
+			if (!mergeBase.ok || !mergeBase.stdout.trim()) continue;
+			const count = await spawnText(["git", "rev-list", "--count", `${mergeBase.stdout.trim()}..HEAD`], {
+				cwd,
+				timeoutMs: 3000,
+			});
+			const ahead = Number.parseInt(count.stdout.trim(), 10);
+			if (!Number.isFinite(ahead)) continue;
+			if (!best || ahead < best.ahead) best = { ref: candidate, ahead };
+		}
+		if (best) return best.ref;
 	}
 	const mergeBase = await spawnText(["git", "merge-base", "HEAD", "origin/main"], { cwd, timeoutMs: 3000 });
 	if (mergeBase.ok && mergeBase.stdout.trim()) return mergeBase.stdout.trim();
@@ -3245,6 +3291,7 @@ const FLAGS_WITH_VALUES = new Set([
 	"--rationale",
 	"--replacements-json",
 	"--order-json",
+	"--classification",
 ]);
 
 function isHelpArg(arg: string): boolean {
@@ -3319,6 +3366,25 @@ function renderUltragoalHelp(args: readonly string[]): string | null {
 			"",
 		].join("\n");
 	}
+	if (subject === "classify-blocker") {
+		return [
+			"Run native SKC Ultragoal workflow commands",
+			"",
+			"USAGE",
+			"  $ skc ultragoal classify-blocker --classification <human_blocked|resolvable> --evidence <text> [FLAGS]",
+			"",
+			"FLAGS",
+			"      --classification=<value>     Required. human_blocked authorizes pause only as the latest ledger event; resolvable never authorizes pause",
+			"      --evidence=<value>           Required. Specific blocker evidence; must name the human-only dependency for human_blocked",
+			"      --goal-id=<value>            Optional durable .skc/ultragoal goal id, e.g. G001",
+			"      --json                       Output a machine-readable receipt",
+			"",
+			"EXAMPLES",
+			'  $ skc ultragoal classify-blocker --classification resolvable --evidence "failing test can be fixed autonomously"',
+			'  $ skc ultragoal classify-blocker --classification human_blocked --evidence "user must provide production API credentials" --goal-id G001',
+			"",
+		].join("\n");
+	}
 	return [
 		"Run native SKC Ultragoal workflow commands",
 		"",
@@ -3333,8 +3399,9 @@ function renderUltragoalHelp(args: readonly string[]): string | null {
 		"  review",
 		"  steer",
 		"  record-review-blockers",
+		"  classify-blocker",
 		"",
-		"Run `skc ultragoal checkpoint --help` or `skc ultragoal review --help` for command-specific requirements.",
+		"Run `skc ultragoal checkpoint --help`, `skc ultragoal review --help`, or `skc ultragoal classify-blocker --help` for command-specific requirements.",
 		"",
 	].join("\n");
 }
@@ -3653,6 +3720,24 @@ async function dispatchUltragoalCommand(args: string[], cwd: string): Promise<Ul
 						: "Recorded review blockers.\n",
 				};
 			}
+			case "classify-blocker": {
+				const event = await recordUltragoalBlockerClassification({
+					cwd,
+					classification: (flagValue(args, "--classification") ?? "") as UltragoalBlockerClassification,
+					evidence: flagValue(args, "--evidence") ?? "",
+					goalId: flagValue(args, "--goal-id"),
+				});
+				return {
+					status: 0,
+					stdout: json
+						? renderCliWriteReceipt({
+								ok: true,
+								event: "blocker_classified",
+								classification: event.classification,
+							})
+						: `Recorded blocker classification: ${String(event.classification)}.\n`,
+				};
+			}
 			default:
 				return { status: 1, stderr: `Unknown skc ultragoal command: ${command}\n` };
 		}
@@ -3670,6 +3755,7 @@ const RECONCILE_COMMANDS = new Set([
 	"steer",
 	"record-review-blockers",
 	"review",
+	"classify-blocker",
 ]);
 
 /**

package/src/skc-runtime/workflow-manifest.generated.json

@@ -1443,7 +1443,8 @@
         "appliesToVerbs": [
           "checkpoint",
           "record-review-blockers",
-          "steer"
+          "steer",
+          "classify-blocker"
         ],
         "name": "evidence",
         "required": true,
@@ -1471,6 +1472,25 @@
         "name": "goal-id",
         "type": "string"
       },
+      {
+        "appliesToVerbs": [
+          "classify-blocker"
+        ],
+        "name": "goal-id",
+        "type": "string"
+      },
+      {
+        "appliesToVerbs": [
+          "classify-blocker"
+        ],
+        "enumValues": [
+          "human_blocked",
+          "resolvable"
+        ],
+        "name": "classification",
+        "required": true,
+        "type": "enum"
+      },
       {
         "appliesToVerbs": [
           "steer"
@@ -1570,7 +1590,8 @@
           "review",
           "checkpoint",
           "record-review-blockers",
-          "steer"
+          "steer",
+          "classify-blocker"
         ],
         "name": "json",
         "type": "boolean"
@@ -1651,6 +1672,10 @@
         "name": "steer",
         "surface": "command-positional"
       },
+      {
+        "name": "classify-blocker",
+        "surface": "command-positional"
+      },
       {
         "name": "graph",
         "planned": true,

package/src/skc-runtime/workflow-manifest.ts

@@ -237,6 +237,7 @@ export const WORKFLOW_MANIFEST: Record<CanonicalSkcWorkflowSkill, SkillManifest>
 				"review",
 				"record-review-blockers",
 				"steer",
+				"classify-blocker",
 			]),
 			...plannedVerbs(PLANNED_ADMIN_VERBS),
 		],
@@ -263,11 +264,19 @@ export const WORKFLOW_MANIFEST: Record<CanonicalSkcWorkflowSkill, SkillManifest>
 				name: "evidence",
 				type: "string",
 				required: true,
-				appliesToVerbs: ["checkpoint", "record-review-blockers", "steer"],
+				appliesToVerbs: ["checkpoint", "record-review-blockers", "steer", "classify-blocker"],
 			},
 			{ name: "skc-goal-json", type: "string", appliesToVerbs: ["checkpoint", "record-review-blockers"] },
 			{ name: "quality-gate-json", type: "string", appliesToVerbs: ["checkpoint"] },
 			{ name: "goal-id", type: "string", appliesToVerbs: ["steer"] },
+			{ name: "goal-id", type: "string", appliesToVerbs: ["classify-blocker"] },
+			{
+				name: "classification",
+				type: "enum",
+				enumValues: ["human_blocked", "resolvable"],
+				required: true,
+				appliesToVerbs: ["classify-blocker"],
+			},
 			{
 				name: "kind",
 				type: "enum",
@@ -307,6 +316,7 @@ export const WORKFLOW_MANIFEST: Record<CanonicalSkcWorkflowSkill, SkillManifest>
 					"checkpoint",
 					"record-review-blockers",
 					"steer",
+					"classify-blocker",
 				],
 			},
 			{ name: "directive-json", type: "string", appliesToVerbs: ["steer"], planned: true },

package/src/slash-commands/builtin-registry.ts

@@ -798,7 +798,10 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 				return;
 			}
 
-			runtime.ctx.showProviderOnboarding();
+			runtime.ctx.showOAuthSelector("login", undefined, {
+				allowExternalCredentialDiscovery: true,
+				trigger: "bare-login",
+			});
 			runtime.ctx.editor.setText("");
 		},
 	},

package/src/task/executor.ts

@@ -1298,11 +1298,15 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					requestPause: () => {
 						pauseRequested = true;
 					},
-					injectMessage: async (content, deliverAs) => {
+					injectMessage: async (content, deliverAs, opts) => {
 						if (deliverAs === "nextTurn") {
 							await session.prompt(content, { attribution: "agent" });
 							return;
 						}
+						if (deliverAs === "steer") {
+							const from = opts?.fromAgentId ?? manager.getSubagentRecord(liveSubagentId)?.ownerId ?? "?";
+							session.emitSubagentSteerObservation({ from, to: liveSubagentId, body: content });
+						}
 						await session.sendUserMessage(content, { deliverAs });
 					},
 				});

package/src/tools/ask-answer-registry.ts

@@ -0,0 +1,25 @@
+/**
+ * Process-wide registry mapping a session id to its active {@link AskAnswerSource}.
+ *
+ * Decouples the `ask` tool (which reads the source via `AgentSession`) from the
+ * notifications extension (which registers one), without threading a new method
+ * through the extension/runner/controller wiring. A session has at most one
+ * source; registering returns a disposer.
+ */
+
+import type { AskAnswerSource } from "./index";
+
+const sources = new Map<string, AskAnswerSource>();
+
+/** Register `source` for `sessionId`. Returns a disposer that clears it. */
+export function registerAskAnswerSource(sessionId: string, source: AskAnswerSource): () => void {
+	sources.set(sessionId, source);
+	return () => {
+		if (sources.get(sessionId) === source) sources.delete(sessionId);
+	};
+}
+
+/** The answer source for `sessionId`, if one is registered. */
+export function getAskAnswerSource(sessionId: string): AskAnswerSource | undefined {
+	return sources.get(sessionId);
+}

package/src/tools/ask.ts

@@ -430,8 +430,18 @@ async function askSingleQuestion(
 				// If input was dismissed (undefined), keep prior selectedOptions/customInput intact
 			}
 		} else {
-			selectedOptions = [stripRecommendedSuffix(choice)];
-			customInput = undefined;
+			const stripped = stripRecommendedSuffix(choice);
+			if (optionLabels.includes(stripped)) {
+				selectedOptions = [stripped];
+				customInput = undefined;
+			} else {
+				// A remote answer (e.g. a typed Telegram reply) that is not one of the
+				// listed options is the "provide my own" custom input — recorded the same
+				// as picking Other and typing it. The local selector can only ever return
+				// a listed entry, so this branch is reached only for free-text answers.
+				customInput = choice;
+				selectedOptions = [];
+			}
 		}
 		if (navigation?.allowForward) {
 			return { selectedOptions, customInput, timedOut, navigation: "forward" };
@@ -551,11 +561,71 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 		const ui: UIContext = {
 			select: (prompt, options, dialogOptions) => {
 				if (!extensionUi) throw new ToolAbortError("Ask tool requires interactive mode");
-				return extensionUi.select(prompt, options, dialogOptions);
+				const source = this.session.getAskAnswerSource?.();
+				if (!source) return extensionUi.select(prompt, options, dialogOptions);
+				// Race the local UI against a remote answer (e.g. a Telegram reply via the
+				// notifications SDK) so asks can be answered without RPC mode. When the
+				// local UI wins, abort the remote source so it stops waiting and marks the
+				// action resolved-locally. First valid answer wins.
+				// Race the local UI against a remote answer (e.g. a Telegram reply via the
+				// notifications SDK) so asks can be answered without RPC mode. First valid
+				// answer wins; the loser is aborted so neither side is left hanging:
+				//   - local wins  -> abort the remote source (marks the action resolved-locally)
+				//   - remote wins -> abort the local selector so the TUI dialog actually closes
+				const remoteController = new AbortController();
+				const localController = new AbortController();
+				// Propagate an external cancel (the tool's signal) to the local selector too.
+				const toolSignal = dialogOptions?.signal;
+				if (toolSignal) {
+					if (toolSignal.aborted) localController.abort();
+					else toolSignal.addEventListener("abort", () => localController.abort(), { once: true });
+				}
+				const remote = source.awaitAnswer(prompt, options, remoteController.signal).then(answer => {
+					// undefined is not a valid remote answer (registration failed, or the local
+					// UI already won and aborted us): never settle the race, let the local
+					// selector decide instead of cancelling the ask.
+					if (answer === undefined) return new Promise<string | undefined>(() => {});
+					localController.abort();
+					return answer;
+				});
+				const local = extensionUi
+					.select(prompt, options, { ...dialogOptions, signal: localController.signal })
+					.then(answer => {
+						remoteController.abort();
+						return answer;
+					});
+				// The losing selector may reject when aborted after the race already settled;
+				// swallow that so it is not an unhandled rejection (the race result is unaffected).
+				void local.catch(() => undefined);
+				return Promise.race([local, remote]);
 			},
 			editor: (title, prefill, dialogOptions, editorOptions) => {
 				if (!extensionUi) throw new ToolAbortError("Ask tool requires interactive mode");
-				return extensionUi.editor(title, prefill, dialogOptions, editorOptions);
+				const source = this.session.getAskAnswerSource?.();
+				if (!source) return extensionUi.editor(title, prefill, dialogOptions, editorOptions);
+				// Race the local editor against a remote free-text answer so "Other / type
+				// your own" custom input can be provided remotely (e.g. a typed Telegram
+				// reply) instead of blocking on the local-only editor. Mirrors `select`.
+				const remoteController = new AbortController();
+				const localController = new AbortController();
+				const toolSignal = dialogOptions?.signal;
+				if (toolSignal) {
+					if (toolSignal.aborted) localController.abort();
+					else toolSignal.addEventListener("abort", () => localController.abort(), { once: true });
+				}
+				const remote = source.awaitAnswer(title, [], remoteController.signal).then(answer => {
+					if (answer === undefined) return new Promise<string | undefined>(() => {});
+					localController.abort();
+					return answer;
+				});
+				const local = extensionUi
+					.editor(title, prefill, { ...(dialogOptions ?? {}), signal: localController.signal }, editorOptions)
+					.then(answer => {
+						remoteController.abort();
+						return answer;
+					});
+				void local.catch(() => undefined);
+				return Promise.race([local, remote]);
 			},
 		};
 
@@ -605,8 +675,9 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 			}
 			try {
 				const deepInterviewPrompt = formatDeepInterviewSelectorPrompt(q.question);
+				const isDeepInterviewQuestion = deepInterviewPrompt !== null || q.deepInterview !== undefined;
 				const displayQuestion = deepInterviewPrompt ?? q.question;
-				const shouldNumberOptions = isDeepInterviewAskQuestion(q.question);
+				const shouldNumberOptions = isDeepInterviewQuestion || isDeepInterviewAskQuestion(q.question);
 				const optionLabels = shouldNumberOptions ? numberOptionLabels(rawOptionLabels) : rawOptionLabels;
 				const initialSelection =
 					shouldNumberOptions && options?.previous
@@ -630,7 +701,7 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 					signal,
 					initialSelection,
 					navigation: options?.navigation,
-					scrollTitleRows: deepInterviewPrompt === null ? undefined : DEEP_INTERVIEW_SELECTOR_SCROLL_TITLE_ROWS,
+					scrollTitleRows: isDeepInterviewQuestion ? DEEP_INTERVIEW_SELECTOR_SCROLL_TITLE_ROWS : undefined,
 					otherOptionLabel: shouldNumberOptions
 						? formatNumberedOptionLabel(OTHER_OPTION, optionLabels.length)
 						: undefined,

package/src/tools/image-gen.ts

@@ -472,20 +472,17 @@ async function findImageApiKey(
 		const openAI = await findOpenAIHostedImageCredentials(modelRegistry, activeModel, sessionId);
 		if (openAI) return openAI;
 		// Fall through to auto-detect if preferred provider key not found.
-	} else if (preferredImageProvider === "antigravity" && modelRegistry) {
-		const antigravity = await findAntigravityCredentials(modelRegistry, sessionId);
-		if (antigravity) return antigravity;
-		// Fall through to auto-detect if preferred provider key not found.
+	} else if (preferredImageProvider === "antigravity") {
+		if (!modelRegistry) return null;
+		return await findAntigravityCredentials(modelRegistry, sessionId);
 	} else if (preferredImageProvider === "gemini") {
 		const geminiKey = getEnvApiKey("google");
 		if (geminiKey) return { provider: "gemini", apiKey: geminiKey };
 		const googleKey = $env.GOOGLE_API_KEY;
-		if (googleKey) return { provider: "gemini", apiKey: googleKey };
-		// Fall through to auto-detect if preferred provider key not found.
+		return googleKey ? { provider: "gemini", apiKey: googleKey } : null;
 	} else if (preferredImageProvider === "openrouter") {
 		const openRouterKey = getEnvApiKey("openrouter");
-		if (openRouterKey) return { provider: "openrouter", apiKey: openRouterKey };
-		// Fall through to auto-detect if preferred provider key not found.
+		return openRouterKey ? { provider: "openrouter", apiKey: openRouterKey } : null;
 	}
 
 	// Auto-detect: GPT hosted image generation, then Antigravity, OpenRouter, Gemini.

package/src/tools/index.ts

@@ -118,6 +118,18 @@ export type {
 	DiscoverableToolSource,
 } from "../tool-discovery/tool-index";
 
+/**
+ * Source of remote answers for interactive asks (e.g. a Telegram reply routed
+ * through the notifications SDK). Lets a pending ask resolve without RPC mode.
+ */
+export interface AskAnswerSource {
+	/**
+	 * Race a remote answer against the local UI for one question. Resolves with the
+	 * chosen option label or free-text answer, or `undefined` to defer to local UI.
+	 */
+	awaitAnswer(question: string, options: string[], signal?: AbortSignal): Promise<string | undefined>;
+}
+
 /** Session context for tool factories */
 export interface ToolSession {
 	/** Current working directory */
@@ -214,6 +226,13 @@ export interface ToolSession {
 	getGoalModeState?: () => GoalModeState | undefined;
 	/** Unattended workflow-gate emitter (present only when unattended mode is negotiated). */
 	getWorkflowGateEmitter?: () => WorkflowGateEmitter | undefined;
+	/**
+	 * Optional remote answer source for interactive asks. When present, the ask
+	 * tool races the local UI selection against a remote answer (e.g. a Telegram
+	 * reply via the notifications SDK) so asks can be answered without RPC mode.
+	 * No-op when undefined: the ask path behaves exactly as before.
+	 */
+	getAskAnswerSource?: () => AskAnswerSource | undefined;
 	/** Optional per-session restriction for goal tool operations. */
 	goalToolAllowedOps?: readonly ("create" | "get" | "complete" | "resume" | "drop" | "pause")[];
 	/** Goal runtime for the active agent session. */

package/src/tools/inspect-image.ts

@@ -78,21 +78,26 @@ export class InspectImageTool implements AgentTool<typeof inspectImageSchema, In
 		};
 
 		const activeModelPattern = this.session.getActiveModelString?.() ?? this.session.getModelString?.();
-		let model = resolvePattern("pi/default") ?? resolvePattern(activeModelPattern) ?? availableModels[0];
+		const configuredVisionPattern = this.session.settings.getModelRole("vision")?.trim();
+		const configuredVisionModel = configuredVisionPattern ? resolvePattern("pi/vision") : undefined;
+		if (configuredVisionPattern && !configuredVisionModel) {
+			throw new ToolError(
+				`Configured modelRoles.vision (${configuredVisionPattern}) did not resolve to an available model. Configure modelRoles.vision with a vision-capable model.`,
+			);
+		}
+		const model = configuredVisionModel ?? resolvePattern("pi/default") ?? resolvePattern(activeModelPattern);
 		if (!model) {
-			throw new ToolError("Unable to resolve a model for inspect_image.");
+			throw new ToolError(
+				"Unable to resolve a model for inspect_image. Configure modelRoles.vision with a vision-capable model or select a vision-capable active/default model.",
+			);
 		}
 
-		// inspect_image requires image input; if the resolved model is text-only,
-		// fall back to any available vision-capable model before failing.
+		// inspect_image requires image input. A text-only selected model must be
+		// paired with an explicit vision role so the model/cost boundary is visible.
 		if (!model.input.includes("image")) {
-			const visionModel = availableModels.find(candidate => candidate.input.includes("image"));
-			if (!visionModel) {
-				throw new ToolError(
-					`Resolved model ${model.provider}/${model.id} does not support image input, and no vision-capable model is available. Configure a vision-capable model.`,
-				);
-			}
-			model = visionModel;
+			throw new ToolError(
+				`Resolved model ${model.provider}/${model.id} does not support image input. Configure modelRoles.vision with a vision-capable model.`,
+			);
 		}
 
 		const apiKey = await modelRegistry.getApiKey(model);

package/src/tools/subagent-render.ts

@@ -160,6 +160,13 @@ function renderSubagentSnapshotBody(snapshot: SubagentSnapshot, expanded: boolea
 		lines.push(`  ${theme.fg("dim", "Assignment:")}`);
 		for (const al of snapshot.assignment.split("\n")) lines.push(`    ${theme.fg("toolOutput", replaceTabs(al))}`);
 	}
+	if (snapshot.steerMessage) {
+		lines.push(`  ${theme.fg("accent", `Steer (${snapshot.steerState ?? "queued"})`)}`);
+		const maxLines = expanded ? PREVIEW_LINES_EXPANDED : PREVIEW_LINES_COLLAPSED;
+		for (const pl of getPreviewLines(snapshot.steerMessage, maxLines, PREVIEW_LINE_WIDTH, Ellipsis.Unicode)) {
+			lines.push(`    ${theme.fg("toolOutput", replaceTabs(pl))}`);
+		}
+	}
 
 	// Defense in depth: the producer only attaches `progress` when a live producer
 	// exists (subagent.ts #liveProgressFields), but the renderer also honors an