@sayknow-cli/coding-agent 0.2.7 → 0.3.1

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

@@ -369,6 +369,9 @@
       {
         "id": "revision"
       },
+      {
+        "id": "post-interview"
+      },
       {
         "id": "adr"
       },
@@ -401,6 +404,26 @@
         "to": "revision",
         "verb": "write-artifact"
       },
+      {
+        "from": "revision",
+        "to": "post-interview",
+        "verb": "write-artifact"
+      },
+      {
+        "from": "critic",
+        "to": "post-interview",
+        "verb": "write-artifact"
+      },
+      {
+        "from": "post-interview",
+        "to": "revision",
+        "verb": "write-artifact"
+      },
+      {
+        "from": "post-interview",
+        "to": "adr",
+        "verb": "write-artifact"
+      },
       {
         "from": "revision",
         "to": "adr",
@@ -435,6 +458,11 @@
         "from": "adr",
         "to": "handoff",
         "verb": "handoff"
+      },
+      {
+        "from": "post-interview",
+        "to": "handoff",
+        "verb": "handoff"
       }
     ],
     "typedArgs": [
@@ -592,6 +620,7 @@
           "architect",
           "critic",
           "revision",
+          "post-interview",
           "adr",
           "final"
         ],
@@ -1443,7 +1472,8 @@
         "appliesToVerbs": [
           "checkpoint",
           "record-review-blockers",
-          "steer"
+          "steer",
+          "classify-blocker"
         ],
         "name": "evidence",
         "required": true,
@@ -1471,6 +1501,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 +1619,8 @@
           "review",
           "checkpoint",
           "record-review-blockers",
-          "steer"
+          "steer",
+          "classify-blocker"
         ],
         "name": "json",
         "type": "boolean"
@@ -1651,6 +1701,10 @@
         "name": "steer",
         "surface": "command-positional"
       },
+      {
+        "name": "classify-blocker",
+        "surface": "command-positional"
+      },
       {
         "name": "graph",
         "planned": true,

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

@@ -172,12 +172,16 @@ export const WORKFLOW_MANIFEST: Record<CanonicalSkcWorkflowSkill, SkillManifest>
 	}),
 	ralplan: manifest({
 		skill: "ralplan",
-		states: ["planner", "architect", "critic", "revision", "adr", "final", "handoff"],
+		states: ["planner", "architect", "critic", "revision", "post-interview", "adr", "final", "handoff"],
 		terminalStates: ["final", "handoff"],
 		transitions: [
 			{ from: "planner", to: "architect", verb: "write-artifact" },
 			{ from: "architect", to: "critic", verb: "write-artifact" },
 			{ from: "critic", to: "revision", verb: "write-artifact" },
+			{ from: "revision", to: "post-interview", verb: "write-artifact" },
+			{ from: "critic", to: "post-interview", verb: "write-artifact" },
+			{ from: "post-interview", to: "revision", verb: "write-artifact" },
+			{ from: "post-interview", to: "adr", verb: "write-artifact" },
 			{ from: "revision", to: "adr", verb: "write-artifact" },
 			{ from: "adr", to: "final", verb: "write-artifact" },
 			{ from: "planner", to: "handoff", verb: "handoff" },
@@ -185,6 +189,7 @@ export const WORKFLOW_MANIFEST: Record<CanonicalSkcWorkflowSkill, SkillManifest>
 			{ from: "critic", to: "handoff", verb: "handoff" },
 			{ from: "revision", to: "handoff", verb: "handoff" },
 			{ from: "adr", to: "handoff", verb: "handoff" },
+			{ from: "post-interview", to: "handoff", verb: "handoff" },
 		],
 		verbs: [...stateVerbs(), ...flagVerbs(["kickoff", "write-artifact"]), ...plannedVerbs(PLANNED_ADMIN_VERBS)],
 		typedArgs: [
@@ -196,7 +201,7 @@ export const WORKFLOW_MANIFEST: Record<CanonicalSkcWorkflowSkill, SkillManifest>
 			{
 				name: "stage",
 				type: "enum",
-				enumValues: ["planner", "architect", "critic", "revision", "adr", "final"],
+				enumValues: ["planner", "architect", "critic", "revision", "post-interview", "adr", "final"],
 				appliesToVerbs: ["write-artifact"],
 			},
 			{ name: "stage_n", type: "number", appliesToVerbs: ["write-artifact"] },
@@ -237,6 +242,7 @@ export const WORKFLOW_MANIFEST: Record<CanonicalSkcWorkflowSkill, SkillManifest>
 				"review",
 				"record-review-blockers",
 				"steer",
+				"classify-blocker",
 			]),
 			...plannedVerbs(PLANNED_ADMIN_VERBS),
 		],
@@ -263,11 +269,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 +321,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/fetch.ts

@@ -16,6 +16,8 @@ import { renderStatusLine } from "../tui";
 import { CachedOutputBlock } from "../tui/output-block";
 import { formatDimensionNote, resizeImage } from "../utils/image-resize";
 import { ensureTool } from "../utils/tools-manager";
