@gajae-code/coding-agent 0.12.11 → 0.12.13

package/src/extensibility/extensions/ouroboros-ooo-bridge.ts

@@ -0,0 +1,235 @@
+import type { MCPServerConnection, MCPToolCallResult } from "../../runtime-mcp";
+import { callTool, connectToServer, disconnectServer } from "../../runtime-mcp";
+import { createExactPrefixCommandBridge } from "./prefix-command-bridge";
+import type { ExtensionContext, InputEvent, InputEventResult } from "./types";
+
+const OUROBOROS_CLI_ENV = "OUROBOROS_CLI";
+const INTERVIEW_COMMAND = "ooo interview";
+const INTERVIEW_TOOL = "ouroboros_interview";
+const INTERVIEW_SESSION_PATTERN = /^interview_[A-Za-z0-9_-]+$/;
+
+interface OuroborosOooBridgeOptions {
+	connect?: typeof connectToServer;
+	callTool?: typeof callTool;
+	disconnect?: typeof disconnectServer;
+}
+
+interface InterviewState {
+	sessionId: string;
+}
+
+interface OuroborosOooBridgeHandler {
+	(event: InputEvent, ctx: ExtensionContext): Promise<InputEventResult>;
+	reset(): Promise<void>;
+}
+
+function resolveOuroborosCommand(): string {
+	return process.env[OUROBOROS_CLI_ENV]?.trim() || "ouroboros";
+}
+
+function interviewArgument(text: string): string | undefined {
+	if (text === INTERVIEW_COMMAND) return "";
+	if (text.startsWith(`${INTERVIEW_COMMAND} `) || text.startsWith(`${INTERVIEW_COMMAND}\t`)) {
+		return text.slice(INTERVIEW_COMMAND.length).trim();
+	}
+	return undefined;
+}
+
+function isOooCommand(text: string): boolean {
+	return text === "ooo" || text.startsWith("ooo ") || text.startsWith("ooo\t");
+}
+
+function isBuiltInControlInput(text: string): boolean {
+	return text === "." || text === "c" || text.startsWith("/");
+}
+
+function resetsInterviewState(text: string): boolean {
+	return /^\/(?:clear|drop|exit|new|quit)(?:\s|$)/.test(text);
+}
+
+function resultText(result: MCPToolCallResult): string {
+	return result.content
+		.filter(content => content.type === "text")
+		.map(content => content.text)
+		.join("\n\n")
+		.trim();
+}
+
+function resultMeta(result: MCPToolCallResult): Record<string, unknown> {
+	return result._meta ?? {};
+}
+
+function resultSessionId(result: MCPToolCallResult, text: string): string | undefined {
+	const metadataSessionId = resultMeta(result).session_id;
+	if (typeof metadataSessionId === "string" && INTERVIEW_SESSION_PATTERN.test(metadataSessionId)) {
+		return metadataSessionId;
+	}
+	const textSessionId = /\bSession(?: ID)?:\s*(interview_[A-Za-z0-9_-]+)/.exec(text)?.[1];
+	return textSessionId && INTERVIEW_SESSION_PATTERN.test(textSessionId) ? textSessionId : undefined;
+}
+
+function resultCompleted(result: MCPToolCallResult): boolean {
+	const meta = resultMeta(result);
+	return meta.completed === true || meta.phase === "complete";
+}
+
+export function createOuroborosOooBridge(options: OuroborosOooBridgeOptions = {}): OuroborosOooBridgeHandler {
+	const connect = options.connect ?? connectToServer;
+	const invoke = options.callTool ?? callTool;
+	const disconnect = options.disconnect ?? disconnectServer;
+	let interview: InterviewState | undefined;
+	let interviewCaptureActive = false;
+	let activeConnection: MCPServerConnection | undefined;
+	let pendingConnection: Promise<MCPServerConnection> | undefined;
+	let activeOperationAbort: AbortController | undefined;
+	let lifecycleGeneration = 0;
+	let operationTail: Promise<void> = Promise.resolve();
+
+	const commandBridge = createExactPrefixCommandBridge({
+		prefix: "ooo",
+		command: resolveOuroborosCommand(),
+		args: ["dispatch", "--runtime", "gjc"],
+	});
+
+	function assertCurrent(generation: number, signal: AbortSignal | undefined): void {
+		if (generation !== lifecycleGeneration || signal?.aborted) {
+			throw signal?.reason instanceof Error ? signal.reason : new Error("Ouroboros interview operation cancelled");
+		}
+	}
+
+	async function disconnectSafely(connection: MCPServerConnection | undefined): Promise<void> {
+		if (!connection) return;
+		try {
+			await disconnect(connection);
+		} catch {
+			// State is already fenced. A dead transport must not keep ordinary input captured.
+		}
+	}
+
+	async function resetInterview(): Promise<void> {
+		lifecycleGeneration++;
+		interviewCaptureActive = false;
+		const operationAbort = activeOperationAbort;
+		activeOperationAbort = undefined;
+		operationAbort?.abort(new Error("Ouroboros interview reset"));
+		const connectionToClose = activeConnection;
+		interview = undefined;
+		activeConnection = undefined;
+		pendingConnection = undefined;
+		await disconnectSafely(connectionToClose);
+	}
+
+	async function connection(ctx: ExtensionContext, generation: number): Promise<MCPServerConnection> {
+		assertCurrent(generation, ctx.signal);
+		if (activeConnection) return activeConnection;
+		const pending =
+			pendingConnection ??
+			connect(
+				"ouroboros-ooo-bridge",
+				{
+					type: "stdio",
+					command: resolveOuroborosCommand(),
+					args: ["mcp", "serve", "--runtime", "gjc"],
+					cwd: ctx.cwd,
+				},
+				{ signal: ctx.signal },
+			);
+		pendingConnection = pending;
+		try {
+			const connected = await pending;
+			try {
+				assertCurrent(generation, ctx.signal);
+			} catch (error) {
+				await disconnectSafely(connected);
+				throw error;
+			}
+			activeConnection = connected;
+			return connected;
+		} finally {
+			if (pendingConnection === pending) pendingConnection = undefined;
+		}
+	}
+
+	async function runInterview(text: string, ctx: ExtensionContext): Promise<InputEventResult> {
+		const operationAbort = new AbortController();
+		activeOperationAbort = operationAbort;
+		const operationSignal = ctx.signal ? AbortSignal.any([ctx.signal, operationAbort.signal]) : operationAbort.signal;
+		const operationContext: ExtensionContext = { ...ctx, signal: operationSignal };
+		const generation = lifecycleGeneration;
+		const abortHandler = () => {
+			void resetInterview();
+		};
+		ctx.signal?.addEventListener("abort", abortHandler, { once: true });
+		try {
+			const interviewConnection = await connection(operationContext, generation);
+			const commandArgument = interviewArgument(text);
+			const args: Record<string, unknown> = { cwd: ctx.cwd };
+			if (interview) {
+				args.session_id = interview.sessionId;
+				const answer = commandArgument === undefined ? text.trim() : commandArgument;
+				if (answer) args.answer = answer;
+			} else {
+				args.initial_context = commandArgument ?? "";
+			}
+
+			const result = await invoke(interviewConnection, INTERVIEW_TOOL, args, { signal: operationSignal });
+			assertCurrent(generation, operationSignal);
+			const output = resultText(result);
+			if (result.isError) throw new Error(output || "Ouroboros interview failed");
+
+			const sessionId = resultSessionId(result, output);
+			if (!resultCompleted(result)) {
+				if (!sessionId) throw new Error("Ouroboros interview response did not include a session ID");
+				interview = { sessionId };
+			} else {
+				await resetInterview();
+			}
+			return output ? { handled: true, text: output } : { handled: true };
+		} catch (error) {
+			await resetInterview();
+			if (!ctx.signal?.aborted) {
+				const message = error instanceof Error ? error.message : String(error);
+				ctx.ui?.notify(message, "error");
+			}
+			return { handled: true };
+		} finally {
+			ctx.signal?.removeEventListener("abort", abortHandler);
+			if (activeOperationAbort === operationAbort) activeOperationAbort = undefined;
+		}
+	}
+
+	function enqueueInterview(
+		text: string,
+		ctx: ExtensionContext,
+		explicitInterview: boolean,
+	): Promise<InputEventResult> {
+		const submissionGeneration = lifecycleGeneration;
+		const operation = operationTail.then(async () => {
+			if (submissionGeneration !== lifecycleGeneration) return { handled: true };
+			if (!explicitInterview && !interviewCaptureActive && !interview) return { handled: true };
+			return runInterview(text, ctx);
+		});
+		operationTail = operation.then(
+			() => undefined,
+			() => undefined,
+		);
+		return operation;
+	}
+
+	const handler = async (event: InputEvent, ctx: ExtensionContext): Promise<InputEventResult> => {
+		if (event.source !== undefined && event.source !== "interactive") return {};
+		if (isBuiltInControlInput(event.text)) {
+			if (resetsInterviewState(event.text)) await resetInterview();
+			return {};
+		}
+		const argument = interviewArgument(event.text);
+		const explicitInterview = argument !== undefined;
+		if (explicitInterview) interviewCaptureActive = true;
+		if (explicitInterview || ((interviewCaptureActive || interview) && !isOooCommand(event.text))) {
+			return enqueueInterview(event.text, ctx, explicitInterview);
+		}
+		return commandBridge(event, ctx);
+	};
+
+	return Object.assign(handler, { reset: resetInterview });
+}

