@sayknow-cli/coding-agent 0.3.0 → 0.3.2

package/src/cli.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 
 /**
- * CLI entry point — registers all commands explicitly and delegates to the
+ * CLI entry point — registers all commands explicitly and delegates to the
  * lightweight CLI runner from pi-utils.
  */
 import { Args, type CliConfig, Command, type CommandEntry, Flags, run } from "@sayknow-cli/utils/cli";
@@ -22,7 +22,7 @@ process.title = APP_NAME;
 const rootHelpFlags = ["--help", "-h", "help"];
 const versionFlags = ["--version", "-v"];
 
-const commands: CommandEntry[] = [
+export const commands: CommandEntry[] = [
 	{ name: "codex-native-hook", load: () => import("./commands/codex-native-hook").then(m => m.default) },
 	{ name: "state", load: () => import("./commands/state").then(m => m.default) },
 	{ name: "setup", load: () => import("./commands/setup").then(m => m.default) },
@@ -39,6 +39,7 @@ const commands: CommandEntry[] = [
 	{ name: "daemon", load: () => import("./commands/daemon").then(m => m.default) },
 	{ name: "web-search", aliases: ["q"], load: () => import("./commands/web-search").then(m => m.default) },
 	{ name: "mcp-serve", load: () => import("./commands/mcp-serve").then(m => m.default) },
+	{ name: "mcp", load: () => import("./commands/mcp").then(m => m.default) },
 	{
 		name: "contribute-pr",
 		aliases: ["contribution-prep"],
@@ -48,6 +49,7 @@ const commands: CommandEntry[] = [
 	{ name: "migrate", load: () => import("./commands/migrate").then(m => m.default) },
 	{ name: "rlm", load: () => import("./commands/rlm").then(m => m.default) },
 	{ name: "update", load: () => import("./commands/update").then(m => m.default) },
+	{ name: "plugin", load: () => import("./commands/plugin").then(m => m.default) },
 	{ name: "launch", load: () => import("./commands/launch").then(m => m.default) },
 ];
 
@@ -62,10 +64,7 @@ async function showHelp(config: CliConfig): Promise<void> {
 }
 
 async function installRuntimeGlobals(): Promise<void> {
-	const [{ installH2Fetch }, { procmgr }] = await Promise.all([
-		import("@sayknow-cli/ai"),
-		import("@sayknow-cli/utils"),
-	]);
+	const { installH2Fetch } = await import("@sayknow-cli/ai/utils/h2-fetch");
 	// Activate HTTP/2 for all `fetch()` calls (provider streams, OAuth, model
 	// discovery, web tools). Bun's HTTP/2 client is gated on a startup flag we
 	// can't toggle from JS, so we patch globalThis.fetch to pass
@@ -75,8 +74,25 @@ async function installRuntimeGlobals(): Promise<void> {
 
 	// Strip macOS malloc-stack-logging env vars before any subprocess is spawned.
 	// Otherwise every child bun process (subagents, plugin installs, ptree spawns,
-	// etc.) prints a `MallocStackLogging: can't turn off …` warning to stderr.
-	procmgr.scrubProcessEnv();
+	// etc.) prints a `MallocStackLogging: can't turn off …` warning to stderr.
+	delete process.env.MallocStackLogging;
+	delete process.env.MallocStackLoggingNoCompact;
+}
+
+function hasRootFastFlag(argv: string[], flags: readonly string[]): boolean {
+	for (const arg of argv) {
+		if (isSubcommand(arg)) return false;
+		if (flags.includes(arg)) return true;
+	}
+	return false;
+}
+
+function hasRootHelpFlag(argv: string[]): boolean {
+	return hasRootFastFlag(argv, rootHelpFlags);
+}
+
+function hasRootVersionFlag(argv: string[]): boolean {
+	return hasRootFastFlag(argv, versionFlags);
 }
 
 class RootHelpCommand extends Command {
@@ -165,7 +181,7 @@ function isSubcommand(first: string | undefined): boolean {
  *
  * Purpose: catch the silent worker-load regressions that hit compiled
  * binaries (issues #1011 and #1027). Neither `--version` nor
- * `stats --summary` actually spawns a Worker on a fresh install — the
+ * `stats --summary` actually spawns a Worker on a fresh install — the
  * sync path early-returns when no session files exist. This probe is the
  * minimal end-to-end test that proves `new Worker(...)` resolves and the
  * bundled worker module evaluates successfully. Wired into
@@ -196,7 +212,7 @@ export async function runCli(argv: string[]): Promise<void> {
 		await runSmokeTest();
 		return;
 	}
-	if (rootHelpFlags.includes(argv[0] ?? "")) {
+	if (hasRootHelpFlag(argv)) {
 		const { renderRootHelp } = await import("@sayknow-cli/utils/cli");
 		const { getExtraHelpText } = await import("./cli/fast-help");
 		renderRootHelp({ bin: APP_NAME, version: VERSION, commands: new Map([["launch", RootHelpCommand]]) });
@@ -206,7 +222,7 @@ export async function runCli(argv: string[]): Promise<void> {
 		}
 		return;
 	}
-	if (versionFlags.includes(argv[0] ?? "")) {
+	if (hasRootVersionFlag(argv)) {
 		process.stdout.write(`${APP_NAME}/${VERSION}\n`);
 		return;
 	}
@@ -223,4 +239,6 @@ export async function runCli(argv: string[]): Promise<void> {
 	return run({ bin: APP_NAME, version: VERSION, argv: runArgv, commands, help: showHelp });
 }
 
-await runCli(process.argv.slice(2));
+if (import.meta.main) {
+	await runCli(process.argv.slice(2));
+}

package/src/commands/mcp.ts

@@ -0,0 +1,117 @@
+/**
+ * Direct MCP server registration for standalone SKC.
+ */
+import { Args, Command, Flags } from "@sayknow-cli/utils/cli";
+import { type MCPAction, type MCPCommandArgs, runMCPCommand } from "../cli/mcp-cli";
+
+const ACTIONS: MCPAction[] = ["add", "list", "remove"];
+
+export default class MCP extends Command {
+	static description = "Register standalone MCP servers explicitly in SKC config";
+	static delegateHelp = true;
+
+	static examples = [
+		"skc mcp add context7 npx -y @upstash/context7-mcp",
+		"skc mcp add docs --type http --url https://example.test/mcp --header Authorization=Bearer_TOKEN",
+		"skc mcp list --json",
+		"skc mcp remove context7",
+	];
+
+	static args = {
+		action: Args.string({ description: "MCP action", required: false, options: ACTIONS }),
+		name: Args.string({ description: "Server name", required: false }),
+		commandArgs: Args.string({
+			description: "Command/URL and trailing args for add",
+			required: false,
+			multiple: true,
+		}),
+	};
+
+	static flags = {
+		project: Flags.boolean({ description: "Write/read project scope (./.skc/mcp.json) instead of user scope" }),
+		force: Flags.boolean({ description: "Overwrite an existing server during add", default: false }),
+		json: Flags.boolean({
+			char: "j",
+			description: "Emit machine-readable JSON with sensitive values redacted",
+			default: false,
+		}),
+		type: Flags.string({ description: "Server transport type", options: ["stdio", "http", "sse"] }),
+		command: Flags.string({ description: "Stdio server command for add" }),
+		url: Flags.string({ description: "HTTP/SSE server URL for add" }),
+		arg: Flags.string({ description: "Argument passed to a stdio server (repeatable)", multiple: true }),
+		env: Flags.string({
+			description: "Environment variable for stdio server as KEY=VALUE (repeatable)",
+			multiple: true,
+		}),
+		header: Flags.string({
+			description: "HTTP/SSE header as KEY=VALUE (repeatable; redacted in output)",
+			multiple: true,
+		}),
+		cwd: Flags.string({ description: "Working directory for stdio server" }),
+		timeout: Flags.integer({ description: "Connection timeout in milliseconds" }),
+	};
+
+	async run(): Promise<void> {
+		if (this.argv.includes("--help") || this.argv.includes("-h")) {
+			this.printHelp();
+			return;
+		}
+
+		const { args, flags } = await this.parse(MCP);
+		const action = (args.action ?? "list") as MCPAction;
+		const cmd: MCPCommandArgs = {
+			action,
+			name: args.name,
+			commandArgs: args.commandArgs,
+			flags: {
+				project: flags.project,
+				force: flags.force,
+				json: flags.json,
+				type: flags.type as MCPCommandArgs["flags"]["type"],
+				command: flags.command,
+				url: flags.url,
+				arg: flags.arg,
+				env: flags.env,
+				header: flags.header,
+				cwd: flags.cwd,
+				timeout: flags.timeout,
+			},
+		};
+		await runMCPCommand(cmd);
+	}
+
+	private printHelp(): void {
+		process.stdout.write(`Register standalone MCP servers explicitly in SKC config
+
+USAGE
+  $ skc mcp [add|list|remove] [NAME] [COMMAND_OR_URL] [ARGS...] [FLAGS]
+
+COMMANDS
+  add     Add an explicit user-provided MCP server definition
+  list    List registered servers with env/header/auth values redacted
+  remove  Remove a registered server and print the removed definition redacted
+
+FLAGS
+      --project          Use project scope (./.skc/mcp.json) instead of user scope
+      --force            Overwrite an existing server during add
+  -j, --json             Emit machine-readable JSON with sensitive values redacted
+      --type=<value>     stdio | http | sse (default: stdio, or http when --url is set)
+      --command=<value>  Stdio server command for add
+      --url=<value>      HTTP/SSE server URL for add
+      --arg=<value>      Stdio server argument (repeatable)
+      --env=<value>      Stdio env var as KEY=VALUE (repeatable; redacted in output)
+      --header=<value>   HTTP/SSE header as KEY=VALUE (repeatable; redacted in output)
+      --cwd=<value>      Working directory for stdio server
+      --timeout=<int>    Connection timeout in milliseconds
+
+EXAMPLES
+  $ skc mcp add context7 npx -y @upstash/context7-mcp
+  $ skc mcp add docs --type http --url https://example.test/mcp --header Authorization=Bearer_TOKEN
+  $ skc mcp list --json
+  $ skc mcp remove context7
+
+SECURITY
+  This command writes only the server definition supplied on this invocation. It does not import or inherit Claude Code, Codex, OpenCode, or other live MCP configs. Public output redacts env, header, auth, and OAuth credential values.
+`);
+	}
+}

package/src/commands/plugin.ts

@@ -49,6 +49,8 @@ export default class Plugin extends Command {
 			description: 'Install scope: "user" (default) or "project"',
 			options: ["user", "project"],
 		}),
+		user: Flags.boolean({ description: "Install SKC plugin bundle into the user root" }),
+		project: Flags.boolean({ description: "Install SKC plugin bundle into the project root" }),
 	};
 
 	async run(): Promise<void> {
@@ -69,6 +71,8 @@ export default class Plugin extends Command {
 				disable: flags.disable,
 				set: flags.set,
 				scope: flags.scope as "user" | "project" | undefined,
+				user: flags.user,
+				project: flags.project,
 			},
 		};
 

package/src/commands/session.ts

@@ -2,6 +2,7 @@ import { Args, Command, Flags } from "@sayknow-cli/utils/cli";
 import {
 	attachSkcTmuxSession,
 	createSkcTmuxSession,
+	forceCloseSkcTmuxSession,
 	listSkcTmuxSessions,
 	removeSkcTmuxSession,
 	statusSkcTmuxSession,
@@ -60,6 +61,12 @@ export default class Session extends Command {
 
 	static flags = {
 		json: Flags.boolean({ char: "j", description: "Emit machine-readable JSON", default: false }),
+		"session-id": Flags.string({
+			description: "Expected @skc-session-id tag for force-close (defense-in-depth match)",
+		}),
+		"state-file": Flags.string({
+			description: "Expected @skc-session-state-file tag for force-close (defense-in-depth match)",
+		}),
 	};
 
 	static examples = [
@@ -68,6 +75,7 @@ export default class Session extends Command {
 		"skc session status <session>",
 		"skc session attach <session>",
 		"skc session remove <session>",
+		"skc session force-close <session> --session-id <id>",
 	];
 
 	async run(): Promise<void> {
@@ -136,6 +144,16 @@ export default class Session extends Command {
 				return;
 			}
 
+			if (action === "force-close" || action === "force-remove") {
+				const closed = forceCloseSkcTmuxSession(sessionName, process.env, flags["session-id"], flags["state-file"]);
+				if (json) {
+					writeJson({ ok: true, session: sessionJson(closed) });
+					return;
+				}
+				writeText([`force-closed: ${closed.name}`]);
+				return;
+			}
+
 			if (action === "attach") {
 				attachSkcTmuxSession(sessionName);
 				return;

package/src/commands/team.ts

@@ -95,7 +95,7 @@ export default class Team extends Command {
 	};
 
 	static examples = [
-		"skc --tmux  # start/attach the required tmux-backed leader session first",
+		"skc --tmux  # start the required tmux-backed leader session first",
 		'skc team 3:executor "Implement the approved plan"',
 		"skc team status <team-name> --json",
 		"skc team monitor <team-name> --json",

package/src/config/keybindings.ts

@@ -117,8 +117,8 @@ export const KEYBINDINGS = {
 		description: "Open external editor",
 	},
 	"app.message.followUp": {
-		defaultKeys: "ctrl+enter",
-		description: "Send follow-up message",
+		defaultKeys: [],
+		description: "Send follow-up message (no default; Ctrl+Enter inserts a newline)",
 	},
 	"app.message.queue": {
 		defaultKeys: "alt+enter",

package/src/config/model-profile-activation.ts

@@ -7,8 +7,13 @@ import {
 	formatAvailableProfileNames,
 	resolveProfileBindings,
 } from "./model-profiles";
-import { isAuthenticated, type ModelRegistry, type SkcModelAssignmentTargetId } from "./model-registry";
-import { resolveModelRoleValue } from "./model-resolver";
+import {
+	isAuthenticated,
+	type ModelRegistry,
+	SKC_MODEL_ASSIGNMENT_TARGETS,
+	type SkcModelAssignmentTargetId,
+} from "./model-registry";
+import { formatModelSelectorValue, resolveModelRoleValue } from "./model-resolver";
 import type { Settings } from "./settings";
 
 const LEGACY_MODEL_PROFILE_ALIASES: ReadonlyMap<string, string> = new Map([["codex-standard", "codex-medium"]]);
@@ -60,6 +65,48 @@ export interface PreparedModelProfileActivation {
 	 */
 	previousSessionDefaultModel: string | undefined;
 }
+export interface MaterializeModelProfileAssignmentOptions {
+	session: Pick<
+		ModelProfileActivationSession,
+		"model" | "thinkingLevel" | "setActiveModelProfile" | "getActiveModelProfile"
+	>;
+	settings: Pick<Settings, "clearOverride" | "get" | "override" | "set">;
+	role: SkcModelAssignmentTargetId;
+	selector: string;
+}
+
+export function materializeActiveModelProfileAssignment(options: MaterializeModelProfileAssignmentOptions): boolean {
+	const activeProfile = options.session.getActiveModelProfile?.() ?? options.settings.get("modelProfile.default");
+	if (!activeProfile) return false;
+
+	const nextModelRoles = { ...options.settings.get("modelRoles") };
+	const nextAgentModelOverrides = { ...options.settings.get("task.agentModelOverrides") };
+	const target = SKC_MODEL_ASSIGNMENT_TARGETS[options.role];
+
+	if (options.role === "default") {
+		nextModelRoles.default = options.selector;
+	} else if (!nextModelRoles.default && options.session.model) {
+		nextModelRoles.default = formatModelSelectorValue(
+			`${options.session.model.provider}/${options.session.model.id}`,
+			options.session.thinkingLevel,
+		);
+	}
+
+	if (target.settingsPath === "modelRoles") {
+		nextModelRoles[options.role] = options.selector;
+	} else {
+		nextAgentModelOverrides[options.role] = options.selector;
+	}
+
+	options.settings.set("modelRoles", nextModelRoles);
+	options.settings.set("task.agentModelOverrides", nextAgentModelOverrides);
+	options.settings.set("modelProfile.default", undefined);
+	options.settings.clearOverride("modelProfile.default");
+	options.settings.override("modelRoles", nextModelRoles);
+	options.settings.override("task.agentModelOverrides", nextAgentModelOverrides);
+	options.session.setActiveModelProfile?.(undefined);
+	return true;
+}
 
 export function formatModelProfileCredentialError(profileName: string, providers: readonly string[]): string {
 	return `Model profile "${profileName}" requires credentials for: ${providers.join(", ")}. Run /login and configure the missing provider(s), then retry.`;
@@ -255,20 +302,19 @@ export async function applyPreparedModelProfileActivation(
 			modelChanged = true;
 		}
 		if (Object.keys(prepared.modelRoles).length > 0) {
-			prepared.settings.override("modelRoles", {
-				...prepared.settings.get("modelRoles"),
-				...prepared.modelRoles,
-			});
+			prepared.settings.override("modelRoles", { ...previousModelRoles, ...prepared.modelRoles });
 			modelRolesChanged = true;
 		}
 		if (Object.keys(prepared.agentModelOverrides).length > 0) {
 			prepared.settings.override("task.agentModelOverrides", {
-				...prepared.settings.get("task.agentModelOverrides"),
+				...previousAgentModelOverrides,
 				...prepared.agentModelOverrides,
 			});
 			overridesChanged = true;
 		}
 		if (options.persistDefault) {
+			prepared.settings.set("modelRoles", {});
+			prepared.settings.set("task.agentModelOverrides", {});
 			prepared.settings.set("modelProfile.default", prepared.profileName);
 			defaultChanged = true;
 			await prepared.settings.flush();
@@ -277,6 +323,8 @@ export async function applyPreparedModelProfileActivation(
 	} catch (error) {
 		if (defaultChanged) {
 			prepared.settings.set("modelProfile.default", previousPersistedDefault);
+			prepared.settings.set("modelRoles", previousModelRoles);
+			prepared.settings.set("task.agentModelOverrides", previousAgentModelOverrides);
 		}
 		if (modelRolesChanged) {
 			prepared.settings.override("modelRoles", previousModelRoles);

package/src/config/settings-schema.ts

@@ -255,10 +255,14 @@ export const SETTINGS_SCHEMA = {
 	"auth.broker.url": { type: "string", default: undefined },
 	"auth.broker.token": { type: "string", default: undefined },
 
-	// Notifications (Telegram bundled reference client)
+	// Notifications (shared daemon with Telegram/Discord/Slack presentation adapters)
 	"notifications.enabled": { type: "boolean", default: false },
 	"notifications.telegram.botToken": { type: "string", default: undefined },
 	"notifications.telegram.chatId": { type: "string", default: undefined },
+	"notifications.discord.botToken": { type: "string", default: undefined },
+	"notifications.discord.channelId": { type: "string", default: undefined },
+	"notifications.slack.botToken": { type: "string", default: undefined },
+	"notifications.slack.channelId": { type: "string", default: undefined },
 	"notifications.redact": { type: "boolean", default: false },
 	"notifications.verbosity": {
 		type: "string",
@@ -2126,6 +2130,17 @@ export const SETTINGS_SCHEMA = {
 		ui: { tab: "tools", label: "Read URLs", description: "Allow the read tool to fetch and process URLs" },
 	},
 
+	"web.insaneFallback": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "tools",
+			label: "Insane Search Fallback",
+			description:
+				"Opt in to the vendored insane-search escalation for blocked public URL reads (403/WAF/JS-gated). Off by default. Requires preinstalled python3 + curl_cffi (and node + playwright/stealth for the browser phase); changes network posture by enabling TLS/browser impersonation for public pages.",
+		},
+	},
+
 	"github.enabled": {
 		type: "boolean",
 		default: false,
@@ -2753,6 +2768,7 @@ export const SETTINGS_SCHEMA = {
 		values: [
 			"auto",
 			"duckduckgo",
+			"insane",
 			"exa",
 			"brave",
 			"jina",
@@ -2785,6 +2801,11 @@ export const SETTINGS_SCHEMA = {
 					label: "DuckDuckGo",
 					description: "Keyless default — no API key or OAuth required",
 				},
+				{
+					value: "insane",
+					label: "Insane",
+					description: "Keyless safe public-route fallback inspired by upstream insane-search",
+				},
 				{ value: "exa", label: "Exa", description: "Uses Exa API when EXA_API_KEY is set" },
 				{ value: "brave", label: "Brave", description: "Requires BRAVE_API_KEY" },
 				{ value: "jina", label: "Jina", description: "Requires JINA_API_KEY" },
@@ -3231,6 +3252,14 @@ export interface NotificationsSettings {
 		botToken: string | undefined;
 		chatId: string | undefined;
 	};
+	discord: {
+		botToken: string | undefined;
+		channelId: string | undefined;
+	};
+	slack: {
+		botToken: string | undefined;
+		channelId: string | undefined;
+	};
 	redact: boolean;
 	daemon: {
 		idleTimeoutMs: number;

package/src/deep-interview/plaintext-gate-guard.ts

@@ -0,0 +1,94 @@
+export type DeepInterviewPlaintextAskLeakOption = "Yes, crystallize" | "Adjust wording" | "Missing scope";
+
+export type DeepInterviewPlaintextAskLeakResult = {
+	kind: "deep_interview_plaintext_ask_leak";
+	matchedOptions: DeepInterviewPlaintextAskLeakOption[];
+	signals: {
+		optionsHeading: true;
+		restateIntent: true;
+		deepInterviewContext: boolean;
+	};
+};
+
+const CANONICAL_OPTIONS: DeepInterviewPlaintextAskLeakOption[] = [
+	"Yes, crystallize",
+	"Adjust wording",
+	"Missing scope",
+];
+
+const RESTATE_INTENT_PATTERNS: RegExp[] = [
+	/\brestate\b/i,
+	/\bconfirmation\b/i,
+	/\bconfirm(?:ation|ed|ing)?\b/i,
+	/\bcrystall?ize\b/i,
+	/\bdoes\s+this\s+(?:capture|match|reflect|summari[sz]e)\b/i,
+	/\bbefore\s+(?:i|we)\s+(?:write|finali[sz]e|crystall?ize)\b/i,
+	/\bread\s+only\s+this\s+line\b/i,
+	/\bturn\s+this\s+into\s+(?:the\s+)?(?:spec|final)\b/i,
+	/재진술/,
+	/다시\s*말/,
+	/확인/,
+	/확정/,
+	/정리/,
+	/요약/,
+	/맞(?:습니까|나요|는지)/,
+];
+
+const DEEP_INTERVIEW_CONTEXT_PATTERNS: RegExp[] = [
+	/\bdeep[ -]?interview\b/i,
+	/\bsocratic\b/i,
+	/\binterview\s+round\b/i,
+	/\bround\s+\d+\b/i,
+	/\bambiguity\b/i,
+	/\btopology\s+confirmation\b/i,
+	/딥\s*인터뷰/,
+	/심층\s*인터뷰/,
+	/인터뷰\s*(?:라운드|진행|확인)/,
+];
+
+const FINAL_ARTIFACT_PATTERNS: RegExp[] = [
+	/^\s*#{1,3}\s*(?:(?:final|approved|completed|완료|최종)\s+)?(?:deep[ -]?interview\s+)?(?:spec(?:ification)?|transcript)\b/im,
+	/^\s*#{1,3}\s*(?:deep[ -]?interview\s+)?(?:final|approved|completed|완료|최종)\s+(?:spec(?:ification)?|transcript)\b/im,
+	/\b(?:final|approved|completed)\s+(?:deep[ -]?interview\s+)?(?:spec(?:ification)?|transcript)\b/i,
+	/\binterview\s+transcript\b/i,
+	/\.skc\/specs\//i,
+	/최종\s*(?:명세|스펙|기록)/,
+];
+
+function hasOptionsHeading(text: string): boolean {
+	return /(?:^|\n)\s*options\s*:/i.test(text);
+}
+
+function hasPattern(text: string, patterns: RegExp[]): boolean {
+	return patterns.some(pattern => pattern.test(text));
+}
+
+function matchedCanonicalOptions(text: string): DeepInterviewPlaintextAskLeakOption[] {
+	const folded = text.toLocaleLowerCase("en-US");
+	return CANONICAL_OPTIONS.filter(option => folded.includes(option.toLocaleLowerCase("en-US")));
+}
+
+function looksLikeFinalArtifact(text: string): boolean {
+	return hasPattern(text, FINAL_ARTIFACT_PATTERNS);
+}
+
+export function detectDeepInterviewPlaintextAskLeak(text: string): DeepInterviewPlaintextAskLeakResult | null {
+	const trimmed = text.trim();
+	if (trimmed.length === 0) return null;
+	if (looksLikeFinalArtifact(trimmed)) return null;
+	if (!hasOptionsHeading(trimmed)) return null;
+
+	const matchedOptions = matchedCanonicalOptions(trimmed);
+	if (matchedOptions.length < 2) return null;
+	if (!hasPattern(trimmed, RESTATE_INTENT_PATTERNS)) return null;
+
+	return {
+		kind: "deep_interview_plaintext_ask_leak",
+		matchedOptions,
+		signals: {
+			optionsHeading: true,
+			restateIntent: true,
+			deepInterviewContext: hasPattern(trimmed, DEEP_INTERVIEW_CONTEXT_PATTERNS),
+		},
+	};
+}

package/src/defaults/skc/extensions/grok-cli-vendor/biome.json

@@ -17,7 +17,7 @@
   "linter": {
     "enabled": true,
     "rules": {
-      "recommended": true
+      "preset": "recommended"
     }
   },
   "javascript": {

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

@@ -292,7 +292,7 @@ Auto-research must never add a public skill entrypoint, never be slash-command/d
 
 ### Step 2b: Ask the Question
 
-Use the `ask` tool with the generated question. Before rendering the prompt/options, apply `language.instruction` from state when present so the entire user-facing question remains in the preserved session language. Present it clearly with the current ambiguity context:
+Use the `ask` tool with the generated question. When a question has options, you MUST call `ask` and must not print `Question:`/`Options:` blocks as assistant prose. If you already printed a question/options block as prose, your next action is to call `ask` with the same question/options, not to wait for a typed answer. Before rendering the prompt/options, apply `language.instruction` from state when present so the entire user-facing question remains in the preserved session language. Present it clearly with the current ambiguity context:
 
 ```
 Round {n} | Component: {target_component_name} | Targeting: {weakest_dimension} | Why now: {one_sentence_targeting_rationale} | Ambiguity: {score}%
@@ -458,7 +458,7 @@ Also recompute and persist `ambiguity_milestone` each round (detect band transit
 
 - **Round 3+**: Allow early exit if user says "enough", "let's go", "build it"
 - **Round 10**: Show soft warning: "We're at 10 rounds. Current ambiguity: {score}%. Continue or proceed with current clarity?"
-- **Round 20**: Hard cap: "Maximum interview rounds reached. Proceeding with current clarity level ({score}%)."
+- **Round 100**: Hard cap: "Maximum interview rounds reached. Proceeding with current clarity level ({score}%)."
 
 ## Phase 3: Lateral Review Panel (milestone-triggered)
 
@@ -495,7 +495,7 @@ When ambiguity ≤ threshold (or hard cap / early exit):
 
 **4a. Closure / Acceptance Guard.** Even when ambiguity ≤ threshold, do not treat the math as completion. Run an independent readiness audit from the full main-session perspective (including explore findings, established facts, and triggers the scorer may not have fully weighed). Confirm every active topology component has goal/constraint/criteria coverage, no unresolved or disputed trigger remains on a path that matters, and no low-confidence auto-answer is standing in for user-confirmed truth above the clarity cap. If a material gap exists, explicitly override the gate to the user — "The math says ready, but I am not accepting it yet because {gap}" — and ask the single highest-impact follow-up, returning to Phase 2. Record any override in `state.closure_overrides`.
 
-**4b. Restate gate.** Once closure passes, collapse the agreed answers into ONE sentence goal that covers every active component, and confirm it with a single `ask`: "If someone read only this line, would they reach the same outcome you have in mind?" Offer **Yes, crystallize**, **Adjust wording**, and **Missing scope**, plus free-text, applying `language.instruction` when present. On "Adjust wording" / "Missing scope", collect the exact correction with one follow-up `ask`, route it back through Step 2c scoring and established-facts maintenance (a correction can change ambiguity), then re-run closure and ask the Restate gate again. Cap at two loops; if alignment is not reached, return to Phase 2 with a targeted question instead of forcing a goal line. Persist the confirmed line as `state.restated_goal`.
+**4b. Restate gate.** Once closure passes, collapse the agreed answers into ONE sentence goal that covers every active component, and confirm it with a single `ask`: "If someone read only this line, would they reach the same outcome you have in mind?" Offer **Yes, crystallize**, **Adjust wording**, and **Missing scope**, plus free-text, applying `language.instruction` when present. Because this gate has options, it MUST go through `ask`: do not print the Restate question and options as assistant prose with `Question:`/`Options:` labels. If the Restate gate was already printed that way, immediately call `ask` with the same question/options before accepting or waiting for any answer. On "Adjust wording" / "Missing scope", collect the exact correction with one follow-up `ask`, route it back through Step 2c scoring and established-facts maintenance (a correction can change ambiguity), then re-run closure and ask the Restate gate again. Cap at two loops; if alignment is not reached, return to Phase 2 with a targeted question instead of forcing a goal line. Persist the confirmed line as `state.restated_goal`.
 
 1. **Generate the specification** using opus model with the prompt-safe transcript. If the full interview transcript or initial context is too large, include the summary plus all concrete decisions, acceptance criteria, unresolved gaps, and ontology snapshots; never overflow the prompt with raw oversized context.
    - Apply `language.instruction` when present so user-facing prose in the spec preserves the session language; keep code identifiers, file paths, commands, JSON/settings keys, and quoted source text unchanged.
@@ -690,6 +690,7 @@ Skipping any stage is possible but reduces quality assurance:
 
 <Tool_Usage>
 - Use the `ask` tool for each interview question — provides clickable UI with contextual options
+- For any option-bearing question, call `ask`; never print `Question:`/`Options:` blocks as assistant prose. If such a block was already printed, call `ask` with the same question/options as the very next action instead of waiting for a typed/prose answer
 - Preserve the SKC `ask` tool path for native interaction; do not introduce parallel structured-question transport into this skill
 - Use `read/search/find exploration or a bounded read-only planner/architect subagent` for brownfield codebase exploration (run BEFORE asking user about codebase)
 - Use opus model (temperature 0.1) for ambiguity scoring — consistency is critical
@@ -698,7 +699,7 @@ Skipping any stage is possible but reduces quality assurance:
 - Use the SKC workflow CLI to save the final spec at `.skc/_session-{sessionid}/specs/deep-interview-{slug}.md` exactly; do not use `write`, `edit`, or `ast_edit` directly on `.skc/` paths without force override.
 - Use public SKC workflow entrypoints to bridge to ralplan, ultragoal, or team only after explicit execution approval — never implement directly. Implementation handoff defaults to ultragoal; reserve team for when tmux-based interactive worker parallelization is genuinely required.
 - The lateral-review panel spawns read-only persona subagents (Task tool) in parallel with independent context; it is an assist layer, never an executor and never the completion authority
-- Apply the Refine gate (Step 2b″), the Dialectic Rhythm Guard (Step 2a), and the Closure + Restate gates (Phase 4) through the `ask` tool, preserving `language.instruction` for each
+- Apply the Refine gate (Step 2b″), the Dialectic Rhythm Guard (Step 2a), and the Closure + Restate gates (Phase 4) through the `ask` tool, preserving `language.instruction` for each; if any of these gates has options, the assistant must call `ask` and must not print `Question:`/`Options:` blocks as assistant prose
 - Use internal fragment auto-modes only at their documented hooks: `auto-research-greenfield.md` between Step 2a and 2b for greenfield `research: true` questions, `auto-answer-uncertain.md` as Step 2b′ after `ask` resolves and before scoring, and `lateral-review-panel.md` for the Phase 3 panel personas at ambiguity-milestone transitions and before synthesizing agent-supplied answers.
 - Fragment auto-modes are loaded on demand as `kind: "skill-fragment"`; they are not public workflow skills, not slash-command/discoverable, and not `skill://` registrations.
 </Tool_Usage>
@@ -787,7 +788,7 @@ Why bad: 45% ambiguity means nearly half the requirements are unclear. The mathe
 </Examples>
 
 <Escalation_And_Stop_Conditions>
-- **Hard cap at 20 rounds**: Proceed with whatever clarity exists, noting the risk
+- **Hard cap at 100 rounds**: Proceed with whatever clarity exists, noting the risk
 - **Soft warning at 10 rounds**: Offer to continue or proceed
 - **Early exit (round 3+)**: Allow with warning if ambiguity > threshold
 - **User says "stop", "cancel", "abort"**: Stop immediately, save state for resume
@@ -822,7 +823,7 @@ Optional settings in `.skc/settings.json`:
   "skc": {
     "deepInterview": {
       "ambiguityThreshold": <resolvedThreshold>,
-      "maxRounds": 20,
+      "maxRounds": 100,
       "softWarningRounds": 10,
       "minRoundsBeforeExit": 3,
       "enableChallengeAgents": true,