gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0-dev.710c06e97

package/packages/contracts/src/rpc.ts

@@ -0,0 +1,286 @@
+// Project/App: GSD-2
+// File Purpose: Canonical RPC protocol contracts shared across runtime, SDK, MCP, and app surfaces.
+
+export const RPC_CONTRACT_VERSION = 1 as const;
+
+export const RPC_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
+
+export const RPC_COMMAND_TYPES = [
+	"prompt",
+	"steer",
+	"follow_up",
+	"abort",
+	"new_session",
+	"get_state",
+	"set_model",
+	"cycle_model",
+	"get_available_models",
+	"set_thinking_level",
+	"cycle_thinking_level",
+	"set_steering_mode",
+	"set_follow_up_mode",
+	"compact",
+	"set_auto_compaction",
+	"set_auto_retry",
+	"abort_retry",
+	"bash",
+	"abort_bash",
+	"get_session_stats",
+	"export_html",
+	"switch_session",
+	"fork",
+	"get_fork_messages",
+	"get_last_assistant_text",
+	"set_session_name",
+	"get_messages",
+	"get_commands",
+	"terminal_input",
+	"terminal_resize",
+	"terminal_redraw",
+	"init",
+	"shutdown",
+	"subscribe",
+] as const;
+
+export const RPC_V2_EVENT_TYPES = ["execution_complete", "cost_update"] as const;
+
+export const RPC_EXTENSION_UI_METHODS = [
+	"select",
+	"confirm",
+	"input",
+	"editor",
+	"notify",
+	"setStatus",
+	"setWidget",
+	"setTitle",
+	"set_editor_text",
+] as const;
+
+export type ThinkingLevel = (typeof RPC_THINKING_LEVELS)[number];
+
+export interface ImageContent {
+	type: "image";
+	data: string;
+	mimeType: string;
+}
+
+export interface ModelInfo {
+	provider: string;
+	id: string;
+	contextWindow?: number;
+	reasoning?: boolean;
+}
+
+export interface SessionStats {
+	sessionFile: string | undefined;
+	sessionId: string;
+	userMessages: number;
+	assistantMessages: number;
+	toolCalls: number;
+	toolResults: number;
+	totalMessages: number;
+	tokens: {
+		input: number;
+		output: number;
+		cacheRead: number;
+		cacheWrite: number;
+		total: number;
+	};
+	cost: number;
+}
+
+export interface BashResult {
+	output: string;
+	exitCode: number | undefined;
+	cancelled: boolean;
+	truncated: boolean;
+	fullOutputPath?: string;
+}
+
+export interface CompactionResult<T = unknown> {
+	summary: string;
+	firstKeptEntryId: string;
+	tokensBefore: number;
+	details?: T;
+}
+
+export type RpcProtocolVersion = 1 | 2;
+
+export type RpcCommand =
+	| { id?: string; type: "prompt"; message: string; images?: ImageContent[]; streamingBehavior?: "steer" | "followUp" }
+	| { id?: string; type: "steer"; message: string; images?: ImageContent[] }
+	| { id?: string; type: "follow_up"; message: string; images?: ImageContent[] }
+	| { id?: string; type: "abort" }
+	| { id?: string; type: "new_session"; parentSession?: string }
+	| { id?: string; type: "get_state" }
+	| { id?: string; type: "set_model"; provider: string; modelId: string }
+	| { id?: string; type: "cycle_model" }
+	| { id?: string; type: "get_available_models" }
+	| { id?: string; type: "set_thinking_level"; level: ThinkingLevel }
+	| { id?: string; type: "cycle_thinking_level" }
+	| { id?: string; type: "set_steering_mode"; mode: "all" | "one-at-a-time" }
+	| { id?: string; type: "set_follow_up_mode"; mode: "all" | "one-at-a-time" }
+	| { id?: string; type: "compact"; customInstructions?: string }
+	| { id?: string; type: "set_auto_compaction"; enabled: boolean }
+	| { id?: string; type: "set_auto_retry"; enabled: boolean }
+	| { id?: string; type: "abort_retry" }
+	| { id?: string; type: "bash"; command: string }
+	| { id?: string; type: "abort_bash" }
+	| { id?: string; type: "get_session_stats" }
+	| { id?: string; type: "export_html"; outputPath?: string }
+	| { id?: string; type: "switch_session"; sessionPath: string }
+	| { id?: string; type: "fork"; entryId: string }
+	| { id?: string; type: "get_fork_messages" }
+	| { id?: string; type: "get_last_assistant_text" }
+	| { id?: string; type: "set_session_name"; name: string }
+	| { id?: string; type: "get_messages" }
+	| { id?: string; type: "get_commands" }
+	| { id?: string; type: "terminal_input"; data: string }
+	| { id?: string; type: "terminal_resize"; cols: number; rows: number }
+	| { id?: string; type: "terminal_redraw" }
+	| { id?: string; type: "init"; protocolVersion: 2; clientId?: string }
+	| { id?: string; type: "shutdown"; graceful?: boolean }
+	| { id?: string; type: "subscribe"; events: string[] };
+
+export interface RpcSlashCommand {
+	name: string;
+	description?: string;
+	source: "extension" | "prompt" | "skill";
+	location?: "user" | "project" | "path";
+	path?: string;
+}
+
+export interface RpcSessionState {
+	model?: ModelInfo;
+	thinkingLevel: ThinkingLevel;
+	isStreaming: boolean;
+	isCompacting: boolean;
+	steeringMode: "all" | "one-at-a-time";
+	followUpMode: "all" | "one-at-a-time";
+	sessionFile?: string;
+	sessionId: string;
+	sessionName?: string;
+	autoCompactionEnabled: boolean;
+	autoRetryEnabled: boolean;
+	retryInProgress: boolean;
+	retryAttempt: number;
+	messageCount: number;
+	pendingMessageCount: number;
+	extensionsReady: boolean;
+}
+
+export type RpcResponse =
+	| { id?: string; type: "response"; command: "prompt"; success: true; runId?: string }
+	| { id?: string; type: "response"; command: "steer"; success: true; runId?: string }
+	| { id?: string; type: "response"; command: "follow_up"; success: true; runId?: string }
+	| { id?: string; type: "response"; command: "abort"; success: true }
+	| { id?: string; type: "response"; command: "new_session"; success: true; data: { cancelled: boolean } }
+	| { id?: string; type: "response"; command: "get_state"; success: true; data: RpcSessionState }
+	| { id?: string; type: "response"; command: "set_model"; success: true; data: ModelInfo }
+	| {
+			id?: string;
+			type: "response";
+			command: "cycle_model";
+			success: true;
+			data: { model: ModelInfo; thinkingLevel: ThinkingLevel; isScoped: boolean } | null;
+	  }
+	| { id?: string; type: "response"; command: "get_available_models"; success: true; data: { models: ModelInfo[] } }
+	| { id?: string; type: "response"; command: "set_thinking_level"; success: true }
+	| { id?: string; type: "response"; command: "cycle_thinking_level"; success: true; data: { level: ThinkingLevel } | null }
+	| { id?: string; type: "response"; command: "set_steering_mode"; success: true }
+	| { id?: string; type: "response"; command: "set_follow_up_mode"; success: true }
+	| { id?: string; type: "response"; command: "compact"; success: true; data: CompactionResult }
+	| { id?: string; type: "response"; command: "set_auto_compaction"; success: true }
+	| { id?: string; type: "response"; command: "set_auto_retry"; success: true }
+	| { id?: string; type: "response"; command: "abort_retry"; success: true }
+	| { id?: string; type: "response"; command: "bash"; success: true; data: BashResult }
+	| { id?: string; type: "response"; command: "abort_bash"; success: true }
+	| { id?: string; type: "response"; command: "get_session_stats"; success: true; data: SessionStats }
+	| { id?: string; type: "response"; command: "export_html"; success: true; data: { path: string } }
+	| { id?: string; type: "response"; command: "switch_session"; success: true; data: { cancelled: boolean } }
+	| { id?: string; type: "response"; command: "fork"; success: true; data: { text: string; cancelled: boolean } }
+	| { id?: string; type: "response"; command: "get_fork_messages"; success: true; data: { messages: Array<{ entryId: string; text: string }> } }
+	| { id?: string; type: "response"; command: "get_last_assistant_text"; success: true; data: { text: string | null } }
+	| { id?: string; type: "response"; command: "set_session_name"; success: true }
+	| { id?: string; type: "response"; command: "get_messages"; success: true; data: { messages: unknown[] } }
+	| { id?: string; type: "response"; command: "get_commands"; success: true; data: { commands: RpcSlashCommand[] } }
+	| { id?: string; type: "response"; command: "terminal_input"; success: true }
+	| { id?: string; type: "response"; command: "terminal_resize"; success: true }
+	| { id?: string; type: "response"; command: "terminal_redraw"; success: true }
+	| { id?: string; type: "response"; command: "init"; success: true; data: RpcInitResult }
+	| { id?: string; type: "response"; command: "shutdown"; success: true }
+	| { id?: string; type: "response"; command: "subscribe"; success: true }
+	| { id?: string; type: "response"; command: string; success: false; error: string };
+
+export interface RpcInitResult {
+	protocolVersion: 2;
+	sessionId: string;
+	capabilities: {
+		events: string[];
+		commands: string[];
+	};
+}
+
+export interface RpcExecutionCompleteEvent {
+	type: "execution_complete";
+	runId: string;
+	status: "completed" | "error" | "cancelled";
+	reason?: string;
+	stats: SessionStats;
+}
+
+export interface RpcCostUpdateEvent {
+	type: "cost_update";
+	runId: string;
+	turnCost: number;
+	cumulativeCost: number;
+	tokens: {
+		input: number;
+		output: number;
+		cacheRead: number;
+		cacheWrite: number;
+	};
+}
+
+export type RpcV2Event = RpcExecutionCompleteEvent | RpcCostUpdateEvent;
+
+/** Agent event — a loosely typed record from the RPC event stream. */
+export interface SdkAgentEvent {
+	type: string;
+	[key: string]: unknown;
+}
+
+export type RpcExtensionUIRequest =
+	| { type: "extension_ui_request"; id: string; method: "select"; title: string; options: string[]; timeout?: number; allowMultiple?: boolean }
+	| { type: "extension_ui_request"; id: string; method: "confirm"; title: string; message: string; timeout?: number }
+	| { type: "extension_ui_request"; id: string; method: "input"; title: string; placeholder?: string; timeout?: number; secure?: boolean }
+	| { type: "extension_ui_request"; id: string; method: "editor"; title: string; prefill?: string }
+	| { type: "extension_ui_request"; id: string; method: "notify"; message: string; notifyType?: "info" | "warning" | "error" }
+	| { type: "extension_ui_request"; id: string; method: "setStatus"; statusKey: string; statusText: string | undefined }
+	| {
+			type: "extension_ui_request";
+			id: string;
+			method: "setWidget";
+			widgetKey: string;
+			widgetLines: string[] | undefined;
+			widgetPlacement?: "aboveEditor" | "belowEditor";
+	  }
+	| { type: "extension_ui_request"; id: string; method: "setTitle"; title: string }
+	| { type: "extension_ui_request"; id: string; method: "set_editor_text"; text: string };
+
+export type RpcExtensionUIResponse =
+	| { type: "extension_ui_response"; id: string; value: string }
+	| { type: "extension_ui_response"; id: string; values: string[] }
+	| { type: "extension_ui_response"; id: string; confirmed: boolean }
+	| { type: "extension_ui_response"; id: string; cancelled: true };
+
+export type McpBlockerMethod = Extract<RpcExtensionUIRequest, { type: "extension_ui_request" }>["method"];
+
+export interface McpPendingBlocker {
+	id: string;
+	method: McpBlockerMethod;
+	message: string;
+	event: RpcExtensionUIRequest;
+}
+
+export type RpcCommandType = RpcCommand["type"];