+import { INSANE_NOTES, tryInsaneFetch } from "../web/insane/bridge";
+import { validatePublicHttpUrlForInsane } from "../web/insane/url-guard";
 import { extractWithParallel, findParallelApiKey, getParallelExtractContent } from "../web/parallel";
 import { specialHandlers } from "../web/scrapers";
 import type { RenderResult } from "../web/scrapers/types";
@@ -705,6 +707,55 @@ async function handleSpecialUrls(
 // Main Render Function
 // =============================================================================
 
+/**
+ * Opt-in insane-search fallback for blocked / degraded public URL reads.
+ *
+ * Returns a finalized `method: "insane"` result on success, or null (so the
+ * caller continues with its normal degraded behavior). Fail-closed: no note,
+ * guard DNS, dependency probe, or subprocess when raw mode or the opt-in
+ * setting is off. The public-URL guard runs BEFORE any probe/spawn.
+ */
+export async function tryInsaneFallback(args: {
+	url: string;
+	finalUrl: string;
+	timeout: number;
+	raw: boolean;
+	settings: Settings;
+	signal: AbortSignal | undefined;
+	fetchedAt: string;
+	notes: string[];
+}): Promise<FetchRenderResult | null> {
+	if (args.raw) return null;
+	if (args.settings.get("web.insaneFallback") !== true) return null;
+
+	const target = args.finalUrl || args.url;
+	const guard = await validatePublicHttpUrlForInsane(target);
+	if (!guard.ok) {
+		args.notes.push(INSANE_NOTES.guardBlocked(guard.reason));
+		return null;
+	}
+
+	const result = await tryInsaneFetch(guard.url.toString(), {
+		timeoutMs: args.timeout * 1000,
+		signal: args.signal,
+	});
+	if (result.ok) {
+		const output = finalizeOutput(result.content);
+		return {
+			url: args.url,
+			finalUrl: target,
+			contentType: "text/markdown",
+			method: "insane",
+			content: output.content,
+			fetchedAt: args.fetchedAt,
+			truncated: output.truncated,
+			notes: [...args.notes, ...result.notes],
+		};
+	}
+	for (const note of result.notes) args.notes.push(note);
+	return null;
+}
+
 /**
  * Main render function implementing the full pipeline
  */
@@ -751,6 +802,19 @@ async function renderUrl(
 		throw new ToolAbortError();
 	}
 	if (!response.ok) {
+		const failureNote = response.status ? `Failed to fetch URL (HTTP ${response.status})` : "Failed to fetch URL";
+		notes.push(failureNote);
+		const insane = await tryInsaneFallback({
+			url,
+			finalUrl: response.finalUrl || url,
+			timeout,
+			raw,
+			settings,
+			signal,
+			fetchedAt,
+			notes,
+		});
+		if (insane) return insane;
 		return {
 			url,
 			finalUrl: response.finalUrl || url,
@@ -759,7 +823,7 @@ async function renderUrl(
 			content: "",
 			fetchedAt,
 			truncated: false,
-			notes: [response.status ? `Failed to fetch URL (HTTP ${response.status})` : "Failed to fetch URL"],
+			notes,
 		};
 	}
 
@@ -1062,6 +1126,8 @@ async function renderUrl(
 		const htmlResult = await renderHtmlToText(finalUrl, rawContent, timeout, settings, signal, storage);
 		if (!htmlResult.ok) {
 			notes.push("html rendering failed (lynx/html2text unavailable)");
+			const insane = await tryInsaneFallback({ url, finalUrl, timeout, raw, settings, signal, fetchedAt, notes });
+			if (insane) return insane;
 			const output = finalizeOutput(rawContent);
 			return {
 				url,
@@ -1122,6 +1188,17 @@ async function renderUrl(
 				};
 			}
 
+			const insaneLowQuality = await tryInsaneFallback({
+				url,
+				finalUrl,
+				timeout,
+				raw,
+				settings,
+				signal,
+				fetchedAt,
+				notes,
+			});
+			if (insaneLowQuality) return insaneLowQuality;
 			notes.push("Page appears to require JavaScript or is mostly navigation");
 		}
 

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

@@ -58,6 +58,7 @@ import { SearchToolBm25Tool } from "./search-tool-bm25";
 import { SkillTool } from "./skill";
 import { loadSshTool } from "./ssh";
 import { SubagentTool } from "./subagent";
+import { TelegramSendTool } from "./telegram-send";
 import { type TodoPhase, TodoWriteTool } from "./todo-write";
 import { WriteTool } from "./write";
 import { YieldTool } from "./yield";
@@ -96,6 +97,7 @@ export * from "./search-tool-bm25";
 export * from "./skill";
 export * from "./ssh";
 export * from "./subagent";
+export * from "./telegram-send";
 export * from "./todo-write";
 export * from "./vim";
 export * from "./write";
@@ -118,6 +120,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 +228,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. */
@@ -383,6 +404,7 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	todo_write: s => new TodoWriteTool(s),
 	web_search: s => new WebSearchTool(s),
 	search_tool_bm25: SearchToolBm25Tool.createIf,
+	telegram_send: TelegramSendTool.createIf,
 	write: s => new WriteTool(s),
 	skill: SkillTool.createIf,
 	goal: s => new GoalTool(s),

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