@sayknow-cli/coding-agent 0.5.2 → 0.5.6

package/src/runtime-mcp/transports/stdio.ts

@@ -24,6 +24,12 @@ import { MCPExpectedFailure, toJsonRpcError } from "../../runtime-mcp/types";
  */
 const CLOSE_WAIT_MS = 1_000;
 
+/** Write one JSONL frame while honoring Bun FileSink backpressure and flush failures. */
+export async function writeStdioFrame(stdin: Bun.FileSink, message: string): Promise<void> {
+	await Promise.resolve(stdin.write(message));
+	await stdin.flush();
+}
+
 /**
  * Build a minimal environment for a no-inherit stdio MCP child. Only OS-level
  * keys needed to locate/run an interpreter (PATH, HOME, temp, locale, and the
@@ -69,6 +75,9 @@ export class StdioTransport implements MCPTransport {
 	#readLoop: Promise<void> | null = null;
 	#stderrLoop: Promise<void> | null = null;
 	#closePromise: Promise<void> | null = null;
+	#writeQueue: Promise<void> = Promise.resolve();
+	#connectionEpoch = 0;
+	#terminalFailure: { epoch: number; error: MCPExpectedFailure } | undefined;
 
 	onClose?: () => void;
 	onError?: (error: Error) => void;
@@ -115,6 +124,8 @@ export class StdioTransport implements MCPTransport {
 			throw new MCPExpectedFailure(error);
 		}
 
+		this.#connectionEpoch++;
+		this.#terminalFailure = undefined;
 		this.#connected = true;
 
 		// Start reading stdout
@@ -126,6 +137,7 @@ export class StdioTransport implements MCPTransport {
 
 	async #startReadLoop(): Promise<void> {
 		if (!this.#process?.child.stdout) return;
+		const epoch = this.#connectionEpoch;
 		let failure: MCPExpectedFailure | undefined;
 		try {
 			for await (const line of readJsonl(this.#process.child.stdout)) {
@@ -138,11 +150,12 @@ export class StdioTransport implements MCPTransport {
 			}
 		} catch (error) {
 			failure = new MCPExpectedFailure(error);
-			if (this.#connected) {
-				this.onError?.(failure);
-			}
 		} finally {
-			this.#handleClose(failure);
+			if (failure) {
+				this.#terminalizeFailure(failure, epoch);
+			} else {
+				this.#handleClose();
+			}
 		}
 	}
 
@@ -177,7 +190,10 @@ export class StdioTransport implements MCPTransport {
 		}
 		// Server-to-client request: has both method and id
 		if ("method" in message && "id" in message && message.id != null) {
-			void this.#handleServerRequest(message as JsonRpcRequest);
+			const stdin = this.#getStdin();
+			if (stdin) {
+				void this.#handleServerRequest(message as JsonRpcRequest, this.#connectionEpoch, stdin);
+			}
 			return;
 		}
 
@@ -211,21 +227,23 @@ export class StdioTransport implements MCPTransport {
 		}
 	}
 
-	async #handleServerRequest(request: JsonRpcRequest): Promise<void> {
+	async #handleServerRequest(request: JsonRpcRequest, epoch: number, stdin: Bun.FileSink): Promise<void> {
+		if (!this.onRequest) {
+			await this.#sendResponseOrClose(request.id, epoch, stdin, undefined, {
+				code: -32601,
+				message: "Method not found",
+			});
+			return;
+		}
+
+		let result: unknown;
 		try {
-			if (!this.onRequest) {
-				this.#sendResponse(request.id, undefined, { code: -32601, message: "Method not found" });
-				return;
-			}
-			const result = await this.onRequest(request.method, request.params);
-			this.#sendResponse(request.id, result);
+			result = await this.onRequest(request.method, request.params);
 		} catch (error) {
-			try {
-				this.#sendResponse(request.id, undefined, toJsonRpcError(error));
-			} catch {
-				// Best-effort — process may have exited
-			}
+			await this.#sendResponseOrClose(request.id, epoch, stdin, undefined, toJsonRpcError(error));
+			return;
 		}
+		await this.#sendResponseOrClose(request.id, epoch, stdin, result);
 	}
 
 	#getStdin(): Bun.FileSink | null {
@@ -233,28 +251,70 @@ export class StdioTransport implements MCPTransport {
 		return typeof stdin === "object" && stdin !== null ? stdin : null;
 	}
 
-	#sendResponse(id: string | number, result?: unknown, error?: JsonRpcError): void {
-		const stdin = this.#getStdin();
-		if (!this.#connected || !stdin) return;
+	async #sendResponse(
+		id: string | number,
+		epoch: number,
+		stdin: Bun.FileSink,
+		result?: unknown,
+		error?: JsonRpcError,
+	): Promise<void> {
 		const response = error
 			? { jsonrpc: "2.0" as const, id, error }
 			: { jsonrpc: "2.0" as const, id, result: result ?? {} };
-		stdin.write(`${JSON.stringify(response)}\n`);
-		stdin.flush();
+		await this.#queueWriteFrame(stdin, `${JSON.stringify(response)}\n`, epoch);
+	}
+
+	#queueWriteFrame(stdin: Bun.FileSink, message: string, epoch: number): Promise<void> {
+		const write = this.#writeQueue
+			.catch(() => {})
+			.then(() => {
+				if (!this.#connected || this.#connectionEpoch !== epoch || this.#getStdin() !== stdin) {
+					throw this.#terminalFailure?.epoch === epoch ? this.#terminalFailure.error : new MCPExpectedFailure();
+				}
+				return writeStdioFrame(stdin, message);
+			});
+		this.#writeQueue = write.catch(() => {});
+		return write;
+	}
+
+	async #sendResponseOrClose(
+		id: string | number,
+		epoch: number,
+		stdin: Bun.FileSink,
+		result?: unknown,
+		error?: JsonRpcError,
+	): Promise<void> {
+		try {
+			await this.#sendResponse(id, epoch, stdin, result, error);
+		} catch (writeError) {
+			this.#terminalizeFailure(writeError, epoch);
+		}
 	}
 
 	#handleClose(failure?: MCPExpectedFailure): void {
 		void this.#closeInternal(true, failure);
 	}
 
+	#terminalizeFailure(error: unknown, epoch: number): MCPExpectedFailure {
+		const existing = this.#terminalFailure;
+		if (existing?.epoch === epoch) return existing.error;
+		const failure = error instanceof MCPExpectedFailure ? error : new MCPExpectedFailure(error);
+		if (epoch !== this.#connectionEpoch) return failure;
+		this.#terminalFailure = { epoch, error: failure };
+		this.onError?.(failure);
+		this.#handleClose(failure);
+		return failure;
+	}
+
 	async request<T = unknown>(
 		method: string,
 		params?: Record<string, unknown>,
 		options?: MCPRequestOptions,
 	): Promise<T> {
 		const stdin = this.#getStdin();
+		const epoch = this.#connectionEpoch;
 		if (!this.#connected || !stdin) {
-			throw new MCPExpectedFailure();
+			throw this.#terminalFailure?.epoch === epoch ? this.#terminalFailure.error : new MCPExpectedFailure();
 		}
 
 		const id = Snowflake.next();
@@ -318,12 +378,10 @@ export class StdioTransport implements MCPTransport {
 
 		const message = `${JSON.stringify(request)}\n`;
 		try {
-			// Bun's FileSink has write() method directly
-			stdin.write(message);
-			stdin.flush();
+			await this.#queueWriteFrame(stdin, message, epoch);
 		} catch (error: unknown) {
 			cleanup();
-			reject(new MCPExpectedFailure(error));
+			reject(this.#terminalizeFailure(error, epoch));
 		}
 
 		return promise;
@@ -331,8 +389,9 @@ export class StdioTransport implements MCPTransport {
 
 	async notify(method: string, params?: Record<string, unknown>): Promise<void> {
 		const stdin = this.#getStdin();
+		const epoch = this.#connectionEpoch;
 		if (!this.#connected || !stdin) {
-			throw new MCPExpectedFailure();
+			throw this.#terminalFailure?.epoch === epoch ? this.#terminalFailure.error : new MCPExpectedFailure();
 		}
 
 		const notification = {
@@ -343,16 +402,20 @@ export class StdioTransport implements MCPTransport {
 
 		const message = `${JSON.stringify(notification)}\n`;
 		try {
-			// Bun's FileSink has write() method directly
-			stdin.write(message);
-			stdin.flush();
+			await this.#queueWriteFrame(stdin, message, epoch);
 		} catch (error) {
-			throw new MCPExpectedFailure(error);
+			throw this.#terminalizeFailure(error, epoch);
 		}
 	}
 
 	async close(): Promise<void> {
-		await this.#closeInternal(false);
+		const epoch = this.#connectionEpoch;
+		let failure = this.#terminalFailure?.epoch === epoch ? this.#terminalFailure.error : undefined;
+		if (!failure) {
+			failure = new MCPExpectedFailure();
+			this.#terminalFailure = { epoch, error: failure };
+		}
+		await this.#closeInternal(false, failure);
 	}
 
 	#closeInternal(fromReadLoop: boolean, failure?: MCPExpectedFailure): Promise<void> {

package/src/sdk/broker/lifecycle.ts

@@ -25,7 +25,8 @@ import {
 } from "../../session/session-storage";
 import {
 	ensureLaunchWorktree,
-	ensureReusableNodeModules,
+	ensureLaunchWorktreeDependencies,
+	launchWorktreeCwd,
 	planLaunchWorktree,
 	type SkcLaunchWorktreePlan,
 } from "../../skc-runtime/launch-worktree";
@@ -656,7 +657,7 @@ async function validateLiveResumeScope(
 					: { enabled: true, detached: true, name: null },
 			);
 			if (!planned.enabled) return fail("invalid_input", "Lifecycle worktree target is invalid.");
-			cwd = path.resolve(planned.worktreePath);
+			cwd = launchWorktreeCwd(planned);
 		} catch (error) {
 			return fail(
 				"invalid_input",
@@ -2338,7 +2339,7 @@ function preparePlannedWorktree(plan: SkcLaunchWorktreePlan): SessionLifecycleWo
 		throw new Error("Lifecycle worktree preparation did not preserve the durable worktree identity.");
 	return {
 		enabled: true,
-		cwd: path.resolve(prepared.worktreePath),
+		cwd: launchWorktreeCwd(prepared),
 		created: prepared.created,
 		reused: prepared.reused,
 		...(prepared.branchName ? { branch: prepared.branchName } : {}),
@@ -2377,7 +2378,7 @@ async function launchInput(
 			);
 			if (!planned.enabled) return fail("invalid_input", "Lifecycle worktree target is invalid.");
 			worktreePlan = planned;
-			cwd = path.resolve(planned.worktreePath);
+			cwd = launchWorktreeCwd(planned);
 		} catch (error) {
 			return fail(
 				"invalid_input",
@@ -2867,7 +2868,7 @@ async function executeLifecycleResponse(
 					digest: createHash("sha256").update(canonicalJson({ worktree })).digest("hex"),
 				};
 				await broker.ledger.transition(identity, "effect_started", { durableEffects });
-				ensureReusableNodeModules(launch.worktreePlan.repoRoot, launch.worktreePlan.worktreePath);
+				ensureLaunchWorktreeDependencies(launch.worktreePlan);
 			}
 		} catch (error) {
 			return fail(

package/src/sdk/protocol/operation-inventory.generated.json

@@ -1825,6 +1825,17 @@
 			"packages/coding-agent/test/sdk-operation-inventory.test.ts"
 		]
 	},
+	{
+		"sourceId": "slash_command:import-session",
+		"sourceFile": "packages/coding-agent/src/slash-commands/builtin-registry.ts",
+		"sourceKind": "slash_command",
+		"decision": "exclude",
+		"rationale": "local transcript-file import into a new session; ACP is explicitly disabled and no SDK operation reads caller-selected host paths",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
 	{
 		"sourceId": "slash_command:copy",
 		"sourceFile": "packages/coding-agent/src/slash-commands/builtin-registry.ts",
@@ -2870,6 +2881,17 @@
 			"testIds": "not_applicable"
 		}
 	},
+	{
+		"sourceId": "agent_session:hasExplicitlyDisabledTools",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "internal automatic-tool-selection predicate, not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
 	{
 		"sourceId": "agent_session:setActiveToolsByName",
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
@@ -4317,6 +4339,17 @@
 			"testIds": "not_applicable"
 		}
 	},
+	{
+		"sourceId": "agent_session:runPrePromptContextCheckForTests",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "test-only context check seam, not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
 	{
 		"sourceId": "agent_session:setRetainedMemorySampler",
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",

package/src/sdk/session.ts

@@ -2272,13 +2272,14 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			};
 		};
 
+		const explicitlyDisabledTools = options.toolNames?.length === 0;
 		const toolNamesFromRegistry = Array.from(toolRegistry.keys());
 		const hasExplicitToolNames = options.toolNames !== undefined;
 		const requestedToolNames = hasExplicitToolNames
 			? [
 					...new Set([
 						...options.toolNames!.map(name => name.toLowerCase()),
-						...(settings.get("goal.enabled") ? ["goal"] : []),
+						...(settings.get("goal.enabled") && !explicitlyDisabledTools ? ["goal"] : []),
 					]),
 				]
 			: toolNamesFromRegistry;
@@ -2298,7 +2299,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			registeredTools.filter(tool => tool.definition.defaultInactive).map(tool => tool.definition.name),
 		);
 		const requestedActiveToolNames = normalizedRequested;
-		const initialRequestedActiveToolNames = options.toolNames
+		const initialRequestedActiveToolNames = hasExplicitToolNames
 			? requestedActiveToolNames
 			: requestedActiveToolNames.filter(name => !defaultInactiveToolNames.has(name));
 		const discoverableMCPToolNames = new Set<string>();
@@ -2348,11 +2349,13 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			];
 			hasExplicitMCPToolSelection =
 				hasExplicitToolNames && (options.toolNames!.length === 0 || selectableExplicitMCPToolNames.length > 0);
-			initialSelectedMCPToolNames = existingSession.hasPersistedMCPToolSelection
-				? restoredSelectedMCPToolNames
-				: hasExplicitMCPToolSelection
-					? selectableExplicitMCPToolNames
-					: defaultSelectedMCPToolNames;
+			initialSelectedMCPToolNames = explicitlyDisabledTools
+				? []
+				: existingSession.hasPersistedMCPToolSelection
+					? restoredSelectedMCPToolNames
+					: hasExplicitMCPToolSelection
+						? selectableExplicitMCPToolNames
+						: defaultSelectedMCPToolNames;
 			initialToolNames = [
 				...new Set([
 					...initialRequestedActiveToolNames.filter(name => !discoverableMCPToolNames.has(name)),
@@ -2361,14 +2364,15 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			];
 		}
 
-		// Custom, extension-registered, and plugin-bundle MCP tools are always
-		// included regardless of the caller's built-in tool filter. Plugin MCPs
-		// remain always-on even when generic MCP discovery is disabled.
-		const alwaysInclude: string[] = [
-			...(options.customTools?.map(t => (isCustomTool(t) ? t.name : t.name)) ?? []),
-			...registeredTools.filter(t => !t.definition.defaultInactive).map(t => t.definition.name),
-			...pluginMcpToolNames,
-		];
+		// Custom, extension-registered, and plugin-bundle MCP tools bypass
+		// built-in filtering, but not an explicit zero-tool selection.
+		const alwaysInclude: string[] = explicitlyDisabledTools
+			? []
+			: [
+					...(options.customTools?.map(t => (isCustomTool(t) ? t.name : t.name)) ?? []),
+					...registeredTools.filter(t => !t.definition.defaultInactive).map(t => t.definition.name),
+					...pluginMcpToolNames,
+				];
 		const pluginMcpToolNameSet = new Set(pluginMcpToolNames);
 		for (const name of alwaysInclude) {
 			if (mcpDiscoveryEnabled && discoverableMCPToolNames.has(name) && !pluginMcpToolNameSet.has(name)) {
@@ -2414,9 +2418,11 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				allowedDiscoveredBuiltinNames,
 				essentialBuiltinNames,
 			);
-			initialSelectedDiscoveredBuiltinToolNames = existingSession.hasPersistedDiscoveredBuiltinToolSelection
-				? restoredDiscoveredNames
-				: explicitlyRequestedDiscoveredBuiltinToolNames;
+			initialSelectedDiscoveredBuiltinToolNames = explicitlyDisabledTools
+				? []
+				: existingSession.hasPersistedDiscoveredBuiltinToolSelection
+					? restoredDiscoveredNames
+					: explicitlyRequestedDiscoveredBuiltinToolNames;
 			initialToolNames = [...new Set([...baselineInitialToolNames, ...initialSelectedDiscoveredBuiltinToolNames])];
 			hasExplicitDiscoveredBuiltinToolSelection =
 				hasExplicitToolNames &&
@@ -2717,6 +2723,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			workspaceTree: resolvedWorkspaceTree,
 			reloadSshTool,
 			requestedToolNames: requestedToolNameSet,
+			explicitlyDisabledTools,
 			discoverableToolAllowedNames: options.discoverableToolAllowedNames,
 			mcpDiscoveryEnabled,
 			discoveryMode: effectiveDiscoveryMode,