@gajae-code/coding-agent 0.3.1 → 0.4.0

package/src/modes/types.ts

@@ -147,6 +147,7 @@ export interface InteractiveModeContext {
 	showStatus(message: string, options?: { dim?: boolean }): void;
 	showError(message: string): void;
 	showWarning(message: string): void;
+	notifyConfigChanged?: () => Promise<void> | void;
 	showNewVersionNotification(newVersion: string): void;
 	clearEditor(): void;
 	updatePendingMessagesDisplay(): void;

package/src/prompts/memories/consolidation.md

@@ -1,5 +1,5 @@
 Memory consolidation agent.
-Memory root: memory://root
+Memory backend: local private runtime state
 Input corpus (raw memories):
 {{raw_memories}}
 Input corpus (rollout summaries):

package/src/prompts/memories/read-path.md

@@ -1,11 +1,10 @@
 # Memory Guidance
-Memory root: memory://root
+Memory backend: local private runtime state
 Operational rules:
-1) Read `memory://root/memory_summary.md` first.
-2) If needed, inspect `memory://root/MEMORY.md` and `memory://root/skills/<name>/SKILL.md`.
-3) Trust memory for heuristics and process context. Trust current repo files, runtime output, and user instruction for factual state and final decisions.
-4) When memory changes your plan, cite the artifact path (e.g. `memory://root/skills/<name>/SKILL.md`) and pair it with current-repo evidence.
-5) If memory disagrees with repo state or user instruction, prefer repo/user. Treat memory as stale. Proceed with corrected behavior, then update/regenerate memory artifacts.
-6) Escalate confidence only after repository verification. Memory alone is NEVER sufficient proof.
+1) The memory summary below is already injected; do not try to call or invent a `memory` tool.
+2) Treat memory as heuristic process context. Trust current repo files, runtime output, and user instruction for factual state and final decisions.
+3) When memory changes your plan, pair it with current-repo evidence before acting.
+4) If memory disagrees with repo state or user instruction, prefer repo/user. Treat memory as stale. Proceed with corrected behavior, then update/regenerate memory artifacts through supported memory commands when available.
+5) Escalate confidence only after repository verification. Memory alone is NEVER sufficient proof.
 Memory summary:
 {{memory_summary}}

package/src/prompts/memories/unavailable.md

@@ -1,9 +1,9 @@
 # Memory Guidance
-Memory root: memory://root
+Memory backend: local private runtime state
 Status: local memory is enabled, but no confirmed memory payload is available for this project yet.
 
 Operational rules:
 1) Do not claim that a user preference, fact, or instruction has been saved, remembered, or persisted unless a backend operation or a non-empty memory payload confirms it.
 2) If the user asks you to save or remember something now, explain that durable memory is not confirmed because local memory has no available payload/readback yet. You may use the instruction for the current session only.
-3) If reading `memory://root` or `memory://root/memory_summary.md` fails, treat that as no confirmed memory, not as successful persistence.
+3) Do not try to call or invent a `memory` tool; local memory readback is unavailable in this session.
 4) The local backend consolidates prior session rollouts asynchronously; an empty payload is a degraded/unconfirmed state, not a successful save.

package/src/prompts/tools/bash.md

@@ -6,7 +6,7 @@ Executes bash command in shell session for terminal operations like git, bun, ca
 - Quote variable expansions like `"$NAME"` to preserve exact content
 - PTY mode is opt-in: set `pty: true` only when the command needs a real terminal (e.g. `sudo`, `ssh` requiring user input); default is `false`
 - Use `;` only when later commands should run regardless of earlier failures
