@gajae-code/coding-agent 0.7.1 → 0.7.3

package/src/cli/notify-cli.ts

@@ -29,6 +29,8 @@ export interface NotifyCommandDeps {
 	pollIntervalMs?: number;
 	setupChatId?: string;
 	setupRedact?: boolean;
+	setupInteractive?: boolean;
+	threadedModePrompt?: (message: string) => Promise<string>;
 }
 
 interface TelegramApiResponse<T> {
@@ -47,6 +49,18 @@ interface TelegramUpdate {
 	};
 }
 
+interface TelegramUser {
+	id: number;
+	is_bot?: boolean;
+	first_name?: string;
+	username?: string;
+	has_topics_enabled?: boolean;
+	allows_users_to_create_topics?: boolean;
+}
+
+type ThreadedModeState = "enabled" | "disabled" | "unknown";
+type ThreadedModeFinalLabel = "verified" | "unverified" | "unknown";
+
 const DEFAULT_API_BASE = "https://api.telegram.org";
 const DEFAULT_POLL_TIMEOUT_MS = 60_000;
 const DEFAULT_POLL_INTERVAL_MS = 1_000;
@@ -120,7 +134,11 @@ async function runSetup(deps: NotifyCommandDeps): Promise<void> {
 		throw new Error("Telegram bot token is required.");
 	}
 
-	await callTelegram(fetchImpl, apiBase, token, "getMe", {});
+	const user = await getMe(fetchImpl, apiBase, token);
+	const threadedState = await verifyThreadedMode(fetchImpl, apiBase, token, user, {
+		interactive: resolveSetupInteractive(deps),
+		prompt: deps.threadedModePrompt ?? promptForThreadedMode,
+	});
 	process.stdout.write(
 		"Token validated. Message your bot now from the private Telegram chat to pair notifications.\n",
 	);
@@ -145,7 +163,9 @@ async function runSetup(deps: NotifyCommandDeps): Promise<void> {
 	if (deps.setupRedact) settings.set("notifications.redact", true);
 	await settings.flush();
 
-	process.stdout.write(`Notifications enabled. botToken=${maskToken(token)} chatId=${chatId}\n`);
+	process.stdout.write(
+		`Notifications enabled. botToken=${maskToken(token)} chatId=${chatId} threaded=${threadedLabel(threadedState)}\n`,
+	);
 }
 
 async function promptForToken(): Promise<string> {
@@ -160,14 +180,135 @@ async function promptForToken(): Promise<string> {
 	}
 }
 