package/packages/contracts/src/workflow.ts

@@ -0,0 +1,213 @@
+// Project/App: GSD-2
+// File Purpose: Canonical workflow MCP tool metadata shared across package boundaries.
+
+export type WorkflowToolWritePolicy = "read" | "write";
+
+export interface WorkflowToolContractMetadata {
+	canonicalName: string;
+	aliases: readonly string[];
+	schemaId: string;
+	executorId: string;
+	writePolicy: WorkflowToolWritePolicy;
+	auditEvent: string;
+}
+
+export const WORKFLOW_TOOL_CONTRACTS = [
+	{
+		canonicalName: "gsd_decision_save",
+		aliases: ["gsd_save_decision"],
+		schemaId: "workflow.decision.save",
+		executorId: "executeDecisionSave",
+		writePolicy: "write",
+		auditEvent: "workflow.decision.save",
+	},
+	{
+		canonicalName: "gsd_requirement_update",
+		aliases: ["gsd_update_requirement"],
+		schemaId: "workflow.requirement.update",
+		executorId: "executeRequirementUpdate",
+		writePolicy: "write",
+		auditEvent: "workflow.requirement.update",
+	},
+	{
+		canonicalName: "gsd_requirement_save",
+		aliases: ["gsd_save_requirement"],
+		schemaId: "workflow.requirement.save",
+		executorId: "executeRequirementSave",
+		writePolicy: "write",
+		auditEvent: "workflow.requirement.save",
+	},
+	{
+		canonicalName: "gsd_milestone_generate_id",
+		aliases: ["gsd_generate_milestone_id"],
+		schemaId: "workflow.milestone.generate_id",
+		executorId: "executeMilestoneGenerateId",
+		writePolicy: "read",
+		auditEvent: "workflow.milestone.generate_id",
+	},
+	{
+		canonicalName: "gsd_plan_milestone",
+		aliases: [],
+		schemaId: "workflow.milestone.plan",
+		executorId: "executePlanMilestone",
+		writePolicy: "write",
+		auditEvent: "workflow.milestone.plan",
+	},
+	{
+		canonicalName: "gsd_plan_slice",
+		aliases: [],
+		schemaId: "workflow.slice.plan",
+		executorId: "executePlanSlice",
+		writePolicy: "write",
+		auditEvent: "workflow.slice.plan",
+	},
+	{
+		canonicalName: "gsd_plan_task",
+		aliases: ["gsd_task_plan"],
+		schemaId: "workflow.task.plan",
+		executorId: "executePlanTask",
+		writePolicy: "write",
+		auditEvent: "workflow.task.plan",
+	},
+	{
+		canonicalName: "gsd_replan_slice",
+		aliases: ["gsd_slice_replan"],
+		schemaId: "workflow.slice.replan",
+		executorId: "executeReplanSlice",
+		writePolicy: "write",
+		auditEvent: "workflow.slice.replan",
+	},
+	{
+		canonicalName: "gsd_slice_complete",
+		aliases: ["gsd_complete_slice"],
+		schemaId: "workflow.slice.complete",
+		executorId: "executeSliceComplete",
+		writePolicy: "write",
+		auditEvent: "workflow.slice.complete",
+	},
+	{
+		canonicalName: "gsd_skip_slice",
+		aliases: [],
+		schemaId: "workflow.slice.skip",
+		executorId: "executeSkipSlice",
+		writePolicy: "write",
+		auditEvent: "workflow.slice.skip",
+	},
+	{
+		canonicalName: "gsd_complete_milestone",
+		aliases: ["gsd_milestone_complete"],
+		schemaId: "workflow.milestone.complete",
+		executorId: "executeCompleteMilestone",
+		writePolicy: "write",
+		auditEvent: "workflow.milestone.complete",
+	},
+	{
+		canonicalName: "gsd_validate_milestone",
+		aliases: ["gsd_milestone_validate"],
+		schemaId: "workflow.milestone.validate",
+		executorId: "executeValidateMilestone",
+		writePolicy: "write",
+		auditEvent: "workflow.milestone.validate",
+	},
+	{
+		canonicalName: "gsd_reassess_roadmap",
+		aliases: ["gsd_roadmap_reassess"],
+		schemaId: "workflow.roadmap.reassess",
+		executorId: "executeReassessRoadmap",
+		writePolicy: "write",
+		auditEvent: "workflow.roadmap.reassess",
+	},
+	{
+		canonicalName: "gsd_save_gate_result",
+		aliases: [],
+		schemaId: "workflow.gate.save_result",
+		executorId: "executeSaveGateResult",
+		writePolicy: "write",
+		auditEvent: "workflow.gate.save_result",
+	},
+	{
+		canonicalName: "gsd_summary_save",
+		aliases: [],
+		schemaId: "workflow.summary.save",
+		executorId: "executeSummarySave",
+		writePolicy: "write",
+		auditEvent: "workflow.summary.save",
+	},
+	{
+		canonicalName: "gsd_task_complete",
+		aliases: ["gsd_complete_task"],
+		schemaId: "workflow.task.complete",
+		executorId: "executeTaskComplete",
+		writePolicy: "write",
+		auditEvent: "workflow.task.complete",
+	},
+	{
+		canonicalName: "gsd_milestone_status",
+		aliases: [],
+		schemaId: "workflow.milestone.status",
+		executorId: "executeMilestoneStatus",
+		writePolicy: "read",
+		auditEvent: "workflow.milestone.status",
+	},
+	{
+		canonicalName: "gsd_journal_query",
+		aliases: [],
+		schemaId: "workflow.journal.query",
+		executorId: "executeJournalQuery",
+		writePolicy: "read",
+		auditEvent: "workflow.journal.query",
+	},
+	{
+		canonicalName: "gsd_exec",
+		aliases: [],
+		schemaId: "workflow.exec.run",
+		executorId: "executeGsdExec",
+		writePolicy: "write",
+		auditEvent: "workflow.exec.run",
+	},
+	{
+		canonicalName: "gsd_exec_search",
+		aliases: [],
+		schemaId: "workflow.exec.search",
+		executorId: "executeGsdExecSearch",
+		writePolicy: "read",
+		auditEvent: "workflow.exec.search",
+	},
+	{
+		canonicalName: "gsd_resume",
+		aliases: [],
+		schemaId: "workflow.resume",
+		executorId: "executeGsdResume",
+		writePolicy: "read",
+		auditEvent: "workflow.resume",
+	},
+	{
+		canonicalName: "gsd_capture_thought",
+		aliases: [],
+		schemaId: "workflow.memory.capture_thought",
+		executorId: "executeCaptureThought",
+		writePolicy: "write",
+		auditEvent: "workflow.memory.capture_thought",
+	},
+	{
+		canonicalName: "gsd_memory_query",
+		aliases: [],
+		schemaId: "workflow.memory.query",
+		executorId: "executeMemoryQuery",
+		writePolicy: "read",
+		auditEvent: "workflow.memory.query",
+	},
+	{
+		canonicalName: "gsd_memory_graph",
+		aliases: [],
+		schemaId: "workflow.memory.graph",
+		executorId: "executeMemoryGraph",
+		writePolicy: "read",
+		auditEvent: "workflow.memory.graph",
+	},
+] as const satisfies readonly WorkflowToolContractMetadata[];
+
+export const WORKFLOW_TOOL_NAMES = WORKFLOW_TOOL_CONTRACTS.flatMap((tool) => [
+	tool.canonicalName,
+	...tool.aliases,
+]) as readonly string[];

