@gajae-code/coding-agent 0.18.5 → 0.18.7

package/src/config/model-profiles.ts

@@ -73,32 +73,25 @@ const profile = (
 
 export const BUILTIN_MODEL_PROFILES: readonly ModelProfileDefinition[] = [
 	profile("codex-eco", ["openai-codex"], {
-		default: "openai-codex/gpt-5.6-terra:low",
+		default: "openai-codex/gpt-6-luna:low",
 		executor: "openai-codex/gpt-6-luna:low",
 		planner: "openai-codex/gpt-6-luna:high",
-		critic: "openai-codex/gpt-5.6-terra:xhigh",
-		architect: "openai-codex/gpt-5.6-terra:high",
+		critic: "openai-codex/gpt-6-luna:xhigh",
+		architect: "openai-codex/gpt-6-luna:high",
 	}),
 	profile("codex-medium", ["openai-codex"], {
-		default: "openai-codex/gpt-6-sol:low",
-		executor: "openai-codex/gpt-5.6-terra:low",
-		planner: "openai-codex/gpt-5.6-terra:high",
-		critic: "openai-codex/gpt-6-sol:xhigh",
-		architect: "openai-codex/gpt-6-sol:high",
+		default: "openai-codex/gpt-6.1-sol:low",
+		executor: "openai-codex/gpt-6.1-sol:low",
+		planner: "openai-codex/gpt-6.1-sol:high",
+		critic: "openai-codex/gpt-6.1-sol:xhigh",
+		architect: "openai-codex/gpt-6.1-sol:high",
 	}),
 	profile("codex-pro", ["openai-codex"], {
-		default: "openai-codex/gpt-6-sol:medium",
-		executor: "openai-codex/gpt-5.6-terra:medium",
-		planner: "openai-codex/gpt-6-sol:high",
-		critic: "openai-codex/gpt-6-sol:max",
-		architect: "openai-codex/gpt-6-sol:xhigh",
-	}),
-	profile("codex-sol61", ["openai-codex"], {
 		default: "openai-codex/gpt-6.1-sol:medium",
 		executor: "openai-codex/gpt-6.1-sol:medium",
 		planner: "openai-codex/gpt-6.1-sol:high",
-		critic: "openai-codex/gpt-6.1-sol:xhigh",
-		architect: "openai-codex/gpt-6-astra:xhigh",
+		critic: "openai-codex/gpt-6.1-sol:max",
+		architect: "openai-codex/gpt-6.1-sol:xhigh",
 	}),
 	profile("lunamaxxing", ["openai-codex"], {
 		default: "openai-codex/gpt-6-luna:medium",
@@ -111,20 +104,20 @@ export const BUILTIN_MODEL_PROFILES: readonly ModelProfileDefinition[] = [
 		default: "openai-codex/gpt-6-astra:medium",
 		executor: "openai-codex/gpt-6-luna:xhigh",
 		planner: "openai-codex/gpt-6-astra:xhigh",
-		critic: "openai-codex/gpt-6-sol:high",
-		architect: "openai-codex/gpt-5.6-terra:xhigh",
+		critic: "openai-codex/gpt-6.1-sol:high",
+		architect: "openai-codex/gpt-6.1-sol:xhigh",
 	}),
 	profile("astra-default", ["openai-codex"], {
 		default: "openai-codex/gpt-6-astra:medium",
 		executor: "openai-codex/gpt-6-luna:max",
 		planner: "openai-codex/gpt-6-astra:xhigh",
-		critic: "openai-codex/gpt-6-sol:xhigh",
-		architect: "openai-codex/gpt-5.6-terra:xhigh",
+		critic: "openai-codex/gpt-6.1-sol:xhigh",
+		architect: "openai-codex/gpt-6.1-sol:xhigh",
 	}),
 	profile("astra-heavy", ["openai-codex"], {
 		default: "openai-codex/gpt-6-astra:medium",
-		executor: "openai-codex/gpt-6-sol:max",
-		planner: "openai-codex/gpt-6-sol:max",
+		executor: "openai-codex/gpt-6.1-sol:max",
+		planner: "openai-codex/gpt-6.1-sol:max",
 		critic: "openai-codex/gpt-6-astra:max",
 		architect: "openai-codex/gpt-6-astra:max",
 	}),
@@ -497,24 +490,24 @@ export const BUILTIN_MODEL_PROFILES: readonly ModelProfileDefinition[] = [
 	}),
 	profile("opus-codex", ["anthropic", "openai-codex"], {
 		default: "anthropic/claude-opus-5-5:medium",
-		executor: "openai-codex/gpt-5.6-terra:low",
+		executor: "openai-codex/gpt-6.1-sol:low",
 		planner: "anthropic/claude-sonnet-5-5",
-		critic: "openai-codex/gpt-6-sol:xhigh",
-		architect: "openai-codex/gpt-6-sol:high",
+		critic: "openai-codex/gpt-6.1-sol:xhigh",
+		architect: "openai-codex/gpt-6.1-sol:high",
 	}),
 	profile("codex-opencodego", ["openai-codex", "opencode-go"], {
-		default: "openai-codex/gpt-6-sol:low",
+		default: "openai-codex/gpt-6.1-sol:low",
 		executor: "opencode-go/deepseek-v4-pro",
 		planner: "opencode-go/kimi-k3",
 		critic: "opencode-go/mimo-v2.5-pro",
-		architect: "openai-codex/gpt-6-sol:high",
+		architect: "openai-codex/gpt-6.1-sol:high",
 	}),
 	profile("fable-opus-codex", ["anthropic", "openai-codex"], {
 		default: "anthropic/claude-fable-5-1:high",
-		executor: "openai-codex/gpt-5.6-terra:medium",
+		executor: "openai-codex/gpt-6.1-sol:medium",
 		planner: "anthropic/claude-opus-5-5:medium",
 		critic: "anthropic/claude-opus-5-5:high",
-		architect: "openai-codex/gpt-6-sol:xhigh",
+		architect: "openai-codex/gpt-6.1-sol:xhigh",
 	}),
 	profile("astra-fable", ["openai-codex", "anthropic"], {
 		default: "openai-codex/gpt-6-astra:medium",
@@ -562,7 +555,6 @@ const PROFILE_PRESENTATION: Record<string, ModelProfilePresentation> = {
 	"codex-eco": { displayName: "Codex Eco", providerGroup: "CODEX" },
 	"codex-medium": { displayName: "Codex Medium", providerGroup: "CODEX" },
 	"codex-pro": { displayName: "Codex Pro", providerGroup: "CODEX" },
-	"codex-sol61": { displayName: "Codex Sol 6.1", providerGroup: "CODEX" },
 	lunamaxxing: { displayName: "LunaMaxxing", providerGroup: "CODEX" },
 	"astra-lite": { displayName: "ASTRA-Lite", providerGroup: "CODEX" },
 	"astra-default": { displayName: "ASTRA-Default", providerGroup: "CODEX" },

package/src/config/model-resolver.ts

@@ -1189,7 +1189,15 @@ async function resolveModelChainEntries(
 				skips.push({ selector, reason: "credential_unavailable" });
 				break;
 			}
-			const key = await modelRegistry.getApiKey(candidate.model, credentialSessionId, { signal: options?.signal });
+			let key: string | undefined;
+			try {
+				key = await modelRegistry.getApiKey(candidate.model, credentialSessionId, { signal: options?.signal });
+			} catch (error) {
+				// OAuth selection can invalidate a pin after the preflight check.
+				if (!options?.isCredentialUnavailable?.(candidate.model.provider)) throw error;
+				skips.push({ selector, reason: "credential_unavailable" });
+				break;
+			}
 			if (isAuthenticatedOrKeyless(key)) {
 				return { ...candidate, activeIndex, skips };
 			}

package/src/config/settings.ts

@@ -1104,6 +1104,41 @@ export class Settings implements NotificationSettingsReader {
 		if (saveError !== undefined) throw saveError;
 	}
 
+	/** Copy execution settings without reloading, persisting, or sharing mutable layers. */
+	snapshot(): Settings {
+		const cloned = new Settings({ cwd: this.#cwd, agentDir: this.#agentDir, inMemory: true });
+		cloned.#global = structuredClone(this.#global);
+		cloned.#project = structuredClone(this.#project);
+		cloned.#overrides = structuredClone(this.#overrides);
+		cloned.#merged = structuredClone(this.#merged);
+		cloned.#schemaReport = structuredClone(this.#schemaReport);
+		cloned.#autoroutingEffective = structuredClone(this.#autoroutingEffective);
+		cloned.#autoroutingLocalIssues = structuredClone(this.#autoroutingLocalIssues);
+		cloned.#schemaMigrationPending = this.#schemaMigrationPending;
+		cloned.#futureSchemaVersion = this.#futureSchemaVersion;
+		cloned.#hasMalformedConfigRoot = this.#hasMalformedConfigRoot;
+		cloned.#hasRecoveredConfigSyntax = this.#hasRecoveredConfigSyntax;
+		cloned.#hasInvalidNotificationGlobal = this.#hasInvalidNotificationGlobal;
+		cloned.#notificationValidationGeneration = this.#notificationValidationGeneration;
+		cloned.#rawNotificationConfig = structuredClone(this.#rawNotificationConfig);
+		cloned.#durableRawNotificationConfig = structuredClone(this.#durableRawNotificationConfig);
+		cloned.#durableNotificationFingerprint = this.#durableNotificationFingerprint;
+		return cloned;
+	}
+
+	/** Resolve a retained execution's project layer without persistence or global hooks. */
+	async snapshotForCwd(cwd: string): Promise<Settings> {
+		const cloned = this.snapshot();
+		if (path.resolve(cwd) === path.resolve(this.#cwd)) return cloned;
+		cloned.#cwd = path.resolve(cwd);
+		cloned.#readonly = true;
+		cloned.#project = {};
+		cloned.#rebuildMerged();
+		cloned.#project = await cloned.#loadProjectSettings(true);
+		await cloned.#normalizeAfterLoad(false);
+		return cloned;
+	}
+
 	async cloneForCwd(cwd: string): Promise<Settings> {
 		// A clone shares the same config queue. Settle an already-reserved local
 		// debounce before the clone can enqueue a durable selector, preventing it
@@ -1572,9 +1607,14 @@ export class Settings implements NotificationSettingsReader {
 		return reconciled.settings;
 	}
 
-	async #loadProjectSettings(): Promise<RawSettings> {
+	async #loadProjectSettings(bypassCache = false): Promise<RawSettings> {
 		try {
-			const result = await loadCapability(settingsCapability.id, { cwd: this.#cwd, settings: this });
+			const result = await loadCapability(settingsCapability.id, {
+				cwd: this.#cwd,
+				agentDir: this.#agentDir,
+				settings: this,
+				bypassCache,
+			});
 			let merged: RawSettings = {};
 			for (const item of result.items as SettingsCapabilityItem[]) {
 				if (item.level !== "project") continue;
@@ -1637,7 +1677,7 @@ export class Settings implements NotificationSettingsReader {
 		return settings;
 	}
 
-	async #normalizeAfterLoad(): Promise<void> {
+	async #normalizeAfterLoad(publishHooks = true): Promise<void> {
 		this.#sanitizeModelSelectorRecords();
 		this.#rebuildMerged();
 		if (!this.#futureSchemaVersion) {
@@ -1653,7 +1693,7 @@ export class Settings implements NotificationSettingsReader {
 		await this.flush();
 		this.#sanitizeModelSelectorRecords();
 		this.#rebuildMerged();
-		this.#fireAllHooks();
+		if (publishHooks) this.#fireAllHooks();
 	}
 
 	#sanitizeModelSelectorRecords(): void {

package/src/coordinator-mcp/event-webhook.ts

@@ -116,6 +116,17 @@ function webhookEnvValue(explicitEnv: NodeJS.ProcessEnv | undefined, name: strin
 	return $credentialEnv(name)?.trim() || undefined;
 }
 
+// Number.parseInt reads a leading digit prefix ("1.5" -> 1, "1e4" -> 1,
+// "10s" -> 10), which would silently turn a timeout into one millisecond or a
+// retry budget into a single attempt. Only plain decimal digits count; anything
+// else falls back to the default, matching the coordinator policy env values.
+function boundedWebhookEnvInt(raw: string | undefined, fallback: number, max: number): number {
+	if (raw === undefined || !/^\d+$/.test(raw)) return fallback;
+	const parsed = Number.parseInt(raw, 10);
+	// An oversized digit string still means "as large as allowed", so it caps.
+	return parsed > 0 ? Math.min(parsed, max) : fallback;
+}
+
 export function parseEventWebhookConfig(explicitEnv?: NodeJS.ProcessEnv): EventWebhookConfig | null {
 	const rawUrl = webhookEnvValue(explicitEnv, "GJC_COORDINATOR_MCP_EVENT_WEBHOOK_URL");
 	if (!rawUrl) return null;
@@ -139,22 +150,16 @@ export function parseEventWebhookConfig(explicitEnv?: NodeJS.ProcessEnv): EventW
 		: null;
 	const tokenFile = webhookEnvValue(explicitEnv, "GJC_COORDINATOR_MCP_EVENT_WEBHOOK_TOKEN_FILE") ?? "";
 	if (tokenFile !== "" && !path.isAbsolute(tokenFile)) throw new Error("coordinator_event_webhook_token_file_invalid");
-	const timeoutRaw = Number.parseInt(
-		webhookEnvValue(explicitEnv, "GJC_COORDINATOR_MCP_EVENT_WEBHOOK_TIMEOUT_MS") ?? "",
-		10,
+	const timeoutMs = boundedWebhookEnvInt(
+		webhookEnvValue(explicitEnv, "GJC_COORDINATOR_MCP_EVENT_WEBHOOK_TIMEOUT_MS"),
+		DEFAULT_EVENT_WEBHOOK_TIMEOUT_MS,
+		MAX_EVENT_WEBHOOK_TIMEOUT_MS,
 	);
-	const timeoutMs =
-		Number.isFinite(timeoutRaw) && timeoutRaw > 0
-			? Math.min(timeoutRaw, MAX_EVENT_WEBHOOK_TIMEOUT_MS)
-			: DEFAULT_EVENT_WEBHOOK_TIMEOUT_MS;
-	const attemptsRaw = Number.parseInt(
-		webhookEnvValue(explicitEnv, "GJC_COORDINATOR_MCP_EVENT_WEBHOOK_MAX_ATTEMPTS") ?? "",
-		10,
+	const maxAttempts = boundedWebhookEnvInt(
+		webhookEnvValue(explicitEnv, "GJC_COORDINATOR_MCP_EVENT_WEBHOOK_MAX_ATTEMPTS"),
+		DEFAULT_EVENT_WEBHOOK_MAX_ATTEMPTS,
+		MAX_EVENT_WEBHOOK_MAX_ATTEMPTS,
 	);
-	const maxAttempts =
-		Number.isFinite(attemptsRaw) && attemptsRaw > 0
-			? Math.min(attemptsRaw, MAX_EVENT_WEBHOOK_MAX_ATTEMPTS)
-			: DEFAULT_EVENT_WEBHOOK_MAX_ATTEMPTS;
 	return { url: rawUrl, tokenFile: tokenFile || null, sessionIds, timeoutMs, maxAttempts };
 }
 

package/src/coordinator-mcp/policy.ts

@@ -86,9 +86,19 @@ const LEGACY_MUTATION_CLASS_ALIASES = new Map<string, CoordinatorMutationClass>(
 	["report", "reports"],
 ]);
 
+// Number.parseInt reads a leading digit prefix ("64KB" -> 64, "1e6" -> 1,
+// "1.5" -> 1), which would silently shrink a cap or TTL to a tiny value. Only
+// plain decimal digits count; anything else falls back to the default.
+function parsePositiveInt(value: string | undefined): number | undefined {
+	const trimmed = (value ?? "").trim();
+	if (!/^\d+$/.test(trimmed)) return undefined;
+	const parsed = Number.parseInt(trimmed, 10);
+	return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+
 function parsePositiveIntMs(value: string | undefined, fallback: number, floor: number): number {
-	const parsed = Number.parseInt((value ?? "").trim(), 10);
-	if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+	const parsed = parsePositiveInt(value);
+	if (parsed === undefined) return fallback;
 	return Math.max(floor, parsed);
 }
 
@@ -133,8 +143,8 @@ function parseMutationClasses(value: string | undefined): Set<CoordinatorMutatio
 }
 
 function parseByteCap(value: string | undefined): number {
-	const parsed = Number.parseInt(value ?? "", 10);
-	if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_ARTIFACT_BYTE_CAP;
+	const parsed = parsePositiveInt(value);
+	if (parsed === undefined) return DEFAULT_ARTIFACT_BYTE_CAP;
 	return Math.min(parsed, MAX_ARTIFACT_BYTE_CAP);
 }
 

package/src/coordinator-mcp/server.ts

@@ -740,13 +740,18 @@ function toolSchema(
 		return {
 			name,
 			description:
-				"Create a durable turn and deliver a bounded follow-up prompt for a selected coordinator bridge session.",
+				"Create a durable turn, or set steer:true with the active turn_id to deliver requested input to that running turn. queue:true is only for a separate later task; it is not consumption acknowledgement.",
 			inputSchema: {
 				type: "object",
 				properties: {
 					session_id: sessionId,
 					prompt: { type: "string" },
 					queue: { type: "boolean" },
+					steer: { type: "boolean" },
+					turn_id: {
+						type: "string",
+						description: "Required with steer:true; the existing active coordinator turn.",
+					},
 					force: { type: "boolean" },
 					idempotency_key: idempotencyKey,
 					allow_mutation: allowMutation,
@@ -829,7 +834,12 @@ function toolSchema(
 					summary: { type: "string" },
 					blocker: { type: "string" },
 					pr_url: { type: "string" },
-					evidence_paths: { type: "array", items: { type: "string" } },
+					evidence_paths: {
+						type: "array",
+						items: { type: "string" },
+						description:
+							"Evidence must be inside configured artifact roots. Agent session logs are not automatically allowed.",
+					},
 					idempotency_key: idempotencyKey,
 					allow_mutation: allowMutation,
 				},
@@ -1250,8 +1260,10 @@ const COORDINATOR_IDEMPOTENCY_RESPONSE_BYTE_CAP = 64 * 1024;
 const COORDINATOR_IDEMPOTENCY_STRING_BYTE_CAP = 8 * 1024;
 const PUBLIC_ERROR_MESSAGES: Record<string, string> = {
 	invalid_input: "Coordinator request input is invalid.",
+	turn_not_active: "Feedback requires the selected active turn; no new coordinator turn was created.",
 	invalid_request: "Coordinator request is invalid.",
 	invalid_session_id: "Coordinator session id is invalid.",
+	invalid_turn_id: "Coordinator turn id is invalid.",
 	unknown_operation: "Coordinator operation is unsupported.",
 	not_found: "Coordinator resource was not found.",
 	resource_gone: "Coordinator resource is no longer available.",
@@ -2608,8 +2620,20 @@ export async function appendCoordinatorEventForTest(
 	return appendCoordinatorEvent(namespaceDir, input);
 }
 
+// Tool arguments and env values arrive untyped. `Number.parseInt(String(v))`
+// reads a leading digit prefix ("1e4" -> 1, "5s" -> 5) and flattens arrays
+// ([50] -> "50"), so a malformed value silently became a 1 ms timeout or a
+// one-row limit. Numbers pass through; strings must be plain decimal digits;
+// anything else is NaN so each caller falls back to its default.
+function integerArg(value: unknown): number {
+	if (typeof value === "number") return value;
+	if (typeof value !== "string") return Number.NaN;
+	const trimmed = value.trim();
+	return /^\d+$/.test(trimmed) ? Number.parseInt(trimmed, 10) : Number.NaN;
+}
+
 function boundedEventLimit(value: unknown): number {
-	const parsed = typeof value === "number" ? value : Number.parseInt(String(value ?? ""), 10);
+	const parsed = integerArg(value);
 	if (!Number.isFinite(parsed) || parsed <= 0) return 100;
 	return Math.min(parsed, 100);
 }
@@ -3178,7 +3202,7 @@ export const COORDINATOR_EVENT_WATCH_TIMEOUT_MAX_MS = 30_000;
 export const COORDINATOR_POLL_INTERVAL_MAX_MS = 10_000;
 
 function parsePositiveIntegerMs(value: unknown, fallback: number): number {
-	const parsed = typeof value === "number" ? value : Number.parseInt(String(value ?? ""), 10);
+	const parsed = integerArg(value);
 	return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
 
@@ -3194,7 +3218,7 @@ export function boundedRuntimePromptAckTimeoutMs(value: unknown): number {
 }
 
 export function boundedEventWatchTimeoutMs(value: unknown): number {
-	const parsed = typeof value === "number" ? value : Number.parseInt(String(value ?? ""), 10);
+	const parsed = integerArg(value);
 	if (parsed === 0) return 0;
 	return Math.min(Number.isFinite(parsed) && parsed > 0 ? parsed : 1000, COORDINATOR_EVENT_WATCH_TIMEOUT_MAX_MS);
 }
@@ -3204,7 +3228,7 @@ export function boundedPollIntervalMs(value: unknown): number {
 }
 
 function boundedLineCount(value: unknown): number {
-	const parsed = typeof value === "number" ? value : Number.parseInt(String(value ?? ""), 10);
+	const parsed = integerArg(value);
 	if (!Number.isFinite(parsed) || parsed <= 0) return 80;
 	return Math.min(parsed, 400);
 }
@@ -5178,7 +5202,20 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 	}
 
 	async function queryLastAssistant(session: Record<string, unknown>): Promise<string | null> {
-		const item = sdkQueryPageItem(await querySession(session, "session.last_assistant"), "session.last_assistant");
+		let item: unknown;
+		try {
+			item = sdkQueryPageItem(await querySession(session, "session.last_assistant"), "session.last_assistant");
+		} catch (error) {
+			// Compatibility with running older hosts: this exact Q17 diagnostic
+			// denotes an absent text payload, not a missing session or closed store.
+			if (
+				error instanceof SdkClientError &&
+				error.code === "resource_gone" &&
+				error.message === "snapshot payload is unavailable"
+			)
+				return null;
+			throw error;
+		}
 		if (typeof item === "string") return item;
 		const message = asRecord(item);
 		return typeof message?.text === "string"
@@ -5227,6 +5264,19 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 	function publicError(error: unknown): Record<string, unknown> {
 		if (error instanceof Error && error.message.startsWith("coordinator_mutation_call_not_allowed:"))
 			return { ok: false, reason: error.message };
+		if (error instanceof Error) {
+			const reason = error.message.startsWith("coordinator_artifact_outside_allowed_roots:")
+				? "artifact_outside_allowed_roots"
+				: error.message === "coordinator_artifact_state_root_denied"
+					? "artifact_state_root_denied"
+					: undefined;
+			if (reason)
+				return {
+					ok: false,
+					reason,
+					error: { code: "invalid_input", message: PUBLIC_ERROR_MESSAGES.invalid_input },
+				};
+		}
 		const directCode = error instanceof SdkClientError ? error.code : sinkErrorCode(error);
 		const messageCode =
 			error instanceof Error && Object.hasOwn(PUBLIC_ERROR_MESSAGES, error.message) ? error.message : undefined;
@@ -10354,6 +10404,91 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 				const idempotencyKey = requiredIdempotencyKey(args);
 				const sessionId = safeExternalId("session", args.session_id);
 				const prompt = args.prompt;
+				if (args.steer === true) {
+					if (args.queue === true || args.force === true)
+						return {
+							ok: false,
+							error: { code: "invalid_input", message: "steer cannot be combined with queue or force." },
+						};
+					const turnId = safeTurnId(args.turn_id);
+					return await withToolIdempotency(
+						name,
+						idempotencyKey,
+						{ session_id: sessionId, turn_id: turnId, prompt, steer: true, allow_mutation: true },
+						async () =>
+							await withSessionTransition(sessionId, async () => {
+								const transaction = await readSessionTransaction(questionPaths, sessionId);
+								const turn = transaction?.canonical.turns[turnId];
+								if (
+									!transaction ||
+									!turn ||
+									transaction.canonical.queue.active_turn_id !== turnId ||
+									(turn.status !== "active" && turn.status !== "waiting_for_answer")
+								)
+									return {
+										ok: false,
+										error: {
+											code: "turn_not_active",
+											message: "Feedback requires the selected active turn; no new turn was created.",
+										},
+									};
+								const runtimeCommandId = turn.delivery.runtime_command_id;
+								const runtimeTurnId = turn.delivery.runtime_turn_id;
+								if (
+									typeof runtimeCommandId !== "string" ||
+									runtimeCommandId.length === 0 ||
+									typeof runtimeTurnId !== "string" ||
+									runtimeTurnId.length === 0
+								)
+									return {
+										ok: false,
+										error: {
+											code: "turn_not_active",
+											message:
+												"Feedback requires the selected active turn's runtime identity; no new turn was created.",
+										},
+									};
+								const session = asRecord(await readJsonFile(sessionFile(sessionId)));
+								if (!session) throw new Error("resource_gone");
+								await assertPersistedSessionAuthority(transaction.canonical.session);
+								const clientRef = `coordinator-feedback:${createHash("sha256")
+									.update(JSON.stringify([sessionId, turnId, idempotencyKey]))
+									.digest("hex")}`;
+								const expectedSdkRunToken = `${runtimeCommandId}:${runtimeTurnId}`;
+								const response = asRecord(
+									await controlSession(
+										session,
+										"turn.steer",
+										{ text: prompt, clientRef, expectedSdkRunToken },
+										idempotencyKey,
+									),
+								);
+								const result = asRecord(response?.result);
+								return {
+									ok: result?.accepted === true,
+									session_id: sessionId,
+									turn_id: turnId,
+									delivery: "steer",
+									queued: false,
+									consumption_verified: false,
+									steer_client_ref: clientRef,
+									result,
+								};
+							}),
+						true,
+						response => {
+							const result = asRecord(response.result);
+							const resultError = asRecord(result?.error);
+							return (
+								["ambiguous", "uncertain_after_send", "connection_closed", "timeout"].includes(
+									String(asRecord(response.error)?.code),
+								) ||
+								result?.status === "uncertain" ||
+								resultError?.code === "delivery_uncertain"
+							);
+						},
+					);
+				}
 				return await withToolIdempotency(
 					name,
 					idempotencyKey,

package/src/coordinator-mcp/session-reaper.ts

@@ -22,6 +22,11 @@ export const DEFAULT_SESSION_IDLE_TTL_MS = 30 * 60_000; // 30 min idle → reap
 export const DEFAULT_SESSION_SWEEP_INTERVAL_MS = 5 * 60_000; // sweep every 5 min
 export const MIN_SESSION_IDLE_TTL_MS = 60_000; // never reap a <1min-idle session
 export const MIN_SESSION_SWEEP_INTERVAL_MS = 30_000;
+/**
+ * Longest delay setTimeout honors. Bun, like Node, treats any larger delay as 1 ms,
+ * so an operator's very long sweep interval would otherwise re-sweep back to back.
+ */
+export const MAX_SESSION_SWEEP_INTERVAL_MS = 2 ** 31 - 1;
 /** After this many consecutive reap failures the session is force-evicted from the index. */
 export const MAX_REAP_FAILURES = 3;
 
@@ -92,7 +97,10 @@ export interface SessionReaper {
 
 export function createSessionReaper(deps: SessionReaperDeps, policy: SessionReaperPolicy): SessionReaper {
 	const idleTtlMs = Math.max(MIN_SESSION_IDLE_TTL_MS, policy.idleTtlMs);
-	const sweepIntervalMs = Math.max(MIN_SESSION_SWEEP_INTERVAL_MS, policy.sweepIntervalMs);
+	const sweepIntervalMs = Math.min(
+		MAX_SESSION_SWEEP_INTERVAL_MS,
+		Math.max(MIN_SESSION_SWEEP_INTERVAL_MS, policy.sweepIntervalMs),
+	);
 	let timer: ReturnType<typeof setTimeout> | null = null;
 	let generation = 0;
 	let inProgress = false;

package/src/defaults/gjc/skills/deep-interview/SKILL.md

@@ -265,7 +265,7 @@ Is that topology and locked intent right? Should any component or intent be adde
 
 Options should include contextually relevant choices such as **Looks right**, **Add/remove/merge components**, **Defer one or more components**, plus free-text, translated/localized according to `language.instruction` when present. This is the only pre-scoring question and preserves the one-question-per-round rule.
 
-The Round 0 `ask` call MUST include `deepInterview.round = 0`, `deepInterview.component = "review-topology"`, `deepInterview.dimension = "topology"`, `deepInterview.ambiguity` (the observed 0..1 ambiguity at ask time; `1` before Round 1 scoring), `deepInterview.intent_contract.items` containing the exact displayed locked-intent items, and `deepInterview.intent_contract.confirmation_options` listing only the displayed affirmative labels that lock the proposal (normally **Looks right**). The runtime recorder canonicalizes and locks this contract only when the user selects one of those labels; correction, deferral, free-text, and clarification answers never lock the pre-question proposal. Do not manually copy raw free text into intent evidence, and do not continue if this required recorder write fails. An incomplete Round 0 object (for example missing `deepInterview.ambiguity` or the whole `deepInterview.intent_contract`) is rejected before coercion with a correction naming the omitted fields; retry once with every required field populated from the visible payload context, never by re-sending the incomplete object or inventing contract items — the recorder never locks intent without an affirmative user answer.
+While state is in the `interviewing` phase, every `ask` MUST contain exactly one non-empty question with structured `deepInterview` metadata on that question; never add an empty `metadata` or `ignore` question. The entire `deepInterview` object is required, not merely the prose round header or `workflowGate`. After native final-spec persistence transitions to `handoff`, Phase 5 next-workflow/approval asks are ordinary asks without interview round metadata. The Round 0 `ask` call MUST include `deepInterview.round = 0`, `deepInterview.component = "review-topology"`, `deepInterview.dimension = "topology"`, `deepInterview.ambiguity` (the observed 0..1 ambiguity at ask time; `1` before Round 1 scoring), `deepInterview.intent_contract.items` containing the exact displayed locked-intent items, and `deepInterview.intent_contract.confirmation_options` listing only the displayed affirmative labels that lock the proposal (normally **Looks right**). The runtime recorder canonicalizes and locks this contract only when the user selects one of those labels; correction, deferral, free-text, and clarification answers never lock the pre-question proposal. Do not manually copy raw free text into intent evidence, and do not continue if this required recorder write fails. An incomplete Round 0 object (for example missing `deepInterview.ambiguity` or the whole `deepInterview.intent_contract`) is rejected before coercion with a correction naming the omitted fields; retry once with every required field populated from the visible payload context, never by re-sending the incomplete object or inventing contract items — the recorder never locks intent without an affirmative user answer.
 
 3. **Lock topology into state** after the answer. Store a normalized component list and confirmation timestamp:
 

package/src/discovery/helpers.ts

@@ -203,10 +203,13 @@ export function getProjectPath(ctx: LoadContext, source: SourceId, subpath: stri
 
 /** Build the filesystem authority for a provider read. */
 export function getReadOptions(
-	ctx: Pick<LoadContext, "home" | "isolatedHome" | "userAgentDir" | "homeIdentity" | "userAgentIdentity">,
+	ctx: Pick<
+		LoadContext,
+		"home" | "isolatedHome" | "userAgentDir" | "homeIdentity" | "userAgentIdentity" | "bypassCache"
+	>,
 	scope: ReadScope,
 ): ReadFileOptions | undefined {
-	if (!ctx.isolatedHome) return undefined;
+	if (!ctx.isolatedHome) return ctx.bypassCache ? { bypassCache: true } : undefined;
 	return {
 		isolatedHome: true,
 		home: ctx.home,
@@ -219,7 +222,10 @@ export function getReadOptions(
 }
 
 export async function getReadOptionsForContainment(
-	ctx: Pick<LoadContext, "home" | "isolatedHome" | "userAgentDir" | "homeIdentity" | "userAgentIdentity">,
+	ctx: Pick<
+		LoadContext,
+		"home" | "isolatedHome" | "userAgentDir" | "homeIdentity" | "userAgentIdentity" | "bypassCache"
+	>,
 	scope: ReadScope,
 	containmentRoot?: string,
 ): Promise<ReadFileOptions | undefined> {

package/src/discovery/ssh.ts

@@ -34,9 +34,14 @@ interface SSHConfigFile {
 
 function parsePort(value: number | string | undefined): number | undefined {
 	if (value === undefined) return undefined;
-	if (typeof value === "number") return Number.isFinite(value) ? value : undefined;
-	const parsed = Number.parseInt(value, 10);
-	return Number.isNaN(parsed) ? undefined : parsed;
+	// The JSON is not validated against SSHConfigFile, so anything else (e.g. an
+	// array, which parseInt would coerce: parseInt([2222]) === 2222) is rejected.
+	if (typeof value !== "number" && typeof value !== "string") return undefined;
+	// `Number.parseInt` accepts trailing garbage (parseInt("22oops") === 22), so a
+	// string must be plain digits.
+	if (typeof value === "string" && !/^\d+$/.test(value)) return undefined;
+	const port = typeof value === "number" ? value : Number.parseInt(value, 10);
+	return Number.isInteger(port) && port >= 1 && port <= 65535 ? port : undefined;
 }
 
 function parseCompat(value: boolean | string | undefined): boolean | undefined {

package/src/edit/modes/replace.ts

@@ -1,8 +1,8 @@
 /**
  * Fuzzy matching utilities for the edit tool.
  *
- * Provides both character-level and line-level fuzzy matching with progressive
- * fallback strategies for finding text in files.
+ * Provides both character-level and line-level fuzzy matching with staged
+ * strategies for finding text in files.
  */
 import type { AgentToolResult } from "@gajae-code/agent-core";
 import { markDesignedError } from "@gajae-code/utils/error-classification";
@@ -430,7 +430,7 @@ export function findContextLine(
 	lines: string[],
 	context: string,
 	startFrom: number,
-	options?: { allowFuzzy?: boolean; skipFunctionFallback?: boolean },
+	options?: { allowFuzzy?: boolean; skipParenRetry?: boolean },
 ): ContextLineResult {
 	const allowFuzzy = options?.allowFuzzy ?? true;
 	const trimmedContext = context.trim();
@@ -570,14 +570,14 @@ export function findContextLine(
 		};
 	}
 
-	if (!options?.skipFunctionFallback && trimmedContext.endsWith("()")) {
+	if (!options?.skipParenRetry && trimmedContext.endsWith("()")) {
 		const withParen = trimmedContext.replace(/\(\)\s*$/u, "(");
 		const withoutParen = trimmedContext.replace(/\(\)\s*$/u, "");
-		const parenResult = findContextLine(lines, withParen, startFrom, { allowFuzzy, skipFunctionFallback: true });
+		const parenResult = findContextLine(lines, withParen, startFrom, { allowFuzzy, skipParenRetry: true });
 		if (parenResult.index !== undefined || (parenResult.matchCount ?? 0) > 0) {
 			return parenResult;
 		}
-		return findContextLine(lines, withoutParen, startFrom, { allowFuzzy, skipFunctionFallback: true });
+		return findContextLine(lines, withoutParen, startFrom, { allowFuzzy, skipParenRetry: true });
 	}
 
 	return { index: undefined, confidence: bestScore };