+const THREADED_ENABLED_SUCCESS =
+	"Telegram Threaded Mode capability verified for this bot. GJC will request a private-chat topic per session; if Telegram ever refuses topic creation, notifications fall back to this flat chat with a one-time nudge.\n";
+
+const THREADED_MISSING_WARNING =
+	"Warning: Telegram getMe did not include has_topics_enabled, so GJC cannot verify private-chat Threaded Mode capability for this bot. Setup will continue; update Telegram/Bot API support or re-run setup if per-session topics fail.\n";
+
+const THREADED_NONINTERACTIVE_WARNING =
+	"Warning: Telegram Threaded Mode capability is OFF for this bot. Setup will be saved because this run is non-interactive, but per-session Telegram delivery may fail closed until the bot owner enables Threaded Mode in @BotFather. GJC cannot enable it through the Bot API.\n";
+
+const THREADED_DISABLED_GUIDANCE =
+	"Telegram Threaded Mode is OFF for this bot. GJC needs Telegram private-chat topics so each session can use its own thread.\n" +
+	"GJC cannot enable this through the Bot API. Open @BotFather, select this bot, enable Threaded Mode / forum topics for private chats, then return here.\n" +
+	"Telegram may require an additional Stars purchase fee for private-chat topics.\n";
+
+const THREADED_DISABLED_PROMPT =
+	"Press Enter after enabling Threaded Mode, or type skip to finish setup with a warning: ";
+
+const THREADED_STILL_OFF = "Telegram still reports Threaded Mode OFF for this bot.\n";
+
+const THREADED_RETRY_PROMPT = "Press Enter to check again, or type skip to finish setup with a warning: ";
+
+const THREADED_SKIP_WARNING =
+	"Warning: continuing without verified Telegram Threaded Mode capability. Setup will be saved, but per-session Telegram delivery may fail closed until Threaded Mode is enabled in BotFather.\n";
+
+const THREADED_INVALID_INPUT = "Type Enter to retry or skip to continue with a warning.\n";
+
+const THREADED_RETRY_INPUTS = new Set(["", "y", "yes", "r", "retry"]);
+const THREADED_SKIP_INPUTS = new Set(["s", "skip", "n", "no"]);
+
+function isTelegramUser(value: unknown): value is TelegramUser {
+	return Boolean(value) && typeof value === "object" && typeof (value as { id?: unknown }).id === "number";
+}
+
+async function getMe(fetchImpl: typeof fetch, apiBase: string, token: string): Promise<TelegramUser> {
+	const user = await callTelegram<unknown>(fetchImpl, apiBase, token, "getMe", {});
+	if (!isTelegramUser(user)) {
+		throw new Error("Telegram getMe returned invalid Telegram response: missing valid User result.");
+	}
+	return user;
+}
+
+function threadedModeState(user: TelegramUser): ThreadedModeState {
+	if (user.has_topics_enabled === true) return "enabled";
+	if (user.has_topics_enabled === false) return "disabled";
+	return "unknown";
+}
+
+function threadedLabel(state: ThreadedModeState): ThreadedModeFinalLabel {
+	if (state === "enabled") return "verified";
+	if (state === "disabled") return "unverified";
+	return "unknown";
+}
+
+function resolveSetupInteractive(deps: NotifyCommandDeps): boolean {
+	if (deps.setupInteractive !== undefined) return deps.setupInteractive;
+	return Boolean(process.stdin.isTTY) && !deps.setupChatId?.trim();
+}
+
+async function promptForThreadedMode(message: string): Promise<string> {
+	if (!process.stdin.isTTY) return "skip";
+	const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+	try {
+		return (await rl.question(message)).trim();
+	} finally {
+		rl.close();
+	}
+}
+
+async function verifyThreadedMode(
+	fetchImpl: typeof fetch,
+	apiBase: string,
+	token: string,
+	initialUser: TelegramUser,
+	opts: { interactive: boolean; prompt: (message: string) => Promise<string> },
+): Promise<ThreadedModeState> {
+	const classify = (user: TelegramUser): ThreadedModeState | undefined => {
+		const state = threadedModeState(user);
+		if (state === "enabled") {
+			process.stdout.write(THREADED_ENABLED_SUCCESS);
+			return "enabled";
+		}
+		if (state === "unknown") {
+			process.stdout.write(THREADED_MISSING_WARNING);
+			return "unknown";
+		}
+		return undefined;
+	};
+
+	const initial = classify(initialUser);
+	if (initial) return initial;
+
+	if (!opts.interactive) {
+		process.stdout.write(THREADED_NONINTERACTIVE_WARNING);
+		return "disabled";
+	}
+
+	process.stdout.write(THREADED_DISABLED_GUIDANCE);
+	let firstPrompt = true;
+	for (;;) {
+		const answer = (await opts.prompt(firstPrompt ? THREADED_DISABLED_PROMPT : THREADED_RETRY_PROMPT))
+			.trim()
+			.toLowerCase();
+		firstPrompt = false;
+		if (THREADED_SKIP_INPUTS.has(answer)) {
+			process.stdout.write(THREADED_SKIP_WARNING);
+			return "disabled";
+		}
+		if (!THREADED_RETRY_INPUTS.has(answer)) {
+			process.stdout.write(THREADED_INVALID_INPUT);
+			continue;
+		}
+		const resolved = classify(await getMe(fetchImpl, apiBase, token));
+		if (resolved) return resolved;
+		process.stdout.write(THREADED_STILL_OFF);
+	}
+}
+
 async function runStatus(deps: NotifyCommandDeps): Promise<void> {
 	const settings = await getSettings(deps);
 	const cfg = getNotificationConfig(settings);
 	process.stdout.write(
 		`${chalk.bold("Notifications")}\n` +
 			`  enabled: ${cfg.enabled}\n` +
-			`  botToken: ${maskToken(cfg.botToken)}\n` +
-			`  chatId: ${cfg.chatId ?? "(unset)"}\n` +
+			`  telegram.botToken: ${maskToken(cfg.botToken)}\n` +
+			`  telegram.chatId: ${cfg.chatId ?? "(unset)"}\n` +
+			`  discord.botToken: ${maskToken(cfg.discord.botToken)}\n` +
+			`  discord.channelId: ${cfg.discord.channelId ?? "(unset)"}\n` +
+			`  slack.botToken: ${maskToken(cfg.slack.botToken)}\n` +
+			`  slack.channelId: ${cfg.slack.channelId ?? "(unset)"}\n` +
 			`  redact: ${cfg.redact}\n`,
 	);
 }
