@gajae-code/coding-agent 0.15.5 → 0.15.6

package/src/sdk/bus/kind-aware-reconciliation.ts

@@ -21,6 +21,8 @@ import type {
 	ReconciliationStore,
 } from "./reconciliation-store";
 
+const EMPTY_PROMPT_FAILURE = { code: "prompt_failed", message: "Prompt submission failed." } as const;
+
 export type { ReconciliationKind };
 
 export interface KindCorrelation extends PromptCorrelation {
@@ -51,8 +53,13 @@ export interface KindAwareReconciliation {
 		kind: ReconciliationKind,
 		correlation: PromptCorrelation | undefined,
 		frame:
-			| { type: "agent_start" | "agent_end"; content?: TurnResultContent }
-			| { type: "agent_failed"; error: unknown; content?: TurnResultContent },
+			| {
+					type: "agent_start" | "agent_end";
+					content?: TurnResultContent;
+					hasActivity?: boolean;
+					outcome?: SdkPromptTerminalOutcome;
+			  }
+			| { type: "agent_failed"; error: unknown; content?: TurnResultContent; hasActivity?: boolean },
 	): Promise<void>;
 	claimPendingOutcome(
 		kind: ReconciliationKind,
@@ -340,8 +347,13 @@ export function createKindAwareReconciliation(
 		kind: ReconciliationKind,
 		correlation: PromptCorrelation | undefined,
 		frame:
-			| { type: "agent_start" | "agent_end"; content?: TurnResultContent }
-			| { type: "agent_failed"; error: unknown; content?: TurnResultContent },
+			| {
+					type: "agent_start" | "agent_end";
+					content?: TurnResultContent;
+					hasActivity?: boolean;
+					outcome?: SdkPromptTerminalOutcome;
+			  }
+			| { type: "agent_failed"; error: unknown; content?: TurnResultContent; hasActivity?: boolean },
 	) => {
 		if (!correlation) return;
 		await queueMutation(candidate => {
@@ -412,7 +424,17 @@ export function createKindAwareReconciliation(
 				record.receiptState = record.pendingReceiptState ?? "missing";
 				record.pendingReceiptState = undefined;
 			} else {
-				record.status = record.error === undefined ? "terminal_ok" : "failed";
+				if (
+					kind === "prompt" &&
+					record.error === undefined &&
+					frame.type === "agent_end" &&
+					frame.outcome?.kind !== "stopped" &&
+					!frame.content?.text.trim() &&
+					!frame.hasActivity
+				) {
+					record.status = "failed";
+					record.error = EMPTY_PROMPT_FAILURE;
+				} else record.status = record.error === undefined ? "terminal_ok" : "failed";
 				record.receiptState = frame.content?.text?.trim() ? "present" : "missing";
 			}
 			cleanupRecords(candidate);
@@ -453,6 +475,7 @@ export function createKindAwareReconciliation(
 					: undefined;
 		const content =
 			typeof arg4 === "function" ? arg6 : typeof arg5 === "object" && arg5 !== null && "code" in arg5 ? arg6 : arg5;
+		const sanitizedContent = sanitizeTurnResultContent(content);
 		await queueMutation(candidate => {
 			if (isCurrent !== undefined && !isCurrent()) return { value: undefined, changed: false };
 			const record = candidate.get(keyOf(kind, correlation));
@@ -463,8 +486,15 @@ export function createKindAwareReconciliation(
 			if (finalOutcome?.kind === "failed") {
 				record.status = "failed";
 				record.error = recordError ?? { code: finalOutcome.code, message: finalOutcome.message };
+			} else if (
+				kind === "prompt" &&
+				((finalOutcome === undefined && !sanitizedContent?.text.trim()) ||
+					(finalOutcome?.kind !== "stopped" && content !== undefined && !sanitizedContent?.text.trim()))
+			) {
+				record.status = "failed";
+				record.error = EMPTY_PROMPT_FAILURE;
 			} else record.status = "terminal_ok";
-			record.content = sanitizeTurnResultContent(content);
+			record.content = sanitizedContent;
 			record.outcome = finalOutcome;
 			record.receiptState = record.pendingReceiptState ?? "unknown";
 			record.pendingOutcome = undefined;

package/src/sdk/bus/prompt-reconciliation.ts

@@ -23,11 +23,13 @@
  */
 
 import { PROMPT_FAILURE_CODE_MAX, sanitizePromptFailure } from "../prompt-failure";
+import type { SdkPromptTerminalOutcome } from "../prompt-status";
 import type { ReceiptState } from "../receipt-state";
 
 export { PROMPT_FAILURE_CODE_MAX, sanitizePromptFailure };
 export const PROMPT_RECONCILIATION_ACTIVE_CAPACITY = 128;
 export const PROMPT_RECONCILIATION_TERMINAL_CAPACITY = 256;
+const EMPTY_PROMPT_FAILURE = { code: "prompt_failed", message: "Prompt submission failed." } as const;
 
 export type PromptReconciliationStatus = "accepted" | "in_flight" | "terminal_ok" | "failed";
 
@@ -101,8 +103,13 @@ export interface PromptReconciliation {
 		correlation: PromptCorrelation | undefined,
 		frame:
 			| { type: "agent_start" }
-			| { type: "agent_end"; finalText?: string }
-			| { type: "agent_failed"; error: unknown; finalText?: string },
+			| {
+					type: "agent_end";
+					finalText?: string;
+					hasActivity?: boolean;
+					outcome?: SdkPromptTerminalOutcome;
+			  }
+			| { type: "agent_failed"; error: unknown; finalText?: string; hasActivity?: boolean },
 	): void;
 	lookup(selector: { commandId?: string; turnId?: string; clientRef?: string }): TurnPromptReconciliation;
 	cleanup(): void;
@@ -190,8 +197,13 @@ export function createPromptReconciliation(options: { now?: () => number } = {})
 		correlation: PromptCorrelation | undefined,
 		frame:
 			| { type: "agent_start" }
-			| { type: "agent_end"; finalText?: string }
-			| { type: "agent_failed"; error: unknown; finalText?: string },
+			| {
+					type: "agent_end";
+					finalText?: string;
+					hasActivity?: boolean;
+					outcome?: SdkPromptTerminalOutcome;
+			  }
+			| { type: "agent_failed"; error: unknown; finalText?: string; hasActivity?: boolean },
 	) => {
 		if (!correlation) return;
 		const record = records.get(keyOf(correlation));
@@ -221,6 +233,18 @@ export function createPromptReconciliation(options: { now?: () => number } = {})
 		if (frame.type === "agent_failed") {
 			record.status = "failed";
 			record.error = sanitizePromptFailure(frame.error);
+		} else if (record.error !== undefined) {
+			// Preserve an actionable provider failure already recorded before a late
+			// empty agent_end; the empty frame cannot downgrade or replace its cause.
+			record.status = "failed";
+		} else if (frame.type === "agent_end" && frame.outcome?.kind === "stopped") {
+			record.status = "terminal_ok";
+		} else if (!frame.finalText?.trim() && !frame.hasActivity) {
+			// A prompt cannot claim successful completion without assistant content.
+			// Keep the terminal transition first-wins, but fail closed instead of
+			// exposing an empty zero-token turn as terminal_ok.
+			record.status = "failed";
+			record.error = EMPTY_PROMPT_FAILURE;
 		} else {
 			record.status = "terminal_ok";
 		}

package/src/sdk/bus/slack-conversation.ts

@@ -74,5 +74,9 @@ export function normalizeSlackConversation(record: SlackConversation): SlackConv
 }
 
 export function acceptsSlackInbound(record: SlackConversation, rootTs: string, endpointGeneration: number): boolean {
-	return record.state === "active" && record.rootTs === rootTs && record.endpointGeneration === endpointGeneration;
+	return (
+		(record.state === "active" || record.state === "resumed_root") &&
+		record.rootTs === rootTs &&
+		record.endpointGeneration === endpointGeneration
+	);
 }

package/src/sdk/cli/session-cli.ts

@@ -16,7 +16,11 @@ import type {
 	SessionReconcileUncertainTarget,
 } from "../lifecycle/service";
 import { PROMPT_CLIENT_REF_MAX_LENGTH } from "../prompt-status";
-import { validateAdapterControl, validateAdapterSecretFields } from "../protocol/adapter-validation";
+import {
+	validateAdapterControl,
+	validateAdapterSecretFields,
+	validateRequiredPromptText,
+} from "../protocol/adapter-validation";
 import { adapterDispositionError, findOperation, type OperationKind } from "../protocol/operation-registry";
 import { type SessionAttachment, SessionRouter, SessionRouterError, type SessionRouterFrame } from "../router";
 import { SessionListTraversalError, sessionListPageFromResponse, traverseSessionList } from "../session-list";
@@ -654,6 +658,8 @@ async function runSend(agentDir: string, sessionId: string, args: SdkSessionCliA
 	if (args.text !== undefined && Object.keys(input).length > 0)
 		throw new SdkSessionCliError("usage", "Use either --text or one JSON input source for the prompt, not both.", 2);
 	const promptInput: JsonRecord = args.text === undefined ? { ...input } : { text: args.text };
+	const promptError = validateRequiredPromptText("turn.prompt", promptInput);
+	if (promptError) throw new SdkSessionCliError(promptError.code, promptError.message, 2);
 	const inputRef = clientRefFromInput(promptInput);
 	const clientRef = inputRef ?? args.opRef?.trim() ?? createOperationRef();
 	if (args.opRef !== undefined && inputRef !== undefined && inputRef !== args.opRef.trim())
@@ -914,6 +920,11 @@ function publicationSequence(publicationId: string): number | undefined {
 
 function tailItemFromRouterFrame(frame: SessionRouterFrame): SdkTailItemV1 | undefined {
 	if (frame.name === undefined) return undefined;
+	// The replay response is an out-of-band control frame, not an event-ring
+	// item. Its generation/lastSeq metadata is a response position, and it
+	// intentionally has no event `seq`; projecting it as a tail item would make
+	// the strict event-position validator reject every otherwise valid tail.
+	if (frame.name === "event_replay_result") return undefined;
 	const seq = frame.publicationId === undefined ? undefined : publicationSequence(frame.publicationId);
 	return toTailItemV1(
 		{

package/src/sdk/client/discovery.ts

@@ -35,7 +35,7 @@ export class SdkDiscoveryError extends Error {
 
 export type SdkSessionEndpointScope = "default" | "chat";
 
-function endpointDirectory(repo: string, scope: SdkSessionEndpointScope = "default"): string {
+export function endpointDirectory(repo: string, scope: SdkSessionEndpointScope = "default"): string {
 	return scope === "chat" ? path.join(repo, ".gjc", "state", "chat", "sdk") : path.join(repo, ".gjc", "state", "sdk");
 }
 function isUsableSessionId(sessionId: string): boolean {
@@ -132,6 +132,8 @@ export async function readSdkSessionEndpoint(
 	if (!isUsableSessionId(sessionId)) return null;
 	const file = path.join(endpointDirectory(repo, scope), `${sessionId}.json`);
 	try {
+		const stat = await fs.lstat(file);
+		if (!stat.isFile()) return null;
 		return parseEndpoint(sessionId, file, JSON.parse(await fs.readFile(file, "utf8")));
 	} catch (error) {
 		if ((error as NodeJS.ErrnoException).code === "ENOENT") return null;

package/src/sdk/host/control/dispatch.ts

@@ -3,6 +3,7 @@ import {
 	DEFAULT_MODEL_SELECTION_RECOVERY_MESSAGE,
 	parseDefaultModelSelectionRecovery,
 } from "../../../session/default-model-selection";
+import { validateRequiredPromptText } from "../../protocol/adapter-validation";
 import { OPERATIONS, type Operation } from "../../protocol/operation-registry";
 import type { ControlInput, ControlSurface, ControlValue } from "./operations";
 import { brokerRuntimeCloseCapability, hasBrokerRuntimeCloseCapability } from "./runtime-gate";
@@ -462,6 +463,8 @@ export function dispatchControl(
 		);
 	if (!isInput(request.input))
 		return Promise.resolve(failure(request.id, "invalid_input", "Control input must be an object."));
+	const promptError = validateRequiredPromptText(row.sdkId, request.input);
+	if (promptError) return Promise.resolve(failure(request.id, promptError.code, promptError.message));
 	if ((row.sdkId === "context.clear" || row.sdkId === "session.delete") && request.confirm !== true)
 		return Promise.resolve(
 			failure(request.id, "invalid_input", "confirm: true is required for this destructive operation."),

package/src/sdk/host/model-pin.ts

@@ -17,9 +17,19 @@ export interface SdkHostModelResolveContext {
 }
 
 /** Registry loader owned by the SDK host, not by machine-facing adapters. */
-export type SdkHostModelRegistryLoader = (
+export type SdkHostModelRegistryLoader = ((
 	context?: SdkHostModelResolveContext,
-) => ModelRegistry | Promise<ModelRegistry>;
+) => ModelRegistry | Promise<ModelRegistry>) & {
+	acquire?: (context?: SdkHostModelResolveContext) => () => void;
+	dispose?: () => Promise<void>;
+};
+
+type OwnedModelRegistry = {
+	registry: ModelRegistry;
+	storage: AuthStorage;
+};
+
+const MAX_CACHED_MODEL_REGISTRIES = 32;
 
 /**
  * Builds an offline model resolver for a single SDK host process.
@@ -32,16 +42,112 @@ export function createSdkHostModelRegistryLoader(
 	modelsPath?: string,
 	loadSettings?: (context?: SdkHostModelResolveContext) => Promise<Pick<Settings, "get" | "getGlobal">>,
 ): SdkHostModelRegistryLoader {
-	const cachedRegistries = new Map<string, Promise<ModelRegistry>>();
-	return async (context?: SdkHostModelResolveContext) => {
-		const scopeKey = context?.cwd ?? "";
+	const cachedRegistries = new Map<string, Promise<OwnedModelRegistry>>();
+	const retiredRegistries = new Map<string, Promise<OwnedModelRegistry>[]>();
+	const activeScopes = new Map<string, number>();
+	const disposedEntries = new WeakSet<Promise<OwnedModelRegistry>>();
+	const pendingDisposals = new Set<Promise<void>>();
+	const disposalBarrier = Promise.withResolvers<void>();
+	const registryAgentDir = path.resolve(path.dirname(modelsPath ?? "."));
+	let disposed = false;
+	const scopeKeyFor = (context?: SdkHostModelResolveContext): string =>
+		context?.cwd === undefined ? "" : path.resolve(context.cwd);
+	const disposeEntry = async (entry: Promise<OwnedModelRegistry>): Promise<void> => {
+		let owned: OwnedModelRegistry;
+		try {
+			owned = await entry;
+		} catch {
+			// Initialization failures close their storage before rejecting. Disposal is
+			// best-effort and must not block broker shutdown on one broken scope.
+			return;
+		}
+		try {
+			owned.registry.dispose();
+		} finally {
+			owned.storage.close();
+		}
+	};
+	const maybeResolveDisposal = (): void => {
+		if (
+			disposed &&
+			cachedRegistries.size === 0 &&
+			retiredRegistries.size === 0 &&
+			activeScopes.size === 0 &&
+			pendingDisposals.size === 0
+		)
+			disposalBarrier.resolve();
+	};
+	const disposeEntries = (entries: Promise<OwnedModelRegistry>[]): void => {
+		const seen = new Set<Promise<OwnedModelRegistry>>();
+		const unique = entries.filter(entry => {
+			if (seen.has(entry) || disposedEntries.has(entry)) return false;
+			seen.add(entry);
+			return true;
+		});
+		if (unique.length === 0) {
+			maybeResolveDisposal();
+			return;
+		}
+		for (const entry of unique) disposedEntries.add(entry);
+		const pending = Promise.all(unique.map(entry => disposeEntry(entry))).then(
+			() => undefined,
+			() => undefined,
+		);
+		pendingDisposals.add(pending);
+		void pending.finally(() => {
+			pendingDisposals.delete(pending);
+			maybeResolveDisposal();
+		});
+	};
+	const retireEntry = (scopeKey: string, entry: Promise<OwnedModelRegistry>): void => {
+		if ((activeScopes.get(scopeKey) ?? 0) > 0) {
+			const retired = retiredRegistries.get(scopeKey) ?? [];
+			if (!retired.includes(entry)) retired.push(entry);
+			retiredRegistries.set(scopeKey, retired);
+			return;
+		}
+		disposeEntries([entry]);
+	};
+	const disposeRetired = (scopeKey: string): void => {
+		const retired = retiredRegistries.get(scopeKey);
+		if (!retired || (activeScopes.get(scopeKey) ?? 0) > 0) return;
+		retiredRegistries.delete(scopeKey);
+		disposeEntries(retired);
+	};
+	const evictIdleEntries = (): Promise<OwnedModelRegistry>[] => {
+		const evicted: Promise<OwnedModelRegistry>[] = [];
+		while (cachedRegistries.size > MAX_CACHED_MODEL_REGISTRIES) {
+			const oldest = [...cachedRegistries.keys()].find(key => (activeScopes.get(key) ?? 0) === 0);
+			if (oldest === undefined) break;
+			const entry = cachedRegistries.get(oldest);
+			cachedRegistries.delete(oldest);
+			if (entry) evicted.push(entry);
+		}
+		return evicted;
+	};
+	const loadRegistry = async (context?: SdkHostModelResolveContext): Promise<ModelRegistry> => {
+		if (disposed) throw new Error("SDK host model registry loader is disposed.");
+		const scopeKey = scopeKeyFor(context);
 		let cachedRegistry = cachedRegistries.get(scopeKey);
 		if (cachedRegistry === undefined) {
-			const initializing = Promise.all([discoverStorage(), loadSettings?.(context)]).then(
-				([storage, registrySettings]) => new ModelRegistry(storage, modelsPath, registrySettings),
-			);
+			const initializing = discoverStorage().then(async storage => {
+				try {
+					const registrySettings = await loadSettings?.(context);
+					return {
+						storage,
+						registry: new ModelRegistry(storage, modelsPath, registrySettings, {
+							agentDir: registryAgentDir,
+							automaticRefresh: false,
+						}),
+					};
+				} catch (error) {
+					storage.close();
+					throw error;
+				}
+			});
 			cachedRegistries.set(scopeKey, initializing);
 			cachedRegistry = initializing;
+			disposeEntries(evictIdleEntries());
 			try {
 				await initializing;
 			} catch (error) {
@@ -49,21 +155,67 @@ export function createSdkHostModelRegistryLoader(
 				throw error;
 			}
 		}
-		const registry = await cachedRegistry;
-		if (loadSettings) registry.setScopedSettings(await loadSettings(context));
+		const owned = await cachedRegistry;
+		if (disposed || disposedEntries.has(cachedRegistry) || cachedRegistries.get(scopeKey) !== cachedRegistry) {
+			retireEntry(scopeKey, cachedRegistry);
+			throw new Error("SDK host model registry loader is disposed.");
+		}
+		cachedRegistries.delete(scopeKey);
+		cachedRegistries.set(scopeKey, cachedRegistry);
+		const registry = owned.registry;
+		if (loadSettings) {
+			const registrySettings = await loadSettings(context);
+			if (disposed || disposedEntries.has(cachedRegistry)) {
+				retireEntry(scopeKey, cachedRegistry);
+				throw new Error("SDK host model registry loader is disposed.");
+			}
+			registry.setScopedSettings(registrySettings);
+		}
 		await registry.refresh("offline");
+		if (disposed || disposedEntries.has(cachedRegistry)) {
+			retireEntry(scopeKey, cachedRegistry);
+			throw new Error("SDK host model registry loader is disposed.");
+		}
 		return registry;
 	};
+	return Object.assign(loadRegistry, {
+		dispose: async (): Promise<void> => {
+			if (disposed) return await disposalBarrier.promise;
+			disposed = true;
+			for (const [scopeKey, entry] of cachedRegistries) retireEntry(scopeKey, entry);
+			cachedRegistries.clear();
+			for (const scopeKey of retiredRegistries.keys()) disposeRetired(scopeKey);
+			maybeResolveDisposal();
+			await disposalBarrier.promise;
+		},
+		acquire: (context?: SdkHostModelResolveContext): (() => void) => {
+			const scopeKey = scopeKeyFor(context);
+			activeScopes.set(scopeKey, (activeScopes.get(scopeKey) ?? 0) + 1);
+			let released = false;
+			return () => {
+				if (released) return;
+				released = true;
+				const next = (activeScopes.get(scopeKey) ?? 1) - 1;
+				if (next <= 0) activeScopes.delete(scopeKey);
+				else activeScopes.set(scopeKey, next);
+				disposeRetired(scopeKey);
+				disposeEntries(evictIdleEntries());
+				maybeResolveDisposal();
+			};
+		},
+	});
 }
 
 export type SdkHostModelResolution =
 	| { ok: true; model: string | null }
 	| { ok: false; reason: "unknown_model"; model: string; error: string };
 
-export type SdkHostModelResolver = (
+export type SdkHostModelResolver = ((
 	raw: unknown,
 	context?: SdkHostModelResolveContext,
-) => Promise<SdkHostModelResolution>;
+) => Promise<SdkHostModelResolution>) & {
+	dispose?: () => Promise<void>;
+};
 
 /** Resolve the explicit model pin at the SDK host boundary. */
 export async function resolveSdkHostModel(
@@ -74,19 +226,24 @@ export async function resolveSdkHostModel(
 	if (raw === undefined || raw === null) return { ok: true, model: null };
 	const requested = typeof raw === "string" ? raw : "";
 	const echoed = requested.trim().slice(0, MAX_ECHOED_MODEL_LENGTH);
-	const registry = await loadRegistry(context);
-	const resolved: ResolveCliModelResult = resolveCliModel({ cliModel: requested, modelRegistry: registry });
-	if (!resolved.model)
+	const release = loadRegistry.acquire?.(context) ?? (() => {});
+	try {
+		const registry = await loadRegistry(context);
+		const resolved: ResolveCliModelResult = resolveCliModel({ cliModel: requested, modelRegistry: registry });
+		if (!resolved.model)
+			return {
+				ok: false,
+				reason: "unknown_model",
+				model: echoed,
+				error: resolved.error ?? "No models available. Check your installation or add models to models.json.",
+			};
 		return {
-			ok: false,
-			reason: "unknown_model",
-			model: echoed,
-			error: resolved.error ?? "No models available. Check your installation or add models to models.json.",
+			ok: true,
+			model: formatModelSelectorValue(formatModelString(resolved.model), resolved.thinkingLevel),
 		};
-	return {
-		ok: true,
-		model: formatModelSelectorValue(formatModelString(resolved.model), resolved.thinkingLevel),
-	};
+	} finally {
+		release();
+	}
 }
 
 /** Default resolver used by the SDK broker host. */
@@ -96,6 +253,9 @@ export function createDefaultSdkHostModelResolver(agentDir: string): SdkHostMode
 		path.join(agentDir, "models.yml"),
 		context => Settings.loadReadonly({ agentDir, cwd: context?.cwd }),
 	);
-	return (raw: unknown, context?: SdkHostModelResolveContext): Promise<SdkHostModelResolution> =>
-		resolveSdkHostModel(raw, loadRegistry, context);
+	return Object.assign(
+		(raw: unknown, context?: SdkHostModelResolveContext): Promise<SdkHostModelResolution> =>
+			resolveSdkHostModel(raw, loadRegistry, context),
+		{ dispose: loadRegistry.dispose },
+	);
 }

package/src/sdk/host/sdk-run-capability.ts

@@ -0,0 +1 @@
+export { createSdkRunCapability } from "../../session/sdk-run-capability-internal";