@gajae-code/coding-agent 0.6.5 → 0.7.0

package/src/setup/host-plugin-setup.ts

@@ -0,0 +1,142 @@
+/**
+ * Host plugin setup for `gjc setup claude` and `gjc setup codex`.
+ *
+ * Renders install guidance and a fail-closed coordinator MCP config preview for
+ * the canonical generated plugin bundle under `plugins/`. This is intentionally
+ * render-only and fail-closed: the workdir allowlist is scoped to the project
+ * root and no mutation class is enabled until the user opts in.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getProjectDir } from "@gajae-code/utils";
+
+export type HostPluginKind = "claude" | "codex";
+
+export interface HostPluginSetupFlags {
+	json?: boolean;
+	check?: boolean;
+	root?: string[];
+	repo?: string;
+}
+
+export interface HostPluginSetupResult {
+	ok: true;
+	host: HostPluginKind;
+	mode: "render";
+	gated: boolean;
+	pluginPath: string;
+	manifestPath: string;
+	marketplacePath: string;
+	installGuidance: string[];
+	coordinatorConfigPreview: {
+		command: string;
+		args: string[];
+		env: Record<string, string>;
+	};
+	mutationPolicy: string;
+	notes: string[];
+	check?: { ok: boolean; checked: string[]; missing: string[] };
+}
+
+const NAMESPACE_LABEL = "gajae-code-plugin";
+
+function resolveProjectRoot(flags: HostPluginSetupFlags): string {
+	const explicit = flags.root?.find(root => root.trim().length > 0);
+	return explicit ? path.resolve(explicit) : getProjectDir();
+}
+
+function verifyBundleFiles(files: string[]): { ok: boolean; checked: string[]; missing: string[] } {
+	const missing = files.filter(file => !fs.existsSync(file));
+	return { ok: missing.length === 0, checked: files, missing };
+}
+
+export function buildHostPluginSetup(host: HostPluginKind, flags: HostPluginSetupFlags = {}): HostPluginSetupResult {
+	const projectRoot = resolveProjectRoot(flags);
+	const marketplaceRoot = path.join(projectRoot, "plugins");
+	const pluginDir = path.join(marketplaceRoot, "gajae-code");
+	const repo = flags.repo && flags.repo.trim().length > 0 ? flags.repo.trim() : NAMESPACE_LABEL;
+
+	// Concrete, fail-closed env: workdir allowlist is the project root, no mutations.
+	const env: Record<string, string> = {
+		GJC_COORDINATOR_MCP_WORKDIR_ROOTS: projectRoot,
+		GJC_COORDINATOR_MCP_REPO: repo,
+		GJC_COORDINATOR_MCP_SESSION_COMMAND: "gjc --worktree",
+	};
+
+	if (host === "claude") {
+		const manifestPath = path.join(pluginDir, ".claude-plugin", "plugin.json");
+		const marketplacePath = path.join(marketplaceRoot, ".claude-plugin", "marketplace.json");
+		return {
+			ok: true,
+			host,
+			mode: "render",
+			gated: false,
+			pluginPath: marketplaceRoot,
+			manifestPath,
+			marketplacePath,
+			installGuidance: [
+				`Add the local marketplace: /plugin marketplace add ${marketplaceRoot}`,
+				"Install the plugin: /plugin install gajae-code",
+				"Then call gjc_delegate_plan / gjc_delegate_execute / gjc_delegate_team from Claude Code.",
+			],
+			coordinatorConfigPreview: { command: "gjc", args: ["mcp-serve", "coordinator"], env },
+			mutationPolicy:
+				"Fail-closed: delegation is read-only until you set GJC_COORDINATOR_MCP_MUTATIONS=sessions and pass allow_mutation:true per call.",
+			notes: [],
+			...(flags.check
+				? { check: verifyBundleFiles([manifestPath, marketplacePath, path.join(pluginDir, ".mcp.json")]) }
+				: {}),
+		};
+	}
+
+	// Codex: verified installable on Codex CLI 0.139.0 via the local marketplace smoke.
+	const manifestPath = path.join(pluginDir, ".codex-plugin", "plugin.json");
+	const marketplacePath = path.join(marketplaceRoot, ".agents", "plugins", "marketplace.json");
+	return {
+		ok: true,
+		host,
+		mode: "render",
+		gated: false,
+		pluginPath: marketplaceRoot,
+		manifestPath,
+		marketplacePath,
+		installGuidance: [
+			`Add the local marketplace: codex plugin marketplace add ${marketplaceRoot}`,
+			"Install the plugin: codex plugin add gajae-code@gajae-code-local",
+			"Then call gjc_delegate_plan / gjc_delegate_execute / gjc_delegate_team from Codex.",
+		],
+		coordinatorConfigPreview: { command: "gjc", args: ["mcp-serve", "coordinator"], env },
+		mutationPolicy:
+			"Fail-closed: delegation is read-only until you set GJC_COORDINATOR_MCP_MUTATIONS=sessions and pass allow_mutation:true per call.",
+		notes: [
+			"Verified on Codex CLI 0.139.0: marketplace add + plugin add install the plugin (enabled) and `codex mcp list` registers gjc-coordinator with the fail-closed env.",
+			"The bundled .codex.mcp.json workdir root is host-neutral; `gjc setup codex` renders a concrete root, and operators should re-run the local marketplace smoke on their target Codex version.",
+		],
+		...(flags.check
+			? {
+					check: verifyBundleFiles([
+						manifestPath,
+						marketplacePath,
+						path.join(pluginDir, ".codex.mcp.json"),
+						path.join(pluginDir, "skills", "gjc-delegation", "SKILL.md"),
+					]),
+				}
+			: {}),
+	};
+}
+
+export function formatHostPluginSetup(result: HostPluginSetupResult): string {
+	const lines: string[] = [];
+	lines.push(`host: ${result.host}${result.gated ? " (gated on versioned smoke)" : ""}`);
+	lines.push(`plugin: ${result.pluginPath}`);
+	lines.push("install:");
+	for (const step of result.installGuidance) lines.push(`  - ${step}`);
+	lines.push(`mcp: ${result.coordinatorConfigPreview.command} ${result.coordinatorConfigPreview.args.join(" ")}`);
+	lines.push(
+		`  GJC_COORDINATOR_MCP_WORKDIR_ROOTS=${result.coordinatorConfigPreview.env.GJC_COORDINATOR_MCP_WORKDIR_ROOTS}`,
+	);
+	lines.push(result.mutationPolicy);
+	for (const note of result.notes) lines.push(`note: ${note}`);
+	return lines.join("\n");
+}

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

@@ -797,7 +797,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]);
 			},
 		};
 

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

package/src/tools/subagent.ts

@@ -17,6 +17,8 @@ const MAX_LIST_LIMIT = 50;
 const RECEIPT_PREVIEW_WIDTH = 280;
 const PREVIEW_WIDTH = 2_000;
 const FULL_PREVIEW_WIDTH = 12_000;
+const STEER_QUEUED_GUIDANCE =
+	"The steer message is queued for the subagent's next steering boundary and has not necessarily taken effect yet.";
 
 const subagentSchema = z.object({
 	action: z
@@ -63,6 +65,9 @@ export interface SubagentSnapshot {
 	outputRef?: string;
 	truncated?: boolean;
 	guidance?: string;
+	steerMessage?: string;
+	steerState?: "queued" | "resume_queued" | "resume_started";
+	steerPauseRequested?: boolean;
 	/** Live streaming progress for the awaited subagent (await panel only; UI detail). */
 	progress?: AgentProgress;
 	/** True when a live in-session progress producer exists for this subagent. */