@@ -263,12 +404,18 @@ ${chalk.bold("Usage:")}
   ${APP_NAME} notify status
 
 ${chalk.bold("Subcommands:")}
-  setup     Pair a Telegram bot token with a private chat
+  setup     Pair a Telegram bot token with a private chat and verify Threaded Mode capability
   status    Show notification configuration without secrets
 
 ${chalk.bold("Examples:")}
   ${APP_NAME} notify setup
   ${APP_NAME} notify setup --token <botToken> --chat-id <chatId> [--redact]
   ${APP_NAME} notify status
+
+${chalk.bold("Threaded Mode:")}
+  GJC uses Telegram private-chat topics for per-session threads. Setup verifies the bot
+  capability via getMe.has_topics_enabled. If it is off, enable Threaded Mode in @BotFather;
+  bots cannot toggle it through the Bot API. If Telegram refuses topic creation at runtime,
+  GJC delivers flat to the paired private chat and nudges you to enable Threaded Mode.
 `);
 }

package/src/cli.ts

@@ -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) },
 ];
 
@@ -220,4 +222,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 GJC.
+ */
+import { Args, Command, Flags } from "@gajae-code/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 GJC config";
+	static delegateHelp = true;
+
+	static examples = [
+		"gjc mcp add context7 npx -y @upstash/context7-mcp",
+		"gjc mcp add docs --type http --url https://example.test/mcp --header Authorization=Bearer_TOKEN",
+		"gjc mcp list --json",
+		"gjc 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 (./.gjc/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 GJC config
+
+USAGE
+  $ gjc 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 (./.gjc/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
+  $ gjc mcp add context7 npx -y @upstash/context7-mcp
+  $ gjc mcp add docs --type http --url https://example.test/mcp --header Authorization=Bearer_TOKEN
+  $ gjc mcp list --json
+  $ gjc 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/team.ts

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

@@ -254,10 +254,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",
@@ -2104,6 +2108,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,
@@ -2731,6 +2746,7 @@ export const SETTINGS_SCHEMA = {
 		values: [
 			"auto",
 			"duckduckgo",
+			"insane",
 			"exa",
 			"brave",
 			"jina",
@@ -2763,6 +2779,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" },
@@ -3177,6 +3198,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,
+	/\.gjc\/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/gjc/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}%
@@ -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 GJC `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 GJC workflow CLI to save the final spec at `.gjc/_session-{sessionid}/specs/deep-interview-{slug}.md` exactly; do not use `write`, `edit`, or `ast_edit` directly on `.gjc/` paths without force override.
 - Use public GJC 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>

package/src/defaults/gjc/skills/ralplan/SKILL.md