package/src/extensibility/extensions/prefix-command-bridge.ts

@@ -86,7 +86,10 @@ export function createExactPrefixCommandBridge(options: ExactPrefixCommandBridge
 		process.env[recursionEnv] = nextRecursionDepth(recursionEnv);
 		try {
 			const result = await dispatch(options.command, [...args, event.text], ctx, { timeout });
-			if (result.code === 0) return { handled: true };
+			if (result.code === 0) {
+				const output = result.stdout.trim() || result.stderr.trim();
+				return output ? { handled: true, text: output } : { handled: true };
+			}
 			if (result.code === continueExitCode) return {};
 
 			const output =
@@ -118,11 +121,3 @@ export function createExactPrefixCommandBridge(options: ExactPrefixCommandBridge
 		}
 	};
 }
-
-export function createOuroborosOooBridge() {
-	return createExactPrefixCommandBridge({
-		prefix: "ooo",
-		command: "ouroboros",
-		args: ["dispatch"],
-	});
-}

package/src/extensibility/extensions/runner.ts

@@ -79,6 +79,16 @@ export function testSetExtensionHandlerTimeoutMs(timeoutMs: number): void {
 const EXTENSION_HANDLER_TIMEOUT = Symbol("extensionHandlerTimeout");
 
 const MAX_PENDING_CREDENTIAL_DISABLED = 32;
+function createHandlerContext(ctx: ExtensionContext, signal: AbortSignal): ExtensionContext {
+	const descriptors = Object.getOwnPropertyDescriptors(ctx);
+	descriptors.signal = {
+		configurable: true,
+		enumerable: true,
+		writable: true,
+		value: signal,
+	};
+	return Object.defineProperties({}, descriptors) as ExtensionContext;
+}
 
 /**
  * Events handled by the generic emit() method.
@@ -688,12 +698,14 @@ export class ExtensionRunner {
 		ext: Extension,
 		timeoutMs: number,
 	): Promise<TResult | undefined> {
-		let timeout: ReturnType<typeof setTimeout> | undefined;
+		let timeout: NodeJS.Timeout | undefined;
+		const abortController = new AbortController();
+		const handlerContext = createHandlerContext(ctx, abortController.signal);
 		try {
 			const timeoutPromise = new Promise<typeof EXTENSION_HANDLER_TIMEOUT>(resolve => {
 				timeout = setTimeout(() => resolve(EXTENSION_HANDLER_TIMEOUT), timeoutMs);
 			});
-			const handlerResult = await Promise.race([Promise.resolve(handler(event, ctx)), timeoutPromise]);
+			const handlerResult = await Promise.race([Promise.resolve(handler(event, handlerContext)), timeoutPromise]);
 			if (timeout !== undefined) {
 				clearTimeout(timeout);
 				timeout = undefined;
@@ -701,6 +713,7 @@ export class ExtensionRunner {
 
 			if (handlerResult === EXTENSION_HANDLER_TIMEOUT) {
 				const error = `handler timed out after ${timeoutMs}ms`;
+				abortController.abort(new Error(error));
 				logger.warn("Extension handler timed out", {
 					extensionPath: ext.path,
 					event: event.type,

package/src/extensibility/extensions/types.ts

@@ -352,6 +352,8 @@ export interface ExtensionContext {
 	hasUI: boolean;
 	/** Current working directory */
 	cwd: string;
+	/** Aborted when the runner stops waiting for this handler, including handler timeout. */
+	signal?: AbortSignal;
 	/** Session manager (read-only) */
 	sessionManager: ReadonlySessionManager;
 	/** Session classification supplied by the SDK for extension policy decisions. */

package/src/gjc-runtime/deep-interview-recorder.ts

@@ -11,6 +11,7 @@ import {
 	assertDeepInterviewInputWithinLimit,
 	assertDeepInterviewIntentManifest,
 	assertDeepInterviewStructuredResponseWithinLimit,
+	canonicalizeDeepInterviewText,
 	createDeepInterviewIntentManifest,
 	type DeepInterviewEstablishedFact,
 	type DeepInterviewIntentItem,
@@ -106,16 +107,19 @@ export function buildAnswerShell(
 	input: DeepInterviewAnswerInput,
 	now: string = new Date().toISOString(),
 ): DeepInterviewRoundRecord {
+	const questionText = canonicalizeDeepInterviewText(input.questionText);
+	const selectedOptions = input.selectedOptions?.map(canonicalizeDeepInterviewText);
+	const customInput = input.customInput === undefined ? undefined : canonicalizeDeepInterviewText(input.customInput);
 	return {
 		round_key: deriveRoundKey(input.interviewId, input),
 		round_id: input.round_id,
 		round: input.round,
 		question_id: input.questionId,
-		question_text: input.questionText,
-		question_hash: questionHash(input.questionText),
-		answer_hash: answerHash(input.selectedOptions, input.customInput),
-		selected_options: input.selectedOptions,
-		custom_input: input.customInput,
+		question_text: questionText,
+		question_hash: questionHash(questionText),
+		answer_hash: answerHash(selectedOptions, customInput),
+		selected_options: selectedOptions,
+		custom_input: customInput,
 		component: input.component,
 		dimension: input.dimension,
 		ambiguity_at_ask: input.ambiguity,

package/src/gjc-runtime/deep-interview-state.ts

@@ -97,13 +97,34 @@ export function hashContent(value: string): string {
 	return createHash("sha256").update(value).digest("hex").slice(0, 32);
 }
 
+/**
+ * Canonicalize interview prose to NFC.
+ *
+ * Hangul, unlike most Latin prose, routinely reaches the interview in both
+ * composed and decomposed form (macOS-sourced pastes and some IME/clipboard
+ * paths emit NFD), and the two forms are the same text for the user while
+ * being different JavaScript strings. Canonicalizing at the identity and
+ * length boundaries keeps one round per answer and keeps the character caps
+ * script-fair: decomposed Hangul otherwise costs two to three code points per
+ * syllable against the same budget.
+ */
+export function canonicalizeDeepInterviewText(value: string): string {
+	return value.normalize("NFC");
+}
+
 export function questionHash(questionText: string): string {
-	return hashContent(questionText);
+	return hashContent(canonicalizeDeepInterviewText(questionText));
 }
 
 export function answerHash(selectedOptions: string[] | undefined, customInput: string | undefined): string {
 	return createHash("sha256")
-		.update(JSON.stringify({ selected: selectedOptions ?? [], custom: customInput ?? null }))
+		.update(
+			JSON.stringify({
+				selected: (selectedOptions ?? []).map(canonicalizeDeepInterviewText),
+				custom:
+					customInput === undefined || customInput === null ? null : canonicalizeDeepInterviewText(customInput),
+			}),
+		)
 		.digest("hex");
 }
 
@@ -471,10 +492,13 @@ export function assertDeepInterviewStructuredResponseWithinLimit(value: unknown)
 /**
  * Assert a free-text input is within its size cap. Never inspects content for shell
  * metacharacters — free-text fields accept prose verbatim; this only bounds length.
+ * The cap is measured on the NFC form so decomposed Hangul is charged the same
+ * budget as the identical composed text.
  */
 export function assertDeepInterviewInputWithinLimit(value: string, max: number, fieldName = "input"): void {
 	if (typeof value !== "string") throw new Error(`${fieldName} must be a string`);
-	if (deepInterviewCharacterCount(value) > max) throw new Error(`${fieldName} exceeds max length ${max}`);
+	if (deepInterviewCharacterCount(canonicalizeDeepInterviewText(value)) > max)
+		throw new Error(`${fieldName} exceeds max length ${max}`);
 }
 
 /** Validate user-supplied deep-interview prose before an envelope is persisted. */

package/src/gjc-runtime/gc-render.ts

@@ -72,6 +72,12 @@ export function buildGcReportText(report: GcReport): string {
 		lines.push("");
 	}
 
+	if (report.warnings.length > 0) {
+		lines.push(`Warnings (${report.warnings.length})`);
+		for (const warning of report.warnings) lines.push(`  [${warning.store}/${warning.scope}] ${warning.message}`);
+		lines.push("");
+	}
+
 	if (report.errors.length > 0) {
 		lines.push(`Errors (${report.errors.length})`);
 		for (const err of report.errors) lines.push(`  [${err.store}/${err.scope}] ${err.message}`);
@@ -82,7 +88,8 @@ export function buildGcReportText(report: GcReport): string {
 	lines.push(
 		`Summary: discovered=${c.discovered} stale=${c.stale} alive=${c.alive} eperm=${c.eperm} unknown=${c.unknown} ` +
 			`terminal_lifecycle=${c.terminal_lifecycle} unclassified=${c.unclassified} ` +
-			`${report.dry_run ? `would_remove=${c.would_remove}` : `removed=${c.removed} failed=${c.failed}`} errors=${c.errors}`,
+			`${report.dry_run ? `would_remove=${c.would_remove}` : `removed=${c.removed} failed=${c.failed}`} ` +
+			`errors=${c.errors} warnings=${report.warnings.length}`,
 	);
 	lines.push("");
 	return `${lines.join("\n")}`;

package/src/gjc-runtime/gc-runtime.ts

@@ -78,9 +78,18 @@ export interface GcError {
 	message: string;
 }
 
+/** Non-fatal discovery partials (e.g. traversal caps). Does not affect exit code. */
+export interface GcWarning {
+	store: GcStore;
+	scope: string;
+	message: string;
+}
+
 export interface GcCollectResult {
 	records: GcRecord[];
 	errors: GcError[];
+	/** Optional partial-result notices; omitted by adapters that have none. */
+	warnings?: GcWarning[];
 }
 
 export interface GcPruneOutcome {
@@ -140,6 +149,8 @@ export interface GcReport {
 	stores: Record<GcStore, GcRecord[]>;
 	counts: GcCounts;
 	errors: GcError[];
+	/** Partial-result notices that do not fail the run (e.g. walk caps). */
+	warnings: GcWarning[];
 	session_index?: GcSessionIndexHealth;
 }
 
@@ -298,12 +309,14 @@ function parseGcArgs(argv: string[]): ParsedGcArgs {
 export async function collectGcReport(adapters: GcStoreAdapter[], ctx: GcContext, prune: boolean): Promise<GcReport> {
 	const stores = emptyStores();
 	const errors: GcError[] = [];
+	const warnings: GcWarning[] = [];
 
 	for (const adapter of adapters) {
 		try {
 			const result = await adapter.collect(ctx);
 			stores[adapter.store].push(...result.records);
 			errors.push(...result.errors);
+			if (result.warnings) warnings.push(...result.warnings);
 		} catch (error) {
 			errors.push({
 				store: adapter.store,
@@ -350,7 +363,7 @@ export async function collectGcReport(adapters: GcStoreAdapter[], ctx: GcContext
 		}
 	}
 
-	return { dry_run: !prune, stores, counts: computeCounts(stores, errors), errors };
+	return { dry_run: !prune, stores, counts: computeCounts(stores, errors), errors, warnings };
 }
 
 /**
@@ -358,6 +371,7 @@ export async function collectGcReport(adapters: GcStoreAdapter[], ctx: GcContext
  * - usage/parse error => 2
  * - hard discovery errors => 1 (both modes)
  * - prune mode with a failed intended removal => 1
+ * - warnings alone never fail the run
  * - otherwise => 0
  */
 export function computeExitCode(report: GcReport): number {

package/src/gjc-runtime/launch-tmux.ts

@@ -652,6 +652,56 @@ function renameTmuxWindow(
 	spawnSync(tmuxCommand, buildTmuxRenameWindowArgs(title, target), options);
 }
 
+interface TmuxWindowIdentity {
+	paneId: string;
+	windowId: string;
+	windowIndex: string;
+}
+
+function parseTmuxWindowIdentity(value: string): TmuxWindowIdentity | null {
+	const [paneId, windowId, windowIndex, extra] = value.trim().split("\t");
+	if (
+		extra !== undefined ||
+		paneId === undefined ||
+		windowId === undefined ||
+		windowIndex === undefined ||
+		!/^%\d+$/.test(paneId) ||
+		!/^@\d+$/.test(windowId) ||
+		!/^\d+$/.test(windowIndex)
+	)
+		return null;
+	return { paneId, windowId, windowIndex };
+}
+
+function quoteTmuxCommandArgument(value: string): string {
+	return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
+function renameExistingTmuxWindow(
+	tmuxCommand: string,
+	paneId: string,
+	title: string,
+	spawnSync: TmuxSpawnSync,
+	options: TmuxSpawnOptions,
+): void {
+	if (!/^%\d+$/.test(paneId)) return;
+	const observed = spawnSync(
+		tmuxCommand,
+		["display-message", "-p", "-t", paneId, "#{pane_id}\t#{window_id}\t#{window_index}"],
+		options,
+	);
+	if (observed.exitCode !== 0) return;
+	const identity = parseTmuxWindowIdentity(observed.stdout ?? "");
+	if (!identity || identity.paneId !== paneId) return;
+
+	// `if-shell -F` evaluates the pane binding and inserts the rename into the
+	// same tmux command queue. The nested command targets the immutable window
+	// id, so an active-window switch or index reuse cannot redirect the rename.
+	const predicate = `#{&&:#{==:#{pane_id},${identity.paneId}},#{&&:#{==:#{window_id},${identity.windowId}},#{==:#{window_index},${identity.windowIndex}}}}`;
+	const command = `rename-window -t ${identity.windowId} -- ${quoteTmuxCommandArgument(title)}`;
+	spawnSync(tmuxCommand, ["if-shell", "-t", identity.paneId, "-F", predicate, command], options);
+}
+
 function renameExistingTmuxWindowIfNeeded(context: TmuxLaunchContext): void {
 	const env = context.env ?? process.env;
 	if (!env.TMUX || env[GJC_TMUX_LAUNCHED_ENV] === "1") return;
@@ -669,11 +719,13 @@ function renameExistingTmuxWindowIfNeeded(context: TmuxLaunchContext): void {
 	const tmuxAvailable = context.tmuxAvailable ?? Bun.which(tmuxCommand) !== null;
 	if (!tmuxAvailable) return;
 
+	const paneId = env.TMUX_PANE?.trim();
+	if (!paneId) return;
 	const cwd = context.cwd ?? process.cwd();
 	const branch = context.worktreeBranch ?? context.currentBranch ?? readCurrentBranch(cwd);
 	const title = buildGjcTmuxWindowTitle(context.project ?? cwd, branch);
 	const spawnSync = context.spawnSync ?? defaultSpawnSync;
-	renameTmuxWindow(tmuxCommand, title, spawnSync, {
+	renameExistingTmuxWindow(tmuxCommand, paneId, title, spawnSync, {
 		cwd,
 		env,
 		stdin: "pipe",