@gajae-code/coding-agent 0.15.4 → 0.15.6

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

@@ -1,7 +1,9 @@
 import { randomBytes } from "node:crypto";
 import * as fsSync from "node:fs";
 import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { getAgentDir } from "@gajae-code/utils";
+import { repo as resolveGitRepository } from "../../utils/git";
 import { ensureBroker } from "../broker/ensure";
 import { lifecycleRequestTimeoutMs } from "../broker/startup-budget";
 import { SdkClientError } from "../client";
@@ -14,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";
@@ -38,10 +44,12 @@ export type SdkSessionCliAction =
 	| "status"
 	| "tail"
 	| "retire"
+	| "global"
 	| "raw"
 	| "control"
 	| "query"
 	| "global";
+export type SdkSessionListScope = "repo" | "cwd" | "worktree" | "all";
 export type SdkSessionCliRawKind = "control" | "query" | "global";
 
 export interface SdkSessionCliArgs {
@@ -56,6 +64,7 @@ export interface SdkSessionCliArgs {
 	jsonInputFile?: string;
 	jsonInputStdin?: boolean;
 	idempotencyKey?: string;
+	scope?: string;
 	confirm?: boolean;
 	cursor?: string;
 	wait?: boolean;
@@ -358,16 +367,156 @@ async function sessionRows(agentDir: string): Promise<SessionRows> {
 	});
 }
 