-- Internal URIs (`agent://`, `artifact://`, `memory://`, `rule://`, `local://`) are auto-resolved to filesystem paths
+- Internal URIs (`agent://`, `artifact://`, `rule://`, `local://`) are auto-resolved to filesystem paths
 {{#if asyncEnabled}}
 - Use `async: true` for long-running commands when you don't need immediate output; the call returns a background job ID and the result is delivered automatically as a follow-up.
 {{/if}}

package/src/prompts/tools/irc.md

@@ -24,7 +24,7 @@ These rules apply to both sending and replying.
 - **Do not quote the message you are replying to.** The sender already saw it; the TUI already renders it. Lead with the answer.
 - **Use IRC, not terminal tools, to learn about peers.** Do not `grep` artifacts, read other sessions' JSONL files, or shell-poke around to figure out what another agent is doing. DM them — they have the live answer and you do not.
 - **One round-trip is enough.** Replies arrive synchronously when the recipient is reachable. Do not follow up with "did you get my message?" — they did. If `delivered` is empty or the result was `failed`, the peer is unavailable; move on or report the blocker, do not retry in a loop.
-- **Stay terse.** A DM is a chat message, not a memo. One question per send when you can. Share file paths and artifacts via `local://` / `memory://` / `artifact://` URLs instead of pasting blobs.
+- **Stay terse.** A DM is a chat message, not a memo. One question per send when you can. Share file paths and artifacts via `local://` / `artifact://` URLs instead of pasting blobs.
 - **Address peers by id.** Use the exact id from `op: "list"` (e.g. `0-AuthLoader`, `0-Main`). Do not invent friendly names.
 - **Do not IRC for things a tool would answer.** If a `read`, `grep`, or build command would resolve the question, do that first.
 - **When you receive an IRC message, answer it before continuing.** The recipient injects the question + your auto-reply into your history; address it directly, do not repeat it back to the user.

package/src/prompts/tools/read.md

@@ -8,7 +8,7 @@ Read files, directories, archives, SQLite databases, images, documents, internal
 
 ## Parameters
 
-- `path` — required. Local path, internal URI (`agent://`, `artifact://`, `memory://`, `rule://`, `local://`), or URL. Append `:<sel>` for line ranges, raw mode, or special modes (e.g. `src/foo.ts:50-200`, `src/foo.ts:raw`, `db.sqlite:users:42`).
+- `path` — required. Local path, internal URI (`agent://`, `artifact://`, `rule://`, `local://`), or URL. Append `:<sel>` for line ranges, raw mode, or special modes (e.g. `src/foo.ts:50-200`, `src/foo.ts:raw`, `db.sqlite:users:42`).
 
 ## Selectors
 
@@ -70,7 +70,7 @@ For `.sqlite`, `.sqlite3`, `.db`, `.db3`:
 
 # Internal URIs
 
-`agent://<id>`, `artifact://<id>`, `memory://root`, `rule://<name>`, and `local://<name>.md` resolve transparently and accept the same line selectors as filesystem paths. Use `artifact://<id>` to recover full output that a previous bash/eval/tool result spilled or truncated.
+`agent://<id>`, `artifact://<id>`, `rule://<name>`, and `local://<name>.md` resolve transparently and accept the same line selectors as filesystem paths. Use `artifact://<id>` to recover full output that a previous bash/eval/tool result spilled or truncated.
 
 <critical>
 - You MUST use `read` for every file, directory, archive, and URL inspection. `cat`, `head`, `tail`, `less`, `more`, `ls`, `tar`, `unzip`, `curl`, `wget` are FORBIDDEN — any such bash call is a bug, regardless of how short or convenient it looks.

package/src/prompts/tools/recall.md

@@ -1,3 +1,4 @@
+Compatibility-only legacy Hindsight helper. This prompt is retained for backend/tool-call compatibility and is not part of the public gajae-code coding harness tool surface.
 Search long-term memory for relevant information. Returns raw matching entries ranked by relevance.
 
 Use proactively — before answering questions about past conversations, user preferences, project decisions, or any topic where prior context would help accuracy. When in doubt, recall first.

package/src/prompts/tools/reflect.md

@@ -1,3 +1,4 @@
+Compatibility-only legacy Hindsight helper. This prompt is retained for backend/tool-call compatibility and is not part of the public gajae-code coding harness tool surface.
 Generate a synthesised answer by reasoning over long-term memory. Unlike `recall`, `reflect` blends relevant memories into a coherent response.
 
 Use for open-ended questions spanning many stored facts: "What do you know about this user?", "Summarize project decisions.", "What are my preferences for X?"

package/src/prompts/tools/retain.md

@@ -1,3 +1,4 @@
+Compatibility-only legacy Hindsight helper. This prompt is retained for backend/tool-call compatibility and is not part of the public gajae-code coding harness tool surface.
 Store one or more facts in long-term memory for future sessions.
 
 Use for durable, reusable knowledge: user preferences, project decisions, architectural choices, anything that improves future responses.

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). */
@@ -291,7 +295,7 @@ export interface CreateAgentSessionOptions {
 	taskDepth?: number;
 	/** Current role-agent type/name for nested task sessions. */
 	currentAgentType?: string;
-	/** Parent Hindsight state to alias for subagent memory tools. */
+	/** Parent Hindsight state to alias for subagent private memory backend compatibility. */
 	parentHindsightSessionState?: HindsightSessionState;
 	/** Pre-allocated agent identity for IRC routing. Default: "0-Main" for top-level, parentTaskPrefix-derived for sub. */
 	agentId?: string;
@@ -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,