@@ -47,7 +47,7 @@ Planning artifacts and stage handoffs MUST be persisted through the ralplan CLI
 gjc ralplan --write --stage <type> --stage_n <N> --artifact "markdown file path or markdown string"
 ```
 
-Use stage values that match the producer or artifact kind, such as `planner`, `architect`, `critic`, `revision`, `adr`, or `final`. Increment `--stage_n` for each consensus-loop pass. The `--artifact` value may be either a markdown file path prepared outside `.gjc/` for ingestion or the markdown content string itself. The native `--write` handler persists markdown under `.gjc/_session-{sessionid}/plans/ralplan/<run-id>/stage-<NN>-<stage>.md`, maintains an `index.jsonl` audit log, and for `final` stages additionally writes a `pending-approval.md` copy. Direct `write`, `edit`, or `ast_edit` calls against `.gjc/_session-{sessionid}/specs`, `.gjc/_session-{sessionid}/plans`, `.gjc/_session-{sessionid}/state`, or any other `.gjc/` path are forbidden unless an explicit force override is active.
+Use stage values that match the producer or artifact kind, such as `planner`, `architect`, `critic`, `revision`, `post-interview`, `adr`, or `final`. Increment `--stage_n` for each consensus-loop pass. The `--artifact` value may be either a markdown file path prepared outside `.gjc/` for ingestion or the markdown content string itself. The native `--write` handler persists markdown under `.gjc/_session-{sessionid}/plans/ralplan/<run-id>/stage-<NN>-<stage>.md`, maintains an `index.jsonl` audit log, and for `final` stages additionally writes a `pending-approval.md` copy. Direct `write`, `edit`, or `ast_edit` calls against `.gjc/_session-{sessionid}/specs`, `.gjc/_session-{sessionid}/plans`, `.gjc/_session-{sessionid}/state`, or any other `.gjc/` path are forbidden unless an explicit force override is active.
 
 While ralplan is active it is a pre-approval planning phase: product-code mutation tools (`write`/`edit`/`ast_edit`) and product-mutating `bash` (e.g. `tee src/...`, redirects into the project tree) are blocked, exactly like deep-interview. Prefer passing the `--artifact` markdown **inline** (the content string) so no scratch file is needed; this is mandatory for restricted role agents (see below). Only the leader, and only when an artifact is too large to pass inline, may stage it as a file in a system temp directory (`os.tmpdir()`/`$TMPDIR`, `/tmp`, `/var/tmp`) outside the project tree and pass that path — never write scratch files into the repo or `.gjc/`. Product code is mutated only after the plan is approved and execution begins.
 
@@ -80,9 +80,16 @@ The consensus workflow:
    d. Return to Critic evaluation
    e. Repeat this loop until Critic returns `APPROVE` or 5 iterations are reached
    f. If 5 iterations are reached without `APPROVE`, present the best version to the user
-6. On Critic approval, mark the plan `pending approval` unless explicit execution approval has already been captured, persist the ADR/final plan via `gjc ralplan --write --stage final --stage_n <N> --artifact "..."`, and do not directly edit `.gjc/_session-{sessionid}/plans`. *(--interactive only)* If `--interactive` is set, use the `ask` tool to present the plan with approval options (Approve execution via ultragoal (Recommended) / Approve execution via team (only when tmux-based interactive worker parallelization is required) / Compact then return for execution approval / Request changes / Reject). Final plan must include ADR (Decision, Drivers, Alternatives considered, Why chosen, Consequences, Follow-ups). Otherwise, output the final plan and stop before any mutation or delegation.
-7. *(--interactive only)* User chooses: Approve ultragoal execution (recommended), Approve team execution (tmux parallelization only), Request changes, or Reject
-8. *(--interactive only)* On approval: invoke `/skill:ultragoal` for execution by default; invoke `/skill:team` only when the user explicitly needs tmux-based interactive worker parallelization -- never implement directly
+6. **Post-ralplan interview** (intent reconciliation gate): After Critic returns `APPROVE` and before the plan is finalized, reconcile the consensus plan against the user's actual intent. The goal is to make sure ralplan did not silently bake in assumptions that conflict with what the user wants.
+   a. **Collect open items** from the run: every assumption the Planner/Architect/Critic resolved by assumption rather than by stated fact, every ambiguity flagged during review, and every decision the loop made without explicit user input. Source these from the persisted `planner`/`architect`/`critic`/`revision` stage artifacts, not from memory.
+   b. **Cross-check prior context for conflicts**: glob `.gjc/_session-{sessionid}/specs/deep-interview-*.md` and other prior specs/plans/context relevant by topic. For each, list points where the consensus plan contradicts, weakens, or expands beyond a previously crystallized decision, constraint, or non-goal. Cite the conflicting artifact and line/section.
+   c. **Reconcile with the user**:
+      - *(--interactive only)* Use the `ask` tool to confirm the open assumptions and conflicts **one at a time**, weakest/highest-impact first, polishing intent. If any confirmation reveals that the plan diverges from user intent, route the consolidated correction back into the re-review loop (step 5b Planner revision) and re-run Architect + Critic before returning here. Cap at the same 5-iteration ceiling.
+      - *(automated mode)* Do not ask. Embed every unconfirmed assumption and every detected prior-context conflict into the final plan under an **## Intent Reconciliation** section as explicit open confirmations the user must review at the `pending approval` gate, so nothing is silently assumed.
+   d. Persist the reconciliation with `gjc ralplan --write --stage post-interview --stage_n <N> --artifact "..." --json`, then return the receipt/path plus a compact status (reconciled-clean / reconciled-with-revision / open-confirmations-pending) instead of pasting the full body.
+7. On reconciliation completion, mark the plan `pending approval` unless explicit execution approval has already been captured, persist the ADR/final plan via `gjc ralplan --write --stage final --stage_n <N> --artifact "..."`, and do not directly edit `.gjc/_session-{sessionid}/plans`. *(--interactive only)* If `--interactive` is set, use the `ask` tool to present the plan with approval options (Approve execution via ultragoal (Recommended) / Approve execution via team (only when tmux-based interactive worker parallelization is required) / Compact then return for execution approval / Request changes / Reject). Final plan must include ADR (Decision, Drivers, Alternatives considered, Why chosen, Consequences, Follow-ups) and, when present, the **## Intent Reconciliation** section. Otherwise, output the final plan and stop before any mutation or delegation.
+8. *(--interactive only)* User chooses: Approve ultragoal execution (recommended), Approve team execution (tmux parallelization only), Request changes, or Reject
+9. *(--interactive only)* On approval: invoke `/skill:ultragoal` for execution by default; invoke `/skill:team` only when the user explicitly needs tmux-based interactive worker parallelization -- never implement directly
 
    Before invoking `/skill:team` or `/skill:ultragoal`, mark ralplan ready for handoff so the skill tool's chain guard permits the transition:
 

package/src/defaults/gjc/skills/team/SKILL.md

@@ -311,8 +311,9 @@ Worker protocol:
 Useful runtime env vars:
 
 - `GJC_TMUX_COMMAND` / `GJC_TEAM_TMUX_COMMAND`
-  - tmux binary/command override (default `tmux`). `GJC_TMUX_COMMAND` applies to every GJC tmux flow; `GJC_TEAM_TMUX_COMMAND` is honored as an alias by the team path. Both resolve through the same resolver, so the team leader and `gjc session ...` always target the same multiplexer.
-  - Multiplexer support boundary: GJC-managed sessions and the team leader are detected via tmux user options (`@gjc-profile`, written with `set-option` and read back with `show-options` / `list-sessions -F`). A provider must round-trip those user options to be supported. Real tmux works. Alternative multiplexers such as psmux on Windows do not reliably persist tmux user options yet, so `gjc session status` reports `gjc_tmux_session_untagged` (the session exists in the multiplexer but is not GJC-tagged) and team startup rejects the leader as `unmanaged_tmux_session`. The Windows-native psmux path is therefore not fully supported; use real tmux for GJC-managed session and team flows.
+  - tmux binary/name override (default `tmux`). `GJC_TMUX_COMMAND` applies to every GJC tmux flow; `GJC_TEAM_TMUX_COMMAND` is honored as an alias by the team path. Both resolve through the same resolver, so the team leader and `gjc session ...` always target the same multiplexer. These values are executable path/name overrides, not shell command lines; do not include flags such as `psmux -L <namespace>` in the env var.
+  - Windows psmux namespace boundary: psmux can be exposed as `psmux.exe` or as its `tmux.exe`/`pmux.exe` aliases. Its `-c <path>` cwd/start-directory flags do not isolate the server namespace; psmux uses the tmux-compatible global `-L <namespace>` flag for isolated server instances. GJC does not currently expose structured runtime `-L` support, because launch, `gjc session`, and `gjc team` must all carry the same namespace prefix together.
+  - Multiplexer support boundary: GJC-managed sessions and the team leader are detected via tmux user options (`@gjc-profile`, written with `set-option` and read back with `show-options` / `list-sessions -F`). A provider must round-trip those user options to be supported. Real tmux works. Alternative multiplexers such as psmux on Windows do not reliably persist tmux user options yet, so `gjc session status` reports `gjc_tmux_session_untagged` (the session exists in the multiplexer but is not GJC-tagged) and team startup rejects the leader as `unmanaged_tmux_session`. psmux namespace isolation is separate from this ownership-tag support boundary; `-L` prevents cross-namespace server collision, but it does not make GJC-managed session and team flows supported while user options fail to round-trip. Use real tmux for GJC-managed session and team flows.
 - `GJC_TEAM_WORKER_COMMAND`
   - worker command override (default resolves to active GJC entrypoint or `gjc`)
 - `GJC_TEAM_STATE_ROOT`

package/src/extensibility/extensions/runner.ts

@@ -348,6 +348,7 @@ export class ExtensionRunner {
 		"ctrl+g",
 		"shift+tab",
 		"shift+ctrl+p",
+		"ctrl+enter",
 		"alt+enter",
 		"escape",
 		"enter",