package/packages/contracts/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2024",
+    "module": "Node16",
+    "lib": ["ES2024"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "incremental": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "inlineSources": true,
+    "inlineSourceMap": false,
+    "moduleResolution": "Node16",
+    "resolveJsonModule": true,
+    "allowImportingTsExtensions": false,
+    "types": ["node"],
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "**/*.d.ts", "src/**/*.d.ts"]
+}

package/packages/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gsd-build/daemon",
-  "version": "2.79.0",
+  "version": "2.80.0",
   "description": "GSD daemon — background process for project monitoring and Discord integration",
   "license": "MIT",
   "repository": {
@@ -29,7 +29,8 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.52.0",
-    "@gsd-build/rpc-client": "^2.79.0",
+    "@gsd-build/contracts": "^2.80.0",
+    "@gsd-build/rpc-client": "^2.80.0",
     "discord.js": "^14.25.1",
     "yaml": "^2.8.0",
     "zod": "^3.24.0"

package/packages/daemon/src/event-bridge.test.ts

@@ -12,7 +12,8 @@ import { EventEmitter } from 'node:events';
 import { EventBridge } from './event-bridge.js';
 import type { EventBridgeOptions, BridgeClient } from './event-bridge.js';
 import type { PendingBlocker, ManagedSession, DaemonConfig, SessionStatus } from './types.js';
-import type { SdkAgentEvent, RpcClient, RpcExtensionUIRequest } from '@gsd-build/rpc-client';
+import type { RpcClient } from '@gsd-build/rpc-client';
+import type { RpcExtensionUIRequest, SdkAgentEvent } from '@gsd-build/contracts';
 
 // ---------------------------------------------------------------------------
 // Mock factories

package/packages/daemon/src/event-bridge.ts

@@ -12,7 +12,7 @@
 
 import type { Client, Message, TextChannel, MessageComponentInteraction } from 'discord.js';
 import { EmbedBuilder, ComponentType } from 'discord.js';
-import type { SdkAgentEvent } from '@gsd-build/rpc-client';
+import type { SdkAgentEvent } from '@gsd-build/contracts';
 import type { Logger } from './logger.js';
 import type { DaemonConfig, PendingBlocker } from './types.js';
 import type { SessionManager } from './session-manager.js';

package/packages/daemon/src/event-formatter.test.ts

@@ -1,9 +1,8 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
 import { EmbedBuilder, ActionRowBuilder, ButtonBuilder } from 'discord.js';
-import type { SdkAgentEvent } from '@gsd-build/rpc-client';
+import type { RpcExtensionUIRequest, SdkAgentEvent } from '@gsd-build/contracts';
 import type { PendingBlocker, FormattedEvent } from './types.js';
-import type { RpcExtensionUIRequest } from '@gsd-build/rpc-client';
 import {
   formatToolStart,
   formatToolEnd,

package/packages/daemon/src/event-formatter.ts

@@ -11,8 +11,7 @@
  */
 
 import { EmbedBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle } from 'discord.js';
-import type { SdkAgentEvent } from '@gsd-build/rpc-client';
-import type { RpcExtensionUIRequest } from '@gsd-build/rpc-client';
+import type { RpcExtensionUIRequest, SdkAgentEvent } from '@gsd-build/contracts';
 import type { FormattedEvent, PendingBlocker } from './types.js';
 
 // ---------------------------------------------------------------------------

package/packages/daemon/src/session-manager.ts

@@ -17,7 +17,7 @@ import { execSync } from 'node:child_process';
 import { basename, resolve } from 'node:path';
 import { EventEmitter } from 'node:events';
 import { RpcClient } from '@gsd-build/rpc-client';
-import type { SdkAgentEvent, RpcInitResult, RpcCostUpdateEvent, RpcExtensionUIRequest } from '@gsd-build/rpc-client';
+import type { RpcCostUpdateEvent, RpcExtensionUIRequest, RpcInitResult, SdkAgentEvent } from '@gsd-build/contracts';
 import type {
   ManagedSession,
   StartSessionOptions,
@@ -387,7 +387,7 @@ function extractBlocker(event: SdkAgentEvent): PendingBlocker {
   const uiEvent = event as unknown as RpcExtensionUIRequest;
   return {
     id: String(uiEvent.id ?? ''),
-    method: String(uiEvent.method ?? ''),
+    method: uiEvent.method,
     message: String((uiEvent as Record<string, unknown>).title ?? (uiEvent as Record<string, unknown>).message ?? ''),
     event: uiEvent,
   };

package/packages/daemon/src/types.ts

@@ -1,4 +1,5 @@
-import type { RpcClient, SdkAgentEvent, RpcExtensionUIRequest } from '@gsd-build/rpc-client';
+import type { RpcClient } from '@gsd-build/rpc-client';
+import type { McpPendingBlocker as PendingBlocker, SdkAgentEvent } from '@gsd-build/contracts';
 
 /**
  * Log severity levels, ordered from most to least verbose.
@@ -100,23 +101,7 @@ export interface ManagedSession {
   unsubscribe?: () => void;
 }
 
-// ---------------------------------------------------------------------------
-// Pending Blocker
-// ---------------------------------------------------------------------------
-
-export interface PendingBlocker {
-  /** The extension_ui_request id */
-  id: string;
-
-  /** The request method (e.g. 'select', 'confirm', 'input') */
-  method: string;
-
-  /** Human-readable message or title */
-  message: string;
-
-  /** Full event payload for inspection */
-  event: RpcExtensionUIRequest;
-}
+export type { PendingBlocker };
 
 // ---------------------------------------------------------------------------
 // Cost Accumulator (K004 — cumulative-max)

package/packages/mcp-server/dist/server.d.ts

@@ -93,6 +93,17 @@ interface AskUserQuestionsRoundResult {
     endInterview: false;
     answers: Record<string, AskUserQuestionsRoundResultAnswer>;
 }
+interface AskUserQuestionsWriteGateModule {
+    isGateQuestionId(questionId: string): boolean;
+    isDepthConfirmationAnswer(selected: unknown, options?: Array<{
+        label?: string;
+    }>): boolean;
+    setPendingGate(gateId: string, basePath: string): void;
+    markApprovalGateVerified(gateId?: string | null, basePath?: string): void;
+    markDepthVerified(milestoneId?: string | null, basePath?: string): void;
+    clearPendingGate(basePath: string): void;
+    extractDepthVerificationMilestoneId(questionId: string): string | null;
+}
 export declare function buildAskUserQuestionsElicitRequest(questions: AskUserQuestion[]): AskUserQuestionsElicitRequest;
 export declare function formatAskUserQuestionsElicitResult(questions: AskUserQuestion[], result: AskUserQuestionsElicitResult): string;
 /**
@@ -107,6 +118,8 @@ interface AskUserQuestionsHandlerDeps {
     elicitInput(params: AskUserQuestionsElicitRequest): Promise<AskUserQuestionsElicitResult>;
     isRemoteConfigured(): boolean;
     tryRemoteQuestions(questions: AskUserQuestion[], signal?: AbortSignal): Promise<RemoteToolResult | null>;
+    writeGate?: AskUserQuestionsWriteGateModule | null;
+    writeGateBasePath?: string;
 }
 export declare function askUserQuestionsHandler(questions: AskUserQuestion[], extra: McpToolExtra | undefined, deps: AskUserQuestionsHandlerDeps): Promise<ToolContent>;
 export type ElicitInputFn = (params: {