@@ -240,6 +245,7 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 			}
 			const records: SubagentRecord[] = [];
 			const missing: SubagentSnapshot[] = [];
+			const steerStates = new Map<string, NonNullable<SubagentSnapshot["steerState"]>>();
 			const record = this.#findVisibleRecord(manager, id, ownerFilter);
 			const verifiedOutputIds = await this.#verifiedOutputIds(record ? [record] : []);
 			if (!record) {
@@ -249,23 +255,41 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 				if (record.status === "running") {
 					const handle = manager.getLiveHandle(record.subagentId);
 					if (!handle) throw new ToolError(`Subagent ${record.subagentId} has no live handle.`);
-					await handle.injectMessage(message, "steer");
+					const fromAgentId = this.session.getAgentId?.() ?? undefined;
+					await handle.injectMessage(message, "steer", { fromAgentId });
 					if (params.pause === true) manager.pauseSubagent(record.subagentId, ownerFilter);
+					records.push(manager.getSubagentRecord(record.subagentId, ownerFilter) ?? record);
+					steerStates.set(record.subagentId, "queued");
 				} else {
 					const result = manager.resumeSubagent(record.subagentId, ownerFilter, message);
-					if (!result.ok && result.reason === "context_unavailable") throw new ToolError("context unavailable");
 					if (!result.ok && result.reason === "not_found") {
 						missing.push(this.#missingSnapshot(id, "not_found", "No visible detached subagent matches this id."));
+					} else if (!result.ok) {
+						throw new ToolError(`Failed to resume subagent ${record.subagentId}: ${result.reason ?? "unknown"}.`);
 					} else {
-						records.push(manager.getSubagentRecord(record.subagentId, ownerFilter) ?? record);
+						const snapshotRecord = manager.getSubagentRecord(record.subagentId, ownerFilter) ?? record;
+						records.push(snapshotRecord);
+						steerStates.set(
+							snapshotRecord.subagentId,
+							result.queued === true || result.status === "queued" ? "resume_queued" : "resume_started",
+						);
 					}
 				}
-				if (record.status === "running")
-					records.push(manager.getSubagentRecord(record.subagentId, ownerFilter) ?? record);
 			}
 			return this.#buildSnapshotResult(
 				[
-					...records.map(record => this.#recordSnapshot(manager, record, false, verbosity, verifiedOutputIds)),
+					...records.map(record => {
+						const snapshot = this.#recordSnapshot(manager, record, false, verbosity, verifiedOutputIds);
+						return {
+							...snapshot,
+							steerMessage: message,
+							steerState: steerStates.get(record.subagentId) ?? "queued",
+							steerPauseRequested: params.pause === true,
+							guidance: snapshot.guidance
+								? `${snapshot.guidance} ${STEER_QUEUED_GUIDANCE}`
+								: STEER_QUEUED_GUIDANCE,
+						};
+					}),
 					...missing,
 				],
 				"Subagent steer",
@@ -288,7 +312,7 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 		if (ids.length === 1) return ids[0]!;
 		if (ids.length > 1) {
 			throw new ToolError(
-				`\`${action}\` accepts exactly one target because \`message\` is delivered to one subagent.`,
+				`\`${action}\` accepts exactly one target because \`message\` can be queued for only one subagent.`,
 			);
 		}
 		throw new ToolError(`\`${action}\` requires a single subagent id via \`id\`.`);
@@ -533,6 +557,10 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 			if (snapshot.description) lines.push(`Description: ${snapshot.description}`);
 			if (snapshot.outputRef) lines.push(`Output: ${snapshot.outputRef}`);
 			if (snapshot.assignment) lines.push("Assignment:", "```", snapshot.assignment, "```");
+			if (snapshot.steerMessage) {
+				lines.push(`Steer (${snapshot.steerState ?? "queued"}):`, "```", snapshot.steerMessage, "```");
+				lines.push(STEER_QUEUED_GUIDANCE);
+			}
 			if (snapshot.resultPreview) {
 				lines.push(snapshot.errorText ? "Error preview:" : "Result preview:", "```", snapshot.resultPreview, "```");
 				if (snapshot.truncated)
@@ -770,6 +798,9 @@ function canonicalizeSnapshotForSignature(snapshot: SubagentSnapshot): unknown {
 		outputRef: snapshot.outputRef ?? null,
 		truncated: snapshot.truncated ?? false,
 		guidance: snapshot.guidance ?? null,
+		steerMessage: snapshot.steerMessage ?? null,
+		steerState: snapshot.steerState ?? null,
+		steerPauseRequested: snapshot.steerPauseRequested ?? false,
 		liveProgressAvailable: snapshot.liveProgressAvailable ?? null,
 		effectiveModel: snapshot.effectiveModel ?? null,
 		requestedModel: snapshot.requestedModel ?? null,