@gajae-code/coding-agent 0.11.1 → 0.11.2

package/src/tool-discovery/tool-index.ts

@@ -7,6 +7,7 @@ export type DiscoverableToolSource = "builtin" | "mcp" | "extension" | "custom";
 export interface DiscoverableTool {
 	name: string;
 	label: string;
+	description: string;
 	/** Short BM25 corpus entry; falls back to description first 200 chars */
 	summary: string;
 	source: DiscoverableToolSource;
@@ -44,47 +45,6 @@ export interface DiscoverableToolSearchResult {
 	score: number;
 }
 
-// ─── Legacy MCP-typed aliases (back-compat) ──────────────────────────────────
-
-/** @deprecated Use DiscoverableTool with source === "mcp" */
-export type DiscoverableMCPTool = Pick<
-	DiscoverableTool,
-	"name" | "label" | "schemaKeys" | "serverName" | "mcpToolName"
-> & { description: string };
-
-/** @deprecated Use DiscoverableToolServerSummary */
-export type DiscoverableMCPToolServerSummary = DiscoverableToolServerSummary;
-
-/** @deprecated Use DiscoverableToolSummary */
-export type DiscoverableMCPToolSummary = DiscoverableToolSummary;
-
-/** Tool object stored on legacy MCP index documents. Carries both legacy `description` and the
- *  generic `summary`/`source` so the legacy index is structurally assignable to
- *  DiscoverableToolSearchIndex (search functions read termFrequencies, not the tool fields). */
-export type DiscoverableMCPSearchTool = DiscoverableTool & { description: string };
-
-/** @deprecated Use DiscoverableToolSearchDocument */
-export interface DiscoverableMCPSearchDocument {
-	tool: DiscoverableMCPSearchTool;
-	termFrequencies: Map<string, number>;
-	length: number;
-}
-
-/** @deprecated Use DiscoverableToolSearchIndex.
- *  Documents on this index expose `tool.description` (legacy MCP shape) while still being
- *  searchable via `searchDiscoverableTools`. */
-export interface DiscoverableMCPSearchIndex {
-	documents: DiscoverableMCPSearchDocument[];
-	averageLength: number;
-	documentFrequencies: Map<string, number>;
-}
-
-/** @deprecated Use DiscoverableToolSearchResult */
-export interface DiscoverableMCPSearchResult {
-	tool: DiscoverableMCPSearchTool;
-	score: number;
-}
-
 // ─── BM25 Constants ───────────────────────────────────────────────────────────
 
 const BM25_K1 = 1.2;
@@ -194,6 +154,7 @@ export function getDiscoverableTool(
 	return {
 		name: tool.name,
 		label: typeof toolRecord.label === "string" ? toolRecord.label : tool.name,
+		description: rawDescription,
 		summary,
 		source,
 		serverName: typeof toolRecord.mcpServerName === "string" ? toolRecord.mcpServerName : undefined,
@@ -305,96 +266,3 @@ export function searchDiscoverableTools(
 		.sort((left, right) => right.score - left.score || left.tool.name.localeCompare(right.tool.name))
 		.slice(0, limit);
 }
-
-// ─── Legacy MCP-specific shims (back-compat wrappers) ────────────────────────
-
-/** @deprecated Use getDiscoverableTool */
-export function getDiscoverableMCPTool(tool: AgentTool): DiscoverableMCPTool | null {
-	const toolRecord = tool as AgentTool & {
-		label?: string;
-		description?: string;
-		mcpServerName?: string;
-		mcpToolName?: string;
-		parameters?: unknown;
-	};
-	if (!isMCPBridgeTool(toolRecord)) return null;
-	return {
-		name: tool.name,
-		label: typeof toolRecord.label === "string" ? toolRecord.label : tool.name,
-		description: typeof toolRecord.description === "string" ? toolRecord.description : "",
-		serverName: typeof toolRecord.mcpServerName === "string" ? toolRecord.mcpServerName : undefined,
-		mcpToolName: typeof toolRecord.mcpToolName === "string" ? toolRecord.mcpToolName : undefined,
-		schemaKeys: getSchemaPropertyKeys(toolRecord.parameters),
-	};
-}
-
-/** @deprecated Use collectDiscoverableTools with source filter */
-export function collectDiscoverableMCPTools(tools: Iterable<AgentTool>): DiscoverableMCPTool[] {
-	const discoverable: DiscoverableMCPTool[] = [];
-	for (const tool of tools) {
-		const metadata = getDiscoverableMCPTool(tool);
-		if (metadata) {
-			discoverable.push(metadata);
-		}
-	}
-	return discoverable;
-}
-
-/** @deprecated Use selectDiscoverableToolNamesByServer */
-export function selectDiscoverableMCPToolNamesByServer(
-	tools: Iterable<DiscoverableMCPTool>,
-	serverNames: ReadonlySet<string>,
-): string[] {
-	if (serverNames.size === 0) return [];
-	return Array.from(tools)
-		.filter(tool => tool.serverName !== undefined && serverNames.has(tool.serverName))
-		.map(tool => tool.name);
-}
-
-/** @deprecated Use summarizeDiscoverableTools */
-export function summarizeDiscoverableMCPTools(tools: DiscoverableMCPTool[]): DiscoverableMCPToolSummary {
-	const serverToolCounts = new Map<string, number>();
-	for (const tool of tools) {
-		if (!tool.serverName) continue;
-		serverToolCounts.set(tool.serverName, (serverToolCounts.get(tool.serverName) ?? 0) + 1);
-	}
-	const servers = Array.from(serverToolCounts.entries())
-		.sort(([left], [right]) => left.localeCompare(right))
-		.map(([name, toolCount]) => ({ name, toolCount }));
-	return {
-		servers,
-		toolCount: tools.length,
-	};
-}
-
-/** @deprecated Use buildDiscoverableToolSearchIndex.
- *  Builds an index whose documents preserve the legacy `description` field on each tool while
- *  also carrying the generic `summary` (set from `description`) so the index remains usable
- *  with `searchDiscoverableTools`. */
-export function buildDiscoverableMCPSearchIndex(tools: Iterable<DiscoverableMCPTool>): DiscoverableMCPSearchIndex {
-	const adapted: DiscoverableMCPSearchTool[] = Array.from(tools).map(t => ({
-		name: t.name,
-		label: t.label,
-		description: t.description,
-		summary: t.description,
-		source: "mcp" as DiscoverableToolSource,
-		serverName: t.serverName,
-		mcpToolName: t.mcpToolName,
-		schemaKeys: t.schemaKeys,
-	}));
-	const generic = buildDiscoverableToolSearchIndex(adapted);
-	// Documents reference `adapted` tools (with `description`), so the cast is sound.
-	return generic as unknown as DiscoverableMCPSearchIndex;
-}
-
-/** @deprecated Use searchDiscoverableTools */
-export function searchDiscoverableMCPTools(
-	index: DiscoverableMCPSearchIndex | DiscoverableToolSearchIndex,
-	query: string,
-	limit: number,
-): DiscoverableMCPSearchResult[] {
-	return searchDiscoverableTools(index as DiscoverableToolSearchIndex, query, limit) as DiscoverableMCPSearchResult[];
-}
-
-/** @deprecated Use formatDiscoverableToolServerSummary */
-export const formatDiscoverableMCPToolServerSummary = formatDiscoverableToolServerSummary;

package/src/tools/ask.ts

@@ -66,29 +66,130 @@ const OptionItem = z.object({
 	label: z.string().describe("display label"),
 });
 
+const DeepInterviewIntentItem = z
+	.object({
+		id: z.string().regex(/^(artifact|surface|integration|constraint):[a-z0-9][a-z0-9._/-]{0,127}$/),
+		category: z.enum(["artifact", "surface", "integration", "constraint"]),
+		statement: z.string().min(1).max(1_000),
+	})
+	.strict()
+	.superRefine((value, context) => {
+		if (!value.id.startsWith(`${value.category}:`))
+			context.addIssue({ code: "custom", message: "intent ID must use its category prefix", path: ["id"] });
+	});
+
+const DeepInterviewIntentContract = z
+	.object({
+		items: z.array(DeepInterviewIntentItem).min(1).max(64),
+		confirmation_options: z.array(z.string().min(1).max(200)).min(1).max(5),
+	})
+	.strict();
+
+const DeepInterviewIntentReview = z
+	.object({
+		observed_items: z.array(DeepInterviewIntentItem).min(1).max(64),
+		supporting_substitutions: z
+			.array(
+				z
+					.object({
+						removed_id: z
+							.string()
+							.regex(/^(artifact|surface|integration|constraint):[a-z0-9][a-z0-9._/-]{0,127}$/),
+						replacement_ids: z
+							.array(z.string().regex(/^(artifact|surface|integration|constraint):[a-z0-9][a-z0-9._/-]{0,127}$/))
+							.min(1)
+							.max(64),
+						rationale: z.string().min(1).max(500),
+					})
+					.strict(),
+			)
+			.max(64),
+		approval_options: z.array(z.string().min(1).max(200)).min(1).max(5),
+	})
+	.strict();
+
 /** Optional structured deep-interview round metadata; when present the round is recorded automatically. */
-const DeepInterviewMeta = z.object({
-	round_id: z.string().describe("stable optional round identity").optional(),
-	round: z.number().int().nonnegative().describe("round number"),
-	component: z.string().min(1).describe("targeted topology component"),
-	dimension: z.string().min(1).describe("targeted clarity dimension"),
-	ambiguity: z.number().min(0).max(1).describe("ambiguity at ask time (0..1)"),
-});
+const DeepInterviewMeta = z
+	.object({
+		round_id: z.string().max(128).describe("stable optional round identity").optional(),
+		round: z.number().int().nonnegative().describe("round number"),
+		component: z.string().min(1).max(128).describe("targeted topology component"),
+		dimension: z.string().min(1).max(128).describe("targeted clarity dimension"),
+		ambiguity: z.number().min(0).max(1).describe("ambiguity at ask time (0..1)"),
+		intent_contract: DeepInterviewIntentContract.describe("Round-0 locked intent contract").optional(),
+		intent_review: DeepInterviewIntentReview.describe("Locked-intent reduction review").optional(),
+	})
+	.strict()
+	.superRefine((value, context) => {
+		if (
+			value.intent_contract &&
+			(value.round !== 0 || value.component !== "review-topology" || value.dimension !== "topology")
+		)
+			context.addIssue({
+				code: "custom",
+				message: "intent_contract requires Round 0 review-topology metadata",
+				path: ["intent_contract"],
+			});
+		if (value.intent_review && value.round === 0)
+			context.addIssue({
+				code: "custom",
+				message: "intent_review requires a post-Round-0 answer",
+				path: ["intent_review"],
+			});
+		if (value.intent_contract && value.intent_review)
+			context.addIssue({ code: "custom", message: "intent_contract and intent_review are mutually exclusive" });
+	});
 
 const WorkflowGateMeta = z.object({
 	stage: z.enum(["deep-interview", "ralplan", "ultragoal"]).describe("workflow gate stage"),
 	kind: z.enum(["question", "approval", "execution"]).describe("workflow gate kind"),
 });
 
-const QuestionItem = z.object({
-	id: z.string().describe("question id"),
-	question: z.string().describe("question text"),
-	options: z.array(OptionItem).describe("available options"),
-	multi: z.boolean().describe("allow multiple selections").optional(),
-	recommended: z.number().describe("recommended option index").optional(),
-	deepInterview: DeepInterviewMeta.describe("optional deep-interview round metadata").optional(),
-	workflowGate: WorkflowGateMeta.describe("optional workflow gate stage/kind override").optional(),
-});
+const QuestionItem = z
+	.object({
+		id: z.string().describe("question id"),
+		question: z.string().describe("question text"),
+		options: z.array(OptionItem).describe("available options"),
+		multi: z.boolean().describe("allow multiple selections").optional(),
+		recommended: z.number().describe("recommended option index").optional(),
+		deepInterview: DeepInterviewMeta.describe("optional deep-interview round metadata").optional(),
+		workflowGate: WorkflowGateMeta.describe("optional workflow gate stage/kind override").optional(),
+	})
+	.superRefine((value, context) => {
+		const labels = new Set(value.options.map(option => option.label));
+		if ((value.deepInterview?.intent_contract || value.deepInterview?.intent_review) && value.multi === true)
+			context.addIssue({ code: "custom", message: "intent gates must be single-select", path: ["multi"] });
+		const confirmationOptions = value.deepInterview?.intent_contract?.confirmation_options ?? [];
+		if (new Set(confirmationOptions).size !== confirmationOptions.length)
+			context.addIssue({
+				code: "custom",
+				message: "intent confirmation options must be unique",
+				path: ["deepInterview", "intent_contract"],
+			});
+		const approvalOptions = value.deepInterview?.intent_review?.approval_options ?? [];
+		if (new Set(approvalOptions).size !== approvalOptions.length)
+			context.addIssue({
+				code: "custom",
+				message: "intent approval options must be unique",
+				path: ["deepInterview", "intent_review"],
+			});
+		for (const label of value.deepInterview?.intent_contract?.confirmation_options ?? []) {
+			if (!labels.has(label))
+				context.addIssue({
+					code: "custom",
+					message: "intent confirmation option must be displayed",
+					path: ["deepInterview", "intent_contract"],
+				});
+		}
+		for (const label of value.deepInterview?.intent_review?.approval_options ?? []) {
+			if (!labels.has(label))
+				context.addIssue({
+					code: "custom",
+					message: "intent approval option must be displayed",
+					path: ["deepInterview", "intent_review"],
+				});
+		}
+	});
 
 export const askSchema = z.object({
 	questions: z.array(QuestionItem).min(1).describe("questions to ask"),
@@ -133,7 +234,11 @@ function errorMessage(error: unknown): string {
 	return error instanceof Error ? error.message : String(error);
 }
 
-async function awaitDeepInterviewRecorderPersistence(persistence: Promise<void>): Promise<void> {
+async function awaitDeepInterviewRecorderPersistence(persistence: Promise<void>, required: boolean): Promise<void> {
+	if (required) {
+		await persistence;
+		return;
+	}
 	let timeout: ReturnType<typeof setTimeout> | undefined;
 	try {
 		await Promise.race([
@@ -147,6 +252,7 @@ async function awaitDeepInterviewRecorderPersistence(persistence: Promise<void>)
 		]);
 	} catch (error) {
 		logger.warn(`ask: deep-interview round recording failed: ${errorMessage(error)}`);
+		if (required) throw error;
 	} finally {
 		if (timeout) clearTimeout(timeout);
 	}
@@ -293,6 +399,7 @@ interface AskSingleQuestionOptions {
 	scrollTitleRows?: number;
 	otherOptionLabel?: string;
 	clarificationOptionLabel?: string;
+	autoSelectOnTimeout?: boolean;
 	onRemoteState?: (state: {
 		interaction: "selector" | "custom_editor" | "clarification_editor";
 		selectedCount: number;
@@ -334,7 +441,15 @@ async function askSingleQuestion(
 	multi: boolean,
 	options: AskSingleQuestionOptions = {},
 ): Promise<SelectionResult> {
-	const { recommended, timeout, signal, initialSelection, navigation, scrollTitleRows } = options;
+	const {
+		recommended,
+		timeout,
+		signal,
+		initialSelection,
+		navigation,
+		scrollTitleRows,
+		autoSelectOnTimeout = true,
+	} = options;
 	const doneLabel = getDoneOptionLabel();
 	const otherOptionLabel = options.otherOptionLabel ?? OTHER_OPTION;
 	const clarificationOptionLabel = options.clarificationOptionLabel;
@@ -632,12 +747,23 @@ async function askSingleQuestion(
 				selectedOptions = [];
 			}
 		}
+		if (timedOut && !autoSelectOnTimeout) {
+			return {
+				selectedOptions: [],
+				customInput: undefined,
+				timedOut,
+				...(navigation?.allowForward ? { navigation: "forward" as const } : {}),
+			};
+		}
 		if (navigation?.allowForward) {
 			return { selectedOptions, customInput, timedOut, navigation: "forward" };
 		}
 	}
 
-	if (timedOut && selectedOptions.length === 0 && customInput === undefined) {
+	if (timedOut && !autoSelectOnTimeout) {
+		return { selectedOptions: [], customInput: undefined, timedOut };
+	}
+	if (timedOut && selectedOptions.length === 0 && customInput === undefined && autoSelectOnTimeout) {
 		selectedOptions = getAutoSelectionOnTimeout(optionLabels, recommended);
 	}
 
@@ -724,11 +850,14 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 					ambiguity: meta.ambiguity,
 					selectedOptions,
 					customInput,
+					intent_contract: meta.intent_contract,
+					intent_review: meta.intent_review,
 				},
 				{ sessionId },
 			).then(async () => {
 				await syncDeepInterviewRecorderHud(cwd, statePath, sessionId);
 			}),
+			meta.intent_contract !== undefined || meta.intent_review !== undefined,
 		);
 	}
 
@@ -1061,6 +1190,7 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 					navigation: options?.navigation,
 					scrollTitleRows: isDeepInterviewQuestion ? DEEP_INTERVIEW_SELECTOR_SCROLL_TITLE_ROWS : undefined,
 					otherOptionLabel,
+					autoSelectOnTimeout: !q.deepInterview?.intent_contract && !q.deepInterview?.intent_review,
 					clarificationOptionLabel,
 					onRemoteState: state => {
 						activeRemoteRequest = {
@@ -1145,7 +1275,10 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 				context?.abort();
 				throw new ToolAbortError("Ask tool was cancelled by the user");
 			}
-			if (clarificationQuestion === undefined) {
+			if (
+				clarificationQuestion === undefined &&
+				!(timedOut && (q.deepInterview?.intent_contract || q.deepInterview?.intent_review))
+			) {
 				await this.#recordDeepInterviewRound(q, selectedOptions, customInput);
 			}
 			const details: AskToolDetails = {
@@ -1223,7 +1356,10 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 				clarificationQuestion,
 			};
 
-			if (clarificationQuestion === undefined) {
+			if (
+				clarificationQuestion === undefined &&
+				!(timedOut && (q.deepInterview?.intent_contract || q.deepInterview?.intent_review))
+			) {
 				await this.#recordDeepInterviewRound(q, selectedOptions, customInput);
 			}
 

package/src/tools/ast-edit.ts

@@ -9,7 +9,7 @@ import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { computeLineHash, HL_BODY_SEP } from "../hashline/hash";
 import type { Theme } from "../modes/theme/theme";
 import astEditDescription from "../prompts/tools/ast-edit.md" with { type: "text" };
-import { assertWorkflowMutationRawPathsAllowed } from "../skill-state/deep-interview-mutation-guard";
+import { assertWorkflowMutationRawPathsAllowed } from "../skill-state/workflow-mutation-guard";
 import { Ellipsis, fileHyperlink, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import type { ToolSession } from ".";

package/src/tools/bash.ts

@@ -99,6 +99,43 @@ export interface BashToolDetails {
 	};
 }
 
+/** Project only a bare executable name; commands and their output are never notification-safe. */
+export function summarizeBashToolActivity(kind: "args" | "result", value: unknown): string | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const record = value as Record<string, unknown>;
+	if (kind === "args") {
+		const command = record.command;
+		if (typeof command !== "string") return undefined;
+		const program = command.trim().match(/^([A-Za-z][A-Za-z0-9_.+-]*)\b/)?.[1];
+		if (
+			!program ||
+			program.length > 80 ||
+			/(?:api[-_ ]?key|access[-_ ]?token|bearer|secret|password|\b(?:sk|pk|rk)-)/i.test(program)
+		) {
+			return undefined;
+		}
+		return program;
+	}
+
+	const output =
+		typeof record.output === "string"
+			? record.output
+			: Array.isArray(record.content)
+				? record.content
+						.filter(
+							(block): block is { type: unknown; text: unknown } =>
+								typeof block === "object" && block !== null && "type" in block && "text" in block,
+						)
+						.filter(block => block.type === "text" && typeof block.text === "string")
+						.map(block => block.text as string)
+						.join("\n")
+				: undefined;
+	if (output === undefined) return undefined;
+	const exitCode = typeof record.exitCode === "number" ? `exit=${record.exitCode}` : "completed";
+	const lines = output.length === 0 ? 0 : output.split("\n").length;
+	return `${exitCode}, ${lines} lines, ${Buffer.byteLength(output, "utf-8")} bytes`;
+}
+
 export interface BashToolOptions {}
 
 type ManagedBashJobCompletion =
@@ -248,6 +285,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 	readonly parameters: BashToolSchema;
 	readonly concurrency = "exclusive";
 	readonly strict = true;
+	readonly safeSummary = summarizeBashToolActivity;
 	readonly #asyncEnabled: boolean;
 	readonly #autoBackgroundEnabled: boolean;
 	readonly #autoBackgroundThresholdMs: number;

package/src/tools/browser/dead-tab-recovery.ts

@@ -0,0 +1,78 @@
+export type DeadTabRecoveryConsumeStatus = "consumed" | "expired_or_missing" | "owner_mismatch";
+
+export interface DeadTabRecoveryConsumeResult<T> {
+	status: DeadTabRecoveryConsumeStatus;
+	descriptor?: T;
+}
+
+interface StoredDescriptor<T> {
+	descriptor: T;
+	ownerId: string | undefined;
+	expiresAt: number;
+}
+
+interface DeadTabRecoveryDeps {
+	now(): number;
+	onPeek(): void;
+}
+
+const DEFAULT_TTL_MS = 30_000;
+const descriptors = new Map<string, StoredDescriptor<unknown>>();
+let deps: DeadTabRecoveryDeps = { now: () => Date.now(), onPeek: () => {} };
+
+/** Store a short-lived immutable recovery descriptor for a dead tab worker. */
+export function registerDeadTabRecovery<T extends object>(
+	name: string,
+	ownerId: string | undefined,
+	descriptor: T,
+	ttlMs = DEFAULT_TTL_MS,
+): void {
+	descriptors.set(name, { descriptor: Object.freeze(descriptor), ownerId, expiresAt: deps.now() + ttlMs });
+}
+
+/**
+ * Check whether a recovery descriptor may be consumed by this owner. The test hook is
+ * intentionally synchronous: recovery must not yield between this check and consume.
+ */
+export function peekDeadTabRecovery<T>(name: string, ownerId: string | undefined): DeadTabRecoveryConsumeResult<T> {
+	const stored = descriptors.get(name);
+	const result: DeadTabRecoveryConsumeResult<T> =
+		!stored || stored.expiresAt <= deps.now()
+			? { status: "expired_or_missing" }
+			: stored.ownerId !== ownerId
+				? { status: "owner_mismatch" }
+				: { status: "consumed", descriptor: stored.descriptor as T };
+	deps.onPeek();
+	return result;
+}
+
+/** Consume only a live descriptor belonging to the expected owner. */
+export function consumeDeadTabRecovery<T>(name: string, ownerId: string | undefined): DeadTabRecoveryConsumeResult<T> {
+	const stored = descriptors.get(name);
+	if (!stored || stored.expiresAt <= deps.now()) {
+		if (stored) descriptors.delete(name);
+		return { status: "expired_or_missing" };
+	}
+	if (stored.ownerId !== ownerId) return { status: "owner_mismatch" };
+	descriptors.delete(name);
+	return { status: "consumed", descriptor: stored.descriptor as T };
+}
+
+export function discardDeadTabRecovery(name: string): void {
+	descriptors.delete(name);
+}
+
+/** Whether an unconsumed descriptor remains live at the supplied policy clock. */
+export function isDeadTabRecoveryLive(name: string, now: number): boolean {
+	const stored = descriptors.get(name);
+	return stored !== undefined && stored.expiresAt > now;
+}
+
+export function __setDeadTabRecoveryDepsForTest(overrides: Partial<DeadTabRecoveryDeps>): void {
+	deps = { ...deps, ...overrides };
+}
+
+export function __resetDeadTabRecoveryForTest(): void {
+	descriptors.clear();
+	deps = { now: () => Date.now(), onPeek: () => {} };
+}