-async function runList(agentDir: string): Promise<unknown> {
+const SESSION_LIST_SCOPES: readonly SdkSessionListScope[] = ["repo", "cwd", "worktree", "all"];
+/** Row workspaces whose locator cannot be canonicalized still get one deterministic identity. */
+const WORKSPACE_IDENTITY_CACHE_LIMIT = 4096;
+
+interface WorkspaceIdentity {
+	/** Canonical workspace path (realpath when it exists, lexical resolve otherwise). */
+	canonicalPath: string;
+	/** Canonical containing worktree root; null outside a Git checkout. */
+	repoRoot: string | null;
+	/** Canonical Git common dir; shared by the main checkout and linked worktrees. */
+	commonDir: string | null;
+}
+
+export interface SdkSessionListSelection {
+	scope: SdkSessionListScope;
+	selection: WorkspaceIdentity;
+	/** Bounded, credential-free descriptor included in list output. */
+	descriptor: {
+		scope: SdkSessionListScope;
+		path: string;
+		worktreeRoot?: string;
+		commonDir?: string;
+	};
+}
+
+/** Parses `--scope`; missing means `repo`, anything else invalid is a usage error. */
+export function parseSessionListScope(value: string | undefined): SdkSessionListScope {
+	if (value === undefined) return "repo";
+	if ((SESSION_LIST_SCOPES as readonly string[]).includes(value)) return value as SdkSessionListScope;
+	throw new SdkSessionCliError(
+		"usage",
+		`Invalid scope "${value}". Expected one of: ${SESSION_LIST_SCOPES.join(", ")}.`,
+		2,
+	);
+}
+
+async function canonicalWorkspacePath(target: string): Promise<string> {
+	try {
+		return await fs.realpath(target);
+	} catch {
+		// A removed or unreadable workspace keeps a deterministic lexical identity
+		// instead of guessing a broader or narrower one.
+		return path.resolve(target);
+	}
+}
+
+const workspaceIdentityCache = new Map<string, WorkspaceIdentity>();
+
+/** Resolves (and caches) the Git identity of one workspace locator. */
+async function workspaceIdentity(target: string): Promise<WorkspaceIdentity> {
+	const canonicalPath = await canonicalWorkspacePath(target);
+	const cached = workspaceIdentityCache.get(canonicalPath);
+	if (cached) return cached;
+	if (target === "unknown") {
+		const unavailable = { canonicalPath, repoRoot: null, commonDir: null };
+		workspaceIdentityCache.set(canonicalPath, unavailable);
+		return unavailable;
+	}
+	try {
+		if (!(await fs.stat(target)).isDirectory()) throw new Error("workspace is not a directory");
+	} catch {
+		// A removed or unreadable locator cannot prove Git membership. Keeping it
+		// outside every identity is the narrowest safe result for row filtering.
+		const unavailable = { canonicalPath, repoRoot: null, commonDir: null };
+		workspaceIdentityCache.set(canonicalPath, unavailable);
+		return unavailable;
+	}
+	const repository = await resolveGitRepository.resolve(canonicalPath);
+	const identity: WorkspaceIdentity = repository
+		? {
+				canonicalPath,
+				repoRoot: await canonicalWorkspacePath(repository.repoRoot),
+				commonDir: await canonicalWorkspacePath(repository.commonDir),
+			}
+		: { canonicalPath, repoRoot: null, commonDir: null };
+	if (workspaceIdentityCache.size >= WORKSPACE_IDENTITY_CACHE_LIMIT) workspaceIdentityCache.clear();
+	workspaceIdentityCache.set(canonicalPath, identity);
+	return identity;
+}
+
+/**
+ * Resolves the list selection from `--repo` (default: process cwd) under the
+ * effective scope. Outside Git, `repo`/`worktree` fail typed and actionable —
+ * they never broaden to `all`; `cwd` remains an exact canonical match.
+ */
+export async function resolveSessionListSelection(
+	scope: SdkSessionListScope,
+	repoArg: string | undefined,
+): Promise<SdkSessionListSelection> {
+	const selection = await workspaceIdentity(repoArg ?? process.cwd());
+	if (scope !== "cwd" && !selection.repoRoot)
+		throw new SdkSessionCliError(
+			"not_a_repository",
+			`--scope ${scope} requires a Git repository, but "${selection.canonicalPath}" is outside any Git checkout. ` +
+				"Use --scope cwd for an exact workspace match or --scope all for the full broker listing.",
+			1,
+		);
+	const descriptor: SdkSessionListSelection["descriptor"] = {
+		scope,
+		path: selection.canonicalPath,
+		...(selection.repoRoot ? { worktreeRoot: selection.repoRoot, commonDir: selection.commonDir! } : {}),
+	};
+	return { scope, selection, descriptor };
+}
+
+/**
+ * Filters fully traversed broker rows by the selection scope. Row workspaces
+ * are canonicalized and cached per distinct locator; `repo` matches the shared
+ * common dir across the main checkout and linked worktrees, `worktree` the
+ * containing worktree only, and `cwd` the exact canonical workspace.
+ */
+export async function filterSessionRowsByScope(
+	rows: readonly SdkSessionRowV1[],
+	scope: SdkSessionListScope,
+	selection: SdkSessionListSelection,
+): Promise<{ sessions: SdkSessionRowV1[]; warnings: string[] }> {
+	if (scope === "all") return { sessions: [...rows], warnings: [] };
+	const warnings: string[] = [];
+	const sessions: SdkSessionRowV1[] = [];
+	for (const row of rows) {
+		const identity = await workspaceIdentity(row.locator.repo);
+		let keep: boolean;
+		if (scope === "cwd") keep = identity.canonicalPath === selection.selection.canonicalPath;
+		else if (scope === "worktree")
+			keep = identity.repoRoot !== null && identity.repoRoot === selection.selection.repoRoot;
+		else keep = identity.commonDir !== null && identity.commonDir === selection.selection.commonDir;
+		if (keep) sessions.push(row);
+		else if (identity.repoRoot === null && identity.commonDir === null)
+			warnings.push(
+				`Session ${row.sessionId} workspace "${row.locator.repo}" is outside Git; excluded by scope ${scope}.`,
+			);
+	}
+	return { sessions, warnings };
+}
+
+async function runList(agentDir: string, args: SdkSessionCliArgs): Promise<unknown> {
+	const scope = parseSessionListScope(args.scope);
+	const { selection, descriptor } = await resolveSessionListSelection(scope, args.repo);
 	const listing = await sessionRows(agentDir);
+	const filtered = await filterSessionRowsByScope(listing.sessions, scope, { scope, selection, descriptor });
 	return {
 		ok: true,
 		result: {
 			version: SESSION_ROWS_VERSION,
 			source: "broker",
+			scope,
+			selection: descriptor,
 			...(listing.indexSeq === undefined ? {} : { indexSeq: listing.indexSeq }),
-			sessions: listing.sessions,
-			warnings: listing.warnings,
+			sessions: filtered.sessions,
+			warnings: [...listing.warnings, ...filtered.warnings],
 		},
 	};
 }
@@ -509,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())
@@ -769,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(
 		{
@@ -1367,7 +1523,7 @@ export async function runSdkSessionCli(
 			);
 		const agentDir = args.agentDir ?? getAgentDir();
 		if (action === "list") {
-			writeOutput(stripSecretFields(await runList(agentDir)));
+			writeOutput(stripSecretFields(await runList(agentDir, args)));
 			return;
 		}
 		if (action === "inspect") {

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/host.ts

@@ -49,6 +49,8 @@ export interface SessionSdkHostOptions extends HostEndpointAdapters {
 	query?: (connectionId: string, frame: SdkFrame) => unknown | Promise<unknown>;
 	/** Test/lifecycle seam invoked synchronously before fire-and-forget dispatch. */
 	onFrameAdmitted?: (connectionId: string, frame: SdkFrame) => void;
+	/** Synchronously rejects external input while a runtime is being replaced. */
+	onFrameAdmission?: (connectionId: string, frame: SdkFrame) => SdkFrame | undefined;
 	/** Best-effort diagnostic observation of accepted control/query frames. */
 	onRequest?: SdkRequestObserver;
 	/** Runs before a control response is sent; identity transitions use sendTerminal. */
@@ -408,6 +410,11 @@ export class SessionSdkHost {
 
 	async #onFrame(connectionId: string, frame: SdkFrame): Promise<void> {
 		try {
+			const admissionRejection = this.#options.onFrameAdmission?.(connectionId, frame);
+			if (admissionRejection !== undefined) {
+				await this.#send(connectionId, admissionRejection);
+				return;
+			}
 			switch (frame.type) {
 				case "control_request": {
 					this.#observeRequest("control", connectionId, frame);

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";