@gajae-code/coding-agent 0.3.2 → 0.4.0

package/src/session/agent-session.ts

@@ -163,6 +163,10 @@ import type {
 } from "../extensibility/extensions";
 import type { CompactOptions, ContextUsage } from "../extensibility/extensions/types";
 import { ExtensionToolWrapper } from "../extensibility/extensions/wrapper";
+import type { LoadedSubskillActivation } from "../extensibility/gjc-plugins";
+import { resolveCurrentPhaseForParent } from "../extensibility/gjc-plugins/injection";
+import { readActiveSubskillsForParent, toActiveSubskillEntry } from "../extensibility/gjc-plugins/state";
+import { loadActiveSubskillTools } from "../extensibility/gjc-plugins/tools";
 import type { HookCommandContext } from "../extensibility/hooks/types";
 import type { Skill, SkillWarning } from "../extensibility/skills";
 import { expandSlashCommand, type FileSlashCommand } from "../extensibility/slash-commands";
@@ -174,7 +178,9 @@ import type { Goal, GoalModeState } from "../goals/state";
 import type { HindsightSessionState } from "../hindsight/state";
 import { ensureWorkflowSkillActivationState } from "../hooks/skill-state";
 import { type LocalProtocolOptions, resolveLocalUrlToPath } from "../internal-urls";
+import { shutdownAll as shutdownAllLspClients } from "../lsp/client";
 import { resolveMemoryBackend } from "../memory-backend";
+import type { WorkflowGateEmitter } from "../modes/shared/agent-wire/unattended-session";
 import { getCurrentThemeName, theme } from "../modes/theme/theme";
 import type { PlanModeState } from "../plan-mode/state";
 import autoContinuePrompt from "../prompts/system/auto-continue.md" with { type: "text" };
@@ -197,9 +203,14 @@ import {
 	isMCPToolName,
 	selectDiscoverableMCPToolNamesByServer,
 } from "../runtime-mcp/discoverable-tool-metadata";
+import { MCPManager } from "../runtime-mcp/manager";
 import { deobfuscateSessionContext, type SecretObfuscator } from "../secrets/obfuscator";
 import { formatNoCredentialOnboardingError, formatNoModelOnboardingError } from "../setup/model-onboarding-guidance";
-import { isCanonicalGjcWorkflowSkill } from "../skill-state/active-state";
+import {
+	isCanonicalGjcWorkflowSkill,
+	readVisibleSkillActiveState,
+	syncSkillActiveState,
+} from "../skill-state/active-state";
 import { assertDeepInterviewMutationAllowed } from "../skill-state/deep-interview-mutation-guard";
 import { invalidateHostMetadata } from "../ssh/connection-manager";
 import { resolveThinkingLevelForModel, toReasoningEffort } from "../thinking";
@@ -209,9 +220,11 @@ import {
 	type DiscoverableTool,
 	type DiscoverableToolSearchIndex,
 } from "../tool-discovery/tool-index";
+import type { ToolSession } from "../tools";
+import { AskTool } from "../tools/ask";
 import { assertEditableFile } from "../tools/auto-generated-guard";
 import type { CheckpointState } from "../tools/checkpoint";
-import { outputMeta } from "../tools/output-meta";
+import { outputMeta, wrapToolWithMetaNotice } from "../tools/output-meta";
 import { normalizeLocalScheme, resolveToCwd } from "../tools/path-utils";
 import { getLatestTodoPhasesFromEntries, type TodoItem, type TodoPhase } from "../tools/todo-write";
 import { ToolAbortError, ToolError } from "../tools/tool-errors";
@@ -337,6 +350,8 @@ export interface AgentSessionConfig {
 	taskDepth?: number;
 	/** Tool registry for LSP and settings */
 	toolRegistry?: Map<string, AgentTool>;
+	/** Tool-session factory context used to lazily attach workflow-gate-only tools. */
+	workflowGateToolSession?: ToolSession;
 	/** Current session pre-LLM message transform pipeline */
 	transformContext?: (messages: AgentMessage[], signal?: AbortSignal) => AgentMessage[] | Promise<AgentMessage[]>;
 	/** Provider payload hook used by the active session request path */
@@ -844,6 +859,7 @@ export class AgentSession {
 	#scheduledHiddenNextTurnGeneration: number | undefined = undefined;
 	#planModeState: PlanModeState | undefined;
 	#goalModeState: GoalModeState | undefined;
+	#workflowGateEmitter: WorkflowGateEmitter | undefined;
 	#goalRuntime: GoalRuntime;
 	#goalTurnCounter = 0;
 	#planReferenceSent = false;
@@ -923,6 +939,7 @@ export class AgentSession {
 
 	// Tool registry and prompt builder for extensions
 	#toolRegistry: Map<string, AgentTool>;
+	#workflowGateToolSession: ToolSession | undefined;
 	#transformContext: (messages: AgentMessage[], signal?: AbortSignal) => AgentMessage[] | Promise<AgentMessage[]>;
 	#onPayload: SimpleStreamOptions["onPayload"] | undefined;
 	#onResponse: SimpleStreamOptions["onResponse"] | undefined;
@@ -950,6 +967,8 @@ export class AgentSession {
 	#discoverableToolSearchIndex: DiscoverableToolSearchIndex | null = null;
 	#selectedDiscoveredToolNames = new Set<string>();
 	#rpcHostToolNames = new Set<string>();
+	#gjcSubskillToolNames = new Set<string>();
+	#gjcSubskillToolSignature: string | undefined;
 	#defaultSelectedMCPServerNames = new Set<string>();
 	#defaultSelectedMCPToolNames = new Set<string>();
 	#sessionDefaultSelectedMCPToolNames = new Map<string, string[]>();
@@ -1100,6 +1119,7 @@ export class AgentSession {
 		}
 		this.#validateRetryFallbackChains();
 		this.#toolRegistry = config.toolRegistry ?? new Map();
+		this.#workflowGateToolSession = config.workflowGateToolSession;
 		this.#requestedToolNames = config.requestedToolNames;
 		this.#transformContext = config.transformContext ?? (messages => messages);
 		this.#onPayload = config.onPayload;
@@ -3112,6 +3132,14 @@ export class AgentSession {
 				AsyncJobManager.setInstance(undefined);
 			}
 		}
+		const mcpManager = MCPManager.instance();
+		if (mcpManager) {
+			await mcpManager.disconnectAll();
+			if (MCPManager.instance() === mcpManager) {
+				MCPManager.setInstance(undefined);
+			}
+		}
+		await shutdownAllLspClients();
 		const pythonExecutionsSettled = await this.#prepareEvalExecutionsForDispose();
 		if (!pythonExecutionsSettled) {
 			logger.warn(
@@ -3942,6 +3970,123 @@ export class AgentSession {
 		);
 	}
 
+	async #hasActiveGjcSubskillTools(parent: string, sessionId: string | undefined): Promise<boolean> {
+		if (!parent.trim()) return false;
+		const cwd = this.sessionManager.getCwd();
+		const phase = await resolveCurrentPhaseForParent({ cwd, sessionId, parent });
+		const entries = await readActiveSubskillsForParent({ cwd, sessionId, parent, phase });
+		return entries.some(entry => (entry.toolPaths ?? []).some(toolPath => toolPath.trim().length > 0));
+	}
+
+	#getCustomToolContext(): CustomToolContext {
+		return {
+			sessionManager: this.sessionManager,
+			modelRegistry: this.#modelRegistry,
+			model: this.model,
+			isIdle: () => !this.isStreaming,
+			hasQueuedMessages: () => this.queuedMessageCount > 0,
+			abort: () => {
+				this.agent.abort();
+			},
+		};
+	}
+
+	#computeGjcSubskillToolSignature(tools: CustomTool[]): string {
+		return tools
+			.map(tool => `${tool.name}\u0000${tool.description}\u0000${JSON.stringify(tool.parameters)}`)
+			.sort()
+			.join("\u0001");
+	}
+
+	/**
+	 * Refresh plugin sub-skill tools after workflow/sub-skill activation or phase changes.
+	 */
+	async refreshGjcSubskillTools(): Promise<void> {
+		const activeState = await readVisibleSkillActiveState(
+			this.sessionManager.getCwd(),
+			this.sessionManager.getSessionId(),
+		);
+		const activeSkill =
+			this.#activeSkillState?.skill ??
+			activeState?.skill ??
+			activeState?.active_skills?.find(entry => entry.active !== false)?.skill;
+		const parent = activeSkill?.trim();
+		if (!parent) {
+			if (this.#gjcSubskillToolNames.size === 0) return;
+			const previousGjcSubskillToolNames = new Set(this.#gjcSubskillToolNames);
+			const previousActiveToolNames = this.getActiveToolNames();
+			for (const name of previousGjcSubskillToolNames) {
+				this.#toolRegistry.delete(name);
+			}
+			this.#gjcSubskillToolNames.clear();
+			this.#invalidateDiscoveryCaches();
+			await this.#applyActiveToolsByName(
+				previousActiveToolNames.filter(name => !previousGjcSubskillToolNames.has(name)),
+			);
+			return;
+		}
+
+		const cwd = this.sessionManager.getCwd();
+		const sessionId =
+			this.#activeSkillState?.sessionId ?? activeState?.session_id ?? this.sessionManager.getSessionId();
+		if (this.#gjcSubskillToolNames.size === 0 && !(await this.#hasActiveGjcSubskillTools(parent, sessionId))) return;
+
+		const phase = await resolveCurrentPhaseForParent({ cwd, sessionId, parent });
+		const reservedToolNames = Array.from(this.#toolRegistry.keys()).filter(
+			name => !this.#gjcSubskillToolNames.has(name),
+		);
+		const customTools = await loadActiveSubskillTools({ cwd, sessionId, parent, phase, reservedToolNames });
+		const nextToolNames = customTools.map(tool => tool.name);
+		const uniqueToolNames = new Set(nextToolNames);
+		if (uniqueToolNames.size !== nextToolNames.length) {
+			throw new Error("GJC sub-skill tool names must be unique");
+		}
+
+		const previousGjcSubskillToolNames = new Set(this.#gjcSubskillToolNames);
+		const nextSignature = this.#computeGjcSubskillToolSignature(customTools);
+		if (this.#gjcSubskillToolSignature === nextSignature) {
+			return;
+		}
+
+		const previousActiveToolNames = this.getActiveToolNames();
+		for (const name of previousGjcSubskillToolNames) {
+			this.#toolRegistry.delete(name);
+		}
+		this.#gjcSubskillToolNames.clear();
+		this.#gjcSubskillToolSignature = undefined;
+
+		const getCustomToolContext = () => this.#getCustomToolContext();
+		for (const customTool of customTools) {
+			const wrapped = CustomToolAdapter.wrap(customTool, getCustomToolContext) as AgentTool;
+			const finalTool = (
+				this.#extensionRunner ? new ExtensionToolWrapper(wrapped, this.#extensionRunner) : wrapped
+			) as AgentTool;
+			this.#toolRegistry.set(finalTool.name, finalTool);
+			this.#gjcSubskillToolNames.add(finalTool.name);
+		}
+		this.#gjcSubskillToolSignature = nextSignature;
+
+		this.#invalidateDiscoveryCaches();
+		const activeNonGjcSubskillToolNames = previousActiveToolNames.filter(
+			name => !previousGjcSubskillToolNames.has(name),
+		);
+		const preservedGjcSubskillToolNames = previousActiveToolNames.filter(
+			name => previousGjcSubskillToolNames.has(name) && this.#gjcSubskillToolNames.has(name),
+		);
+		const autoActivatedGjcSubskillToolNames = customTools
+			.filter(tool => !tool.hidden && !previousGjcSubskillToolNames.has(tool.name))
+			.map(tool => tool.name);
+		await this.#applyActiveToolsByName(
+			Array.from(
+				new Set([
+					...activeNonGjcSubskillToolNames,
+					...preservedGjcSubskillToolNames,
+					...autoActivatedGjcSubskillToolNames,
+				]),
+			),
+		);
+	}
+
 	/** Whether auto-compaction is currently running */
 	get isCompacting(): boolean {
 		return this.#autoCompactionAbortController !== undefined || this.#compactionAbortController !== undefined;
@@ -4088,6 +4233,45 @@ export class AgentSession {
 		this.#goalModeState = state;
 	}
 
+	getWorkflowGateEmitter(): WorkflowGateEmitter | undefined {
+		return this.#workflowGateEmitter;
+	}
+
+	setWorkflowGateEmitter(emitter: WorkflowGateEmitter | undefined): void {
+		this.#workflowGateEmitter = emitter;
+		if (emitter) {
+			this.#ensureWorkflowGateAskTool();
+		}
+	}
+
+	#ensureWorkflowGateAskTool(): void {
+		if (this.#toolRegistry.has("ask")) return;
+		if (!this.#workflowGateToolSession) return;
+
+		const askTool = AskTool.createIf(this.#workflowGateToolSession);
+		if (!askTool) return;
+
+		const wrappedTool = wrapToolWithMetaNotice(askTool as unknown as AgentTool);
+		const finalTool: AgentTool = this.#extensionRunner
+			? new ExtensionToolWrapper(wrappedTool, this.#extensionRunner)
+			: wrappedTool;
+		this.#toolRegistry.set(finalTool.name, finalTool);
+
+		if (!this.getActiveToolNames().includes(finalTool.name)) {
+			const activeTools = [
+				...this.agent.state.tools,
+				this.#wrapToolForDeepInterviewMutationGuard(this.#wrapToolForAcpPermission(finalTool)),
+			];
+			this.agent.setTools(activeTools);
+			this.#invalidateDiscoveryCaches();
+			void this.refreshBaseSystemPrompt().catch(error => {
+				logger.warn("Failed to refresh system prompt after workflow gate ask tool registration", {
+					error: error instanceof Error ? error.message : String(error),
+				});
+			});
+		}
+	}
+
 	get goalRuntime(): GoalRuntime {
 		return this.#goalRuntime;
 	}
@@ -4364,6 +4548,7 @@ export class AgentSession {
 		const message = options?.synthetic
 			? { role: "developer" as const, content: userContent, attribution: promptAttribution, timestamp: Date.now() }
 			: { role: "user" as const, content: userContent, attribution: promptAttribution, timestamp: Date.now() };
+		await this.refreshGjcSubskillTools();
 
 		if (eagerTodoPrelude) {
 			this.#toolChoiceQueue.pushOnce(eagerTodoPrelude.toolChoice, {
@@ -4409,9 +4594,33 @@ export class AgentSession {
 		// of relying on the skill prompt to run its own state-init steps.
 		if (active) {
 			await ensureWorkflowSkillActivationState({ cwd: this.sessionManager.getCwd(), skill, sessionId });
+			const subskillDetails = details as {
+				subskillActivation?: LoadedSubskillActivation;
+				subskillActivationSet?: LoadedSubskillActivation[];
+			};
+			const subskillActivations =
+				subskillDetails.subskillActivationSet && subskillDetails.subskillActivationSet.length > 0
+					? subskillDetails.subskillActivationSet
+					: subskillDetails.subskillActivation
+						? [subskillDetails.subskillActivation]
+						: [];
+			if (subskillActivations.length > 0) {
+				const skillBoundActivation = subskillDetails.subskillActivation ?? subskillActivations[0];
+				await syncSkillActiveState({
+					cwd: this.sessionManager.getCwd(),
+					skill,
+					active: true,
+					phase: skillBoundActivation?.phase,
+					sessionId,
+					active_subskills: subskillActivations.map(toActiveSubskillEntry),
+				});
+			}
 		}
 		// In-memory tracking keeps `getActiveSkillState` accurate for the chain guard.
 		this.#activeSkillState = active ? { skill, sessionId } : undefined;
+		if (active) {
+			await this.refreshGjcSubskillTools();
+		}
 	}
 
 	async #syncSkillPromptActiveStateSafely(

package/src/session/blob-store.ts

@@ -73,6 +73,17 @@ export class BlobStore {
 		}
 	}
 
+	/** Synchronously read blob by hash, returns Buffer or null if not found. */
+	getSync(hash: string): Buffer | null {
+		const blobPath = path.join(this.dir, hash);
+		try {
+			return fs.readFileSync(blobPath);
+		} catch (err) {
+			if (isEnoent(err)) return null;
+			throw err;
+		}
+	}
+
 	/** Check if a blob exists. */
 	async has(hash: string): Promise<boolean> {
 		try {
@@ -84,6 +95,43 @@ export class BlobStore {
 	}
 }
 
+export class MemoryBlobStore extends BlobStore {
+	#blobs = new Map<string, Buffer>();
+
+	constructor() {
+		super(":memory:");
+	}
+
+	async put(data: Buffer): Promise<BlobPutResult> {
+		return this.putSync(data);
+	}
+
+	putSync(data: Buffer): BlobPutResult {
+		const hash = new Bun.SHA256().update(data).digest("hex");
+		this.#blobs.set(hash, Buffer.from(data));
+		return {
+			hash,
+			path: `memory:${hash}`,
+			get ref() {
+				return `${BLOB_PREFIX}${hash}`;
+			},
+		};
+	}
+
+	async get(hash: string): Promise<Buffer | null> {
+		return this.getSync(hash);
+	}
+
+	getSync(hash: string): Buffer | null {
+		const data = this.#blobs.get(hash);
+		return data ? Buffer.from(data) : null;
+	}
+
+	async has(hash: string): Promise<boolean> {
+		return this.#blobs.has(hash);
+	}
+}
+
 /** Check if a data string is a blob reference. */
 export function isBlobRef(data: string): boolean {
 	return data.startsWith(BLOB_PREFIX);
@@ -166,3 +214,39 @@ export async function resolveImageData(blobStore: BlobStore, data: string): Prom
 	}
 	return buffer.toString("base64");
 }
+
+/** Synchronously resolve an externalized provider image data URL back to its original string. */
+export function resolveImageDataUrlSync(blobStore: BlobStore, data: string): string {
+	const hash = parseBlobRef(data);
+	if (!hash) return data;
+	const buffer = blobStore.getSync(hash);
+	if (!buffer) {
+		logger.warn("Blob not found for persisted image data URL", { hash });
+		return data;
+	}
+	return buffer.toString("utf8");
+}
+
+/** Synchronously resolve a blob reference back to base64 data. */
+export function resolveImageDataSync(blobStore: BlobStore, data: string): string {
+	const hash = parseBlobRef(data);
+	if (!hash) return data;
+	const buffer = blobStore.getSync(hash);
+	if (!buffer) {
+		logger.warn("Blob not found for image reference", { hash });
+		return data;
+	}
+	return buffer.toString("base64");
+}
+
+/** Synchronously resolve a blob reference back to utf8 text. */
+export function resolveTextBlobSync(blobStore: BlobStore, data: string): string {
+	const hash = parseBlobRef(data);
+	if (!hash) return data;
+	const buffer = blobStore.getSync(hash);
+	if (!buffer) {
+		logger.warn("Blob not found for text reference", { hash });
+		return data;
+	}
+	return buffer.toString("utf8");
+}

package/src/session/messages.ts

@@ -27,6 +27,7 @@ export {
 	createCompactionSummaryMessage,
 } from "@gajae-code/agent-core/compaction/messages";
 
+import type { LoadedSubskillActivation } from "../extensibility/gjc-plugins";
 import type { OutputMeta } from "../tools/output-meta";
 import { formatOutputNotice } from "../tools/output-meta";
 
@@ -37,6 +38,8 @@ export interface SkillPromptDetails {
 	path: string;
 	args?: string;
 	lineCount: number;
+	subskillActivation?: LoadedSubskillActivation;
+	subskillActivationSet?: LoadedSubskillActivation[];
 	/** Internal: tag used by AgentSession to remove the pending-display chip
 	 *  from `#steeringMessages` / `#followUpMessages` when the agent consumes
 	 *  this message. Not surfaced to renderers; the `__` prefix signals