@gajae-code/coding-agent 0.3.2 → 0.4.1

package/src/prompts/system/system-prompt.md

@@ -69,6 +69,13 @@ Use for read-only plan critique. It approves only when execution can proceed wit
 - Before explicit execution approval, planning workflows NEVER edit product source, run mutation-oriented shell commands, commit, push, open PRs, or delegate implementation tasks.
 </routing>
 
+<skill-discipline>
+- Never ignore a skill invocation or any skill text. When a skill is active, read it in full and follow its instructions exactly. Do not assume, paraphrase, reorder, or substitute steps.
+- Read-only and interview-style skills (e.g. `deep-interview`, `planner`, `architect`, `critic`) MUST NOT implement, edit product source, commit, or run mutating commands. Honor each skill's read-only or pending-approval boundary even when the fix looks obvious.
+- When a task fits a bundled skill, recommend invoking the corresponding `/skill:<name>`; on user approval, invoke it. Never silently bypass an applicable skill.
+- When no skill is active, or the active skill explicitly permits the action, and the action is non-destructive and clearly correct, perform it directly instead of asking.
+</skill-discipline>
+
 <runtime-state>
 - Runtime state, specs, plans, and workflow ledgers belong under `.gjc/`.
 - Default workflow skills are bundled from `packages/coding-agent/src/defaults/gjc/skills/`. Runtime user/project `.gjc` discovery remains supported, but committed repo-visible `.gjc` defaults are not the source of truth.
@@ -82,6 +89,8 @@ Use for read-only plan critique. It approves only when execution can proceed wit
 - Do not narrate progress, ceremony, timing, scope inflation, or session limits.
 - If the user's intent is clear, act without asking. Ask only when the next step is destructive or requires a missing choice that materially changes the outcome.
 - When the user proposes something wrong, say what breaks and what to do instead once; then defer to their call.
+- Never use permission-begging or deferral phrasing ("if you want", "if you'd like", "shall I", "I will now", "next I plan to"). For a destructive next step, state the recommended action and stop for approval. For a non-destructive, clearly correct next step, do it directly in the same turn.
+- Do not defer actionable work. Underpromise and overdeliver: report only what is done or in progress, never announce remaining work instead of doing it.
 </communication>
 
 <completion-contract>

package/src/runtime-mcp/client.ts

@@ -141,6 +141,8 @@ export async function connectToServer(
 ): Promise<MCPServerConnection> {
 	const timeoutMs = config.timeout ?? CONNECTION_TIMEOUT_MS;
 	let transport: MCPTransport | undefined;
+	const connectAbort = new AbortController();
+	const connectSignal = options?.signal ? AbortSignal.any([options.signal, connectAbort.signal]) : connectAbort.signal;
 
 	const connect = async (): Promise<MCPServerConnection> => {
 		transport = await createTransport(config);
@@ -155,7 +157,7 @@ export async function connectToServer(
 
 		try {
 			const initResult = await initializeConnection(transport, {
-				signal: options?.signal,
+				signal: connectSignal,
 				async onInitialized() {
 					// Open the SSE stream before sending initialized, so server-to-client
 					// requests triggered by on_initialized (e.g. roots/list) are delivered.
@@ -184,13 +186,14 @@ export async function connectToServer(
 			connect(),
 			timeoutMs,
 			`Connection to MCP server "${name}" timed out after ${timeoutMs}ms`,
-			options?.signal,
+			connectSignal,
 		);
 	} catch (error) {
 		// If withTimeout rejected (timeout/abort) while connect() was still pending,
-		// the transport may be alive with an open SSE listener. Close it.
+		// abort initialization and wait for transport cleanup before returning.
+		connectAbort.abort(error);
 		if (transport) {
-			void transport.close().catch(() => {});
+			await transport.close().catch(() => {});
 		}
 		throw error;
 	}

package/src/runtime-mcp/manager.ts

@@ -152,6 +152,7 @@ export class MCPManager {
 	#connections = new Map<string, MCPServerConnection>();
 	#tools: CustomTool<TSchema, MCPToolDetails>[] = [];
 	#pendingConnections = new Map<string, Promise<MCPServerConnection>>();
+	#pendingConnectionControllers = new Map<string, AbortController>();
 	#pendingToolLoads = new Map<string, Promise<ToolLoadResult>>();
 	#sources = new Map<string, SourceMeta>();
 	#authStorage: AuthStorage | null = null;
@@ -164,6 +165,7 @@ export class MCPManager {
 	#subscribedResources = new Map<string, Set<string>>();
 	#pendingResourceRefresh = new Map<string, { connection: MCPServerConnection; promise: Promise<void> }>();
 	#pendingReconnections = new Map<string, Promise<MCPServerConnection | null>>();
+	#disconnectEpochs = new Map<string, number>();
 	/** Preserved configs for reconnection after connection loss. */
 	#serverConfigs = new Map<string, MCPServerConfig>();
 	/** Monotonic epoch incremented on disconnectAll to invalidate stale reconnections. */
@@ -348,10 +350,14 @@ export class MCPManager {
 			// and falls back to cached/deferred tools.
 			this.#serverConfigs.set(name, config);
 
+			const connectionEpoch = this.#epoch;
+			const connectionAbort = new AbortController();
+			this.#pendingConnectionControllers.set(name, connectionAbort);
 			// Resolve auth config before connecting, but do so per-server in parallel.
 			const connectionPromise = (async () => {
 				const resolvedConfig = await this.#resolveAuthConfig(config);
 				return connectToServer(name, resolvedConfig, {
+					signal: connectionAbort.signal,
 					onNotification: (method, params) => {
 						this.#handleServerNotification(name, method, params);
 					},
@@ -360,18 +366,26 @@ export class MCPManager {
 					},
 				});
 			})().then(
-				connection => {
+				async connection => {
 					// Store original config (without resolved tokens) to keep
 					// cache keys stable and avoid leaking rotating credentials.
 					connection.config = config;
-					this.#serverConfigs.set(name, config);
 					if (sources[name]) {
 						connection._source = sources[name];
 					}
-					if (this.#pendingConnections.get(name) === connectionPromise) {
+					const stillPending = this.#pendingConnections.get(name) === connectionPromise;
+					const stillCurrent = this.#epoch === connectionEpoch && this.#serverConfigs.get(name) === config;
+					if (stillPending) {
 						this.#pendingConnections.delete(name);
-						this.#connections.set(name, connection);
+						this.#pendingConnectionControllers.delete(name);
 					}
+					if (!stillPending || !stillCurrent) {
+						connection.transport.onClose = undefined;
+						await connection.transport.close().catch(() => {});
+						throw new Error(`Server "${name}" was disconnected during connection`);
+					}
+					this.#connections.set(name, connection);
+					this.#serverConfigs.set(name, config);
 
 					// Wire auth refresh for HTTP transports so 401s trigger token refresh.
 					if (connection.transport instanceof HttpTransport && config.auth?.type === "oauth") {
@@ -396,6 +410,7 @@ export class MCPManager {
 				error => {
 					if (this.#pendingConnections.get(name) === connectionPromise) {
 						this.#pendingConnections.delete(name);
+						this.#pendingConnectionControllers.delete(name);
 					}
 					throw error;
 				},
@@ -660,13 +675,16 @@ export class MCPManager {
 	 * Disconnect from a specific server.
 	 */
 	async disconnectServer(name: string): Promise<void> {
+		const nextEpoch = (this.#disconnectEpochs.get(name) ?? 0) + 1;
+		this.#disconnectEpochs.set(name, nextEpoch);
+		this.#pendingConnectionControllers.get(name)?.abort(new Error(`MCP server disconnected: ${name}`));
+		this.#pendingConnectionControllers.delete(name);
 		this.#pendingConnections.delete(name);
 		this.#pendingToolLoads.delete(name);
 		this.#pendingReconnections.delete(name);
 		this.#sources.delete(name);
 		this.#serverConfigs.delete(name);
 		this.#pendingResourceRefresh.delete(name);
-
 		const connection = this.#connections.get(name);
 
 		const subscribedUris = this.#subscribedResources.get(name);
@@ -705,6 +723,10 @@ export class MCPManager {
 		const promises = Array.from(this.#connections.values()).map(conn => disconnectServer(conn));
 		await Promise.allSettled(promises);
 
+		for (const controller of this.#pendingConnectionControllers.values()) {
+			controller.abort(new Error("MCP manager disconnected"));
+		}
+		this.#pendingConnectionControllers.clear();
 		this.#pendingConnections.clear();
 		this.#pendingToolLoads.clear();
 		this.#pendingReconnections.clear();
@@ -808,14 +830,24 @@ export class MCPManager {
 		reconnectEpoch: number,
 	): Promise<MCPServerConnection> {
 		const resolvedConfig = await this.#resolveAuthConfig(config);
-		const connection = await connectToServer(name, resolvedConfig, {
-			onNotification: (method, params) => {
-				this.#handleServerNotification(name, method, params);
-			},
-			onRequest: (method, params) => {
-				return this.#handleServerRequest(method, params);
-			},
-		});
+		const connectionAbort = new AbortController();
+		this.#pendingConnectionControllers.set(name, connectionAbort);
+		let connection: MCPServerConnection;
+		try {
+			connection = await connectToServer(name, resolvedConfig, {
+				signal: connectionAbort.signal,
+				onNotification: (method, params) => {
+					this.#handleServerNotification(name, method, params);
+				},
+				onRequest: (method, params) => {
+					return this.#handleServerRequest(method, params);
+				},
+			});
+		} finally {
+			if (this.#pendingConnectionControllers.get(name) === connectionAbort) {
+				this.#pendingConnectionControllers.delete(name);
+			}
+		}
 
 		connection.config = config;
 		if (source) connection._source = source;

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

@@ -25,6 +25,8 @@ export class HttpTransport implements MCPTransport {
 	#connected = false;
 	#sessionId: string | null = null;
 	#sseConnection: AbortController | null = null;
+	#streamControllers = new Set<AbortController>();
+	#streamReaders = new Set<Promise<void>>();
 
 	onClose?: () => void;
 	onError?: (error: Error) => void;
@@ -52,6 +54,15 @@ export class HttpTransport implements MCPTransport {
 		this.#connected = true;
 	}
 
+	#trackReader(promise: Promise<void>, controller?: AbortController): void {
+		if (controller) this.#streamControllers.add(controller);
+		this.#streamReaders.add(promise);
+		void promise.finally(() => {
+			this.#streamReaders.delete(promise);
+			if (controller) this.#streamControllers.delete(controller);
+		});
+	}
+
 	/**
 	 * Start SSE listener for server-initiated messages.
 	 * Resolves once the SSE connection is established (or fails/unsupported).
@@ -61,7 +72,8 @@ export class HttpTransport implements MCPTransport {
 		if (!this.#connected) return;
 		if (this.#sseConnection) return;
 
-		this.#sseConnection = new AbortController();
+		const sseConnection = new AbortController();
+		this.#sseConnection = sseConnection;
 		const headers: Record<string, string> = {
 			Accept: "text/event-stream",
 			...this.config.headers,
@@ -76,10 +88,10 @@ export class HttpTransport implements MCPTransport {
 			response = await fetch(this.config.url, {
 				method: "GET",
 				headers,
-				signal: this.#sseConnection.signal,
+				signal: sseConnection.signal,
 			});
 		} catch (error) {
-			this.#sseConnection = null;
+			this.#sseConnection = this.#sseConnection === sseConnection ? null : this.#sseConnection;
 			if (error instanceof Error && error.name !== "AbortError") {
 				this.onError?.(error);
 			}
@@ -87,19 +99,20 @@ export class HttpTransport implements MCPTransport {
 		}
 
 		if (response.status === 405 || !response.ok || !response.body) {
-			this.#sseConnection = null;
+			this.#sseConnection = this.#sseConnection === sseConnection ? null : this.#sseConnection;
 			return;
 		}
 
 		// Connection established — read messages in background.
 		// If the stream ends unexpectedly (server restart, network drop),
 		// fire onClose so the manager can trigger reconnection.
-		const signal = this.#sseConnection.signal;
-		void this.#readSSEStream(response.body!, signal).finally(() => {
+		const signal = sseConnection.signal;
+		const reader = this.#readSSEStream(response.body!, signal).finally(() => {
 			const wasConnected = this.#connected;
-			this.#sseConnection = null;
-			if (wasConnected) this.onClose?.();
+			if (this.#sseConnection === sseConnection) this.#sseConnection = null;
+			if (wasConnected && !signal.aborted) this.onClose?.();
 		});
+		this.#trackReader(reader, sseConnection);
 	}
 	async #readSSEStream(body: ReadableStream<Uint8Array>, signal: AbortSignal): Promise<void> {
 		try {
@@ -266,6 +279,8 @@ export class HttpTransport implements MCPTransport {
 		// Re-reading `response.body` after `for await` breaks would lock the
 		// stream a second time and surface as "ReadableStream already has a
 		// controller", so we must not exit the loop early.
+		const drainController = abortController;
+		this.#streamControllers.add(drainController);
 		const drain = async (): Promise<void> => {
 			try {
 				for await (const raw of readSseJson<JsonRpcMessage | JsonRpcMessage[]>(response.body!, operationSignal)) {
@@ -306,10 +321,11 @@ export class HttpTransport implements MCPTransport {
 				}
 			} finally {
 				clearTimeout(timeoutId);
+				this.#streamControllers.delete(drainController);
 			}
 		};
 
-		void drain();
+		this.#trackReader(drain());
 		return promise;
 	}
 
@@ -417,9 +433,13 @@ export class HttpTransport implements MCPTransport {
 			// on the notification response (MCP Streamable HTTP spec). Read them.
 			const contentType = response.headers.get("Content-Type") ?? "";
 			if (contentType.includes("text/event-stream") && response.body) {
-				// Use the SSE connection's signal if available, otherwise read until stream ends
-				const signal = this.#sseConnection?.signal ?? AbortSignal.timeout(this.config.timeout ?? 30000);
-				void this.#readSSEStream(response.body, signal);
+				const streamController = new AbortController();
+				const streamTimeout = AbortSignal.timeout(this.config.timeout ?? 30000);
+				const signals = this.#sseConnection
+					? [this.#sseConnection.signal, streamController.signal, streamTimeout]
+					: [streamController.signal, streamTimeout];
+				const reader = this.#readSSEStream(response.body, AbortSignal.any(signals));
+				this.#trackReader(reader, streamController);
 			} else {
 				await response.body?.cancel();
 			}
@@ -433,14 +453,20 @@ export class HttpTransport implements MCPTransport {
 	}
 
 	async close(): Promise<void> {
-		if (!this.#connected) return;
+		const wasConnected = this.#connected;
 		this.#connected = false;
 
-		// Abort SSE listener
+		// Abort all SSE/background readers and wait for them to settle.
+		for (const controller of this.#streamControllers) {
+			controller.abort();
+		}
 		if (this.#sseConnection) {
 			this.#sseConnection.abort();
 			this.#sseConnection = null;
 		}
+		await Promise.allSettled(Array.from(this.#streamReaders));
+
+		if (!wasConnected && !this.#sessionId) return;
 
 		// Send session termination if we have a session
 		if (this.#sessionId) {

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

@@ -5,8 +5,7 @@
  * Messages are newline-delimited JSON.
  */
 
-import { getProjectDir, readJsonl, Snowflake } from "@gajae-code/utils";
-import { type Subprocess, spawn } from "bun";
+import { getProjectDir, ptree, readJsonl, Snowflake } from "@gajae-code/utils";
 import type {
 	JsonRpcError,
 	JsonRpcMessage,
@@ -22,8 +21,10 @@ import { toJsonRpcError } from "../../runtime-mcp/types";
  * Stdio transport for MCP servers.
  * Spawns a subprocess and communicates via stdin/stdout.
  */
+const CLOSE_WAIT_MS = 1_000;
+
 export class StdioTransport implements MCPTransport {
-	#process: Subprocess<"pipe", "pipe", "pipe"> | null = null;
+	#process: ptree.ChildProcess<"pipe"> | null = null;
 	#pendingRequests = new Map<
 		string | number,
 		{
@@ -57,13 +58,11 @@ export class StdioTransport implements MCPTransport {
 			...this.config.env,
 		};
 
-		this.#process = spawn({
-			cmd: [this.config.command, ...args],
+		this.#process = ptree.spawn([this.config.command, ...args], {
 			cwd: this.config.cwd ?? getProjectDir(),
 			env,
 			stdin: "pipe",
-			stdout: "pipe",
-			stderr: "pipe",
+			stderr: "full",
 		});
 
 		this.#connected = true;
@@ -299,9 +298,11 @@ export class StdioTransport implements MCPTransport {
 		}
 		this.#pendingRequests.clear();
 
-		// Kill subprocess
-		if (this.#process) {
-			this.#process.kill();
+		// Terminate the subprocess tree and keep the handle until exit is observed.
+		const process = this.#process;
+		if (process) {
+			process.kill();
+			await Promise.race([process.exited.catch(() => {}), Bun.sleep(CLOSE_WAIT_MS)]);
 			this.#process = null;
 		}
 

package/src/sdk.ts

@@ -68,6 +68,8 @@ import {
 	wrapRegisteredTools,
 } from "./extensibility/extensions";
 import { ExtensionRuntime } from "./extensibility/extensions/loader";
+import { resolveCurrentPhaseForParent } from "./extensibility/gjc-plugins/injection";
+import { loadActiveSubskillTools } from "./extensibility/gjc-plugins/tools";
 import { loadSkills, type Skill, type SkillWarning, setActiveSkills } from "./extensibility/skills";
 import type { FileSlashCommand } from "./extensibility/slash-commands";
 import type { HindsightSessionState } from "./hindsight/state";
@@ -243,6 +245,8 @@ export interface CreateAgentSessionOptions {
 
 	/** Custom tools to register (in addition to built-in tools). Accepts both CustomTool and ToolDefinition. */
 	customTools?: (CustomTool | ToolDefinition)[];
+	/** Explicit parent/phase used to load active GJC sub-skill tools for this session. */
+	gjcSubskillToolContext?: { parent: string; phase: string; sessionId?: string; cwd?: string };
 	/** Inline extensions (merged with discovery). */
 	extensions?: ExtensionFactory[];
 	/** Additional extension paths to load (merged with discovery). */
@@ -1183,6 +1187,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			getActiveModelString,
 			getPlanModeState: () => session?.getPlanModeState(),
 			getGoalModeState: () => session?.getGoalModeState(),
+			getWorkflowGateEmitter: () => session?.getWorkflowGateEmitter(),
 			getGoalRuntime: () => session?.goalRuntime,
 			getClientBridge: () => session?.clientBridge,
 			getCompactContext: () => session.formatCompactContext(),
@@ -1281,6 +1286,47 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			customTools.push(...getSearchTools());
 		}
 
+		const getReservedSubskillToolNames = () => [
+			...new Set([
+				...builtinTools.map(tool => tool.name),
+				...(options.toolNames?.map(name => name.toLowerCase()) ?? []),
+				...(options.customTools?.map(tool => (isCustomTool(tool) ? tool.name : tool.name)) ?? []),
+				...customTools.map(tool => tool.name),
+			]),
+		];
+
+		const gjcSubskillToolContext = options.gjcSubskillToolContext;
+		if (gjcSubskillToolContext?.parent.trim() && gjcSubskillToolContext.phase.trim()) {
+			const pluginTools = await loadActiveSubskillTools({
+				cwd: gjcSubskillToolContext.cwd ?? cwd,
+				sessionId: gjcSubskillToolContext.sessionId ?? logicalSessionId,
+				parent: gjcSubskillToolContext.parent,
+				phase: gjcSubskillToolContext.phase,
+				reservedToolNames: getReservedSubskillToolNames(),
+			});
+			if (pluginTools.length > 0) {
+				customTools.push(...pluginTools);
+			}
+		} else {
+			for (const skill of skills) {
+				const phase = await resolveCurrentPhaseForParent({
+					cwd,
+					sessionId: logicalSessionId,
+					parent: skill.name,
+				});
+				const pluginTools = await loadActiveSubskillTools({
+					cwd,
+					sessionId: logicalSessionId,
+					parent: skill.name,
+					phase,
+					reservedToolNames: getReservedSubskillToolNames(),
+				});
+				if (pluginTools.length > 0) {
+					customTools.push(...pluginTools);
+				}
+			}
+		}
+
 		// Custom tool and extension discovery is quarantined from the public GJC utility surface.
 		// Explicit SDK extension factories are still honored; callers use them to
 		// register in-process tools/providers without enabling filesystem discovery.
@@ -1889,6 +1935,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			modelRegistry,
 			taskDepth,
 			toolRegistry,
+			workflowGateToolSession: toolSession,
 			transformContext,
 			onPayload,
 			onResponse,