@gajae-code/coding-agent 0.16.3 → 0.16.6

package/src/sdk/session.ts

@@ -32,8 +32,10 @@ import {
 	$flag,
 	getAgentDbPath,
 	getAgentDir,
+	getAgentProfileAuthority,
 	getProjectDir,
 	logger,
+	normalizePathForComparison,
 	postmortem,
 	prompt,
 	Snowflake,
@@ -91,10 +93,14 @@ import { CustomToolAdapter } from "../extensibility/custom-tools/wrapper";
 import {
 	createCustomToolSettings,
 	type ExtensionContext,
+	type ExtensionEvent,
 	type ExtensionFactory,
 	ExtensionRunner,
 	ExtensionToolWrapper,
 	type ExtensionUIContext,
+	type FunctionHook,
+	type FunctionHookEventType,
+	type FunctionHookResult,
 	type LoadExtensionsResult,
 	loadExtensionFromFactory,
 	type ToolDefinition,
@@ -168,6 +174,7 @@ import {
 	unregisterOwnedRegistration,
 } from "../session/terminal-abort";
 import { formatNoModelsAvailableFallback } from "../setup/model-onboarding-guidance";
+import { getSkillFilesystemIdentity } from "../skill-state/canonical-skills";
 import {
 	type BuildSystemPromptResult,
 	buildSystemPrompt as buildSystemPromptInternal,
@@ -197,6 +204,11 @@ import { EventBus } from "../utils/event-bus";
 import { buildNamedToolChoice, buildNamedToolChoiceResult } from "../utils/tool-choice";
 import type { WorkspaceTree } from "../workspace-tree";
 import { createSessionLifecycleService } from "./lifecycle/client";
+import {
+	isStableSessionApiKeyCredentialType,
+	lookupSessionApiKey,
+	resolveLiveSessionApiKeyModel,
+} from "./session-api-key";
 import {
 	attachLifecycleStartupCapability,
 	lifecycleMcpStartupTimeoutOption,
@@ -433,6 +445,8 @@ export interface CreateAgentSessionOptions {
 	cwd?: string;
 	/** Global config directory. Default: ~/.gjc/agent */
 	agentDir?: string;
+	/** Resolver-owned classification for `agentDir`; required when authority must survive HOME/config refreshes. */
+	profileAuthority?: "default" | "custom";
 	/** Spawns to allow. Default: "*" */
 	spawns?: string;
 
@@ -776,10 +790,11 @@ export async function discoverSkills(
  */
 export async function discoverContextFiles(
 	cwd?: string,
-	_agentDir?: string,
+	agentDir?: string,
 ): Promise<Array<{ path: string; content: string; depth?: number }>> {
 	return await loadContextFilesInternal({
 		cwd: cwd ?? getProjectDir(),
+		agentDir,
 	});
 }
 
@@ -816,6 +831,8 @@ export interface BuildSystemPromptOptions {
 	skills?: Skill[];
 	contextFiles?: Array<{ path: string; content: string }>;
 	cwd?: string;
+	agentDir?: string;
+	profileAuthority?: "default" | "custom";
 	appendPrompt?: string;
 	repeatToolDescriptions?: boolean;
 }
@@ -829,6 +846,8 @@ export interface BuildSystemPromptOptions {
 export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}): Promise<BuildSystemPromptResult> {
 	return await buildSystemPromptInternal({
 		cwd: options.cwd,
+		agentDir: options.agentDir,
+		profileAuthority: options.profileAuthority,
 		skills: options.skills,
 		contextFiles: options.contextFiles,
 		appendSystemPrompt: options.appendPrompt,
@@ -1010,14 +1029,89 @@ export function createPluginHooksExtension(hooks: ConstrainedPluginHook[]): Exte
 			if (!normalized) throw new Error("Hook normalization invariant violated");
 			const registrationEvent = normalized.runtimeEvent;
 			const target = normalized.toolName === "*" ? undefined : normalized.toolName;
-			const handler = target
-				? (event: { toolName?: string; tool?: { name?: string }; name?: string }, ...rest: unknown[]) => {
-						const toolName = event?.toolName ?? event?.tool?.name ?? event?.name;
-						if (toolName !== target) return undefined;
-						return (hook.handler as (...a: unknown[]) => unknown)(event, ...rest);
+			if (!hook.functionHook) {
+				const legacyHandler: (...args: unknown[]) => unknown = target
+					? (event: unknown, ...rest: unknown[]) => {
+							const record = event as { toolName?: string; tool?: { name?: string }; name?: string } | undefined;
+							const toolName = record?.toolName ?? record?.tool?.name ?? record?.name;
+							if (toolName !== target) return undefined;
+							return (hook.handler as (...args: unknown[]) => unknown)(event, ...rest);
+						}
+					: (hook.handler as (...args: unknown[]) => unknown);
+				(api.on as (event: string, handler: (...args: unknown[]) => void) => void)(
+					registrationEvent,
+					legacyHandler,
+				);
+				continue;
+			}
+			const handler: FunctionHook = async (invocation, _capabilities, next) => {
+				const legacyResult = await (hook.handler as (...args: unknown[]) => unknown)(invocation.payload, undefined);
+				if (legacyResult === undefined) return await next();
+				if (invocation.eventType === "tool_call") {
+					const result = legacyResult as { block?: unknown; reason?: unknown; input?: unknown };
+					if (result.block === true) {
+						return {
+							action: "deny",
+							reason:
+								typeof result.reason === "string" ? result.reason : "Tool execution blocked by plugin hook",
+						};
+					}
+					if (result.input !== undefined) {
+						return {
+							action: "continue",
+							event: { ...invocation.payload, input: result.input as Record<string, unknown> } as ExtensionEvent,
+						} as FunctionHookResult;
+					}
+				}
+				if (invocation.eventType === "tool_result") {
+					const result = legacyResult as { content?: unknown; details?: unknown; isError?: unknown };
+					if (result.content !== undefined || result.details !== undefined || result.isError !== undefined) {
+						return {
+							action: "continue",
+							event: {
+								...invocation.payload,
+								...(result.content === undefined ? {} : { content: result.content }),
+								...(result.details === undefined ? {} : { details: result.details }),
+								...(result.isError === undefined ? {} : { isError: result.isError }),
+							},
+						} as FunctionHookResult;
+					}
+				}
+				if (invocation.eventType === "context" && (legacyResult as { messages?: unknown }).messages !== undefined) {
+					return {
+						action: "continue",
+						event: {
+							...invocation.payload,
+							messages: (legacyResult as { messages: unknown }).messages,
+						} as ExtensionEvent,
+					} as FunctionHookResult;
+				}
+				if (
+					invocation.eventType.startsWith("session_before_") &&
+					(legacyResult as { cancel?: unknown }).cancel === true
+				) {
+					return { action: "deny", reason: "Session change blocked by plugin hook" };
+				}
+				if (invocation.eventType === "before_agent_start") {
+					const result = legacyResult as { message?: unknown; systemPrompt?: unknown };
+					if (result.message !== undefined || result.systemPrompt !== undefined) {
+						return {
+							action: "return",
+							value: {
+								...(result.message === undefined ? {} : { messages: [result.message] }),
+								...(result.systemPrompt === undefined ? {} : { systemPrompt: result.systemPrompt }),
+							},
+						} as FunctionHookResult;
 					}
-				: hook.handler;
-			(api.on as (event: string, handler: (...args: unknown[]) => unknown) => void)(registrationEvent, handler);
+				}
+				return await next();
+			};
+			const options = {
+				...(target === undefined ? {} : { target }),
+				registrationId: hook.extensionId,
+				...(hook.grant ?? {}),
+			};
+			api.registerFunctionHook(registrationEvent as FunctionHookEventType, handler, options);
 		}
 	};
 }
@@ -1107,14 +1201,14 @@ function buildMCPPromptCommands(manager: MCPManager): LoadedCustomCommand[] {
 function withEmbeddedDefaultGjcSkills(skills: Skill[]): Skill[] {
 	const byName = new Map<string, Skill>();
 	for (const skill of skills) {
-		const key = skill.name.toLowerCase();
+		const key = getSkillFilesystemIdentity(skill.name);
 		if (!byName.has(key)) byName.set(key, skill);
 	}
 	// The four public GJC workflow skills are a product invariant: even if a
 	// caller-supplied or filesystem skill shares a name, the bundled definition
 	// wins so workflow routing can never be silently hijacked.
 	for (const defaultSkill of getEmbeddedDefaultGjcSkills()) {
-		byName.set(defaultSkill.name.toLowerCase(), defaultSkill);
+		byName.set(getSkillFilesystemIdentity(defaultSkill.name), defaultSkill);
 	}
 	return [...byName.values()];
 }
@@ -1388,7 +1482,14 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	}
 	const cwd = options.cwd ?? getProjectDir();
 	const explicitMcpConfigPath = !isCanonicalSubSession && !options.mcpManager ? options.mcpConfigPath : undefined;
-	const agentDir = options.agentDir ?? getDefaultAgentDir();
+	const agentDir = options.agentDir ?? options.settings?.getAgentDir() ?? getDefaultAgentDir();
+	const profileAuthority =
+		options.profileAuthority ??
+		(options.agentDir !== undefined || options.settings !== undefined
+			? normalizePathForComparison(agentDir) !== normalizePathForComparison(getAgentDir())
+				? "custom"
+				: getAgentProfileAuthority()
+			: getAgentProfileAuthority());
 	const eventBus = options.eventBus ?? new EventBus();
 	const hasInjectedAuth = options.authStorage !== undefined || options.modelRegistry !== undefined;
 
@@ -1576,7 +1677,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		// session-context build, tool creation, MCP discovery, and extension discovery.
 		const contextFilesResultPromise = options.contextFiles
 			? Promise.resolve({ contextFiles: options.contextFiles, warnings: [] })
-			: logger.time("discoverContextFiles", loadContextFilesResultInternal, { cwd });
+			: logger.time("discoverContextFiles", loadContextFilesResultInternal, { cwd, agentDir, profileAuthority });
 		contextFilesResultPromise.catch(() => {});
 		const promptTemplatesPromise = options.promptTemplates
 			? Promise.resolve(options.promptTemplates)
@@ -1977,9 +2078,10 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			skills = withEmbeddedDefaultGjcSkills(options.skills);
 			skillWarnings = [];
 		} else if (settings.get("skills.enabled")) {
-			const skillsResult = await logger.time("loadSkills", loadSkills, {
+			const skillsResult = await logger.time("discoverSkills", loadSkills, {
 				...settings.getGroup("skills"),
 				agentDir,
+				profileAuthority,
 				cwd,
 				disabledExtensions: settings.get("disabledExtensions"),
 			});
@@ -2001,7 +2103,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			const rulesResult =
 				options.rules !== undefined
 					? { items: options.rules, warnings: undefined }
-					: await loadCapability<Rule>(ruleCapability.id, { cwd, agentDir, settings });
+					: await loadCapability<Rule>(ruleCapability.id, { cwd, agentDir, profileAuthority, settings });
 			const rulebookRules: Rule[] = [];
 			const alwaysApplyRules: Rule[] = [];
 			for (const rule of rulesResult.items) {
@@ -2329,7 +2431,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		 */
 		const applyRescopedReadState = async (to: string): Promise<void> => {
 			try {
-				const rediscovered = await loadContextFilesResultInternal({ cwd: to });
+				const rediscovered = await loadContextFilesResultInternal({ cwd: to, agentDir, profileAuthority });
 				contextFiles = rediscovered.contextFiles;
 			} catch (error) {
 				logger.warn("Failed to re-discover context files after session rescope", {
@@ -2338,15 +2440,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			}
 			if (options.skills === undefined && settings.get("skills.enabled")) {
 				try {
-					const reloaded = await loadSkills({
-						...settings.getGroup("skills"),
-						agentDir,
-						cwd: to,
-						disabledExtensions: settings.get("disabledExtensions"),
-					});
-					skills = withEmbeddedDefaultGjcSkills(reloaded.skills);
-					if (!options.parentTaskPrefix) setActiveSkills(skills);
-					await session?.replaceSkills(skills);
+					await session?.reloadSkills(to);
 				} catch (error) {
 					logger.warn("Failed to reload skills after session rescope", { error: safeErrorForLog(error) });
 				}
@@ -2378,6 +2472,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				return sessionManager.getCwd();
 			},
 			hasUI: options.hasUI ?? false,
+			profileAuthority,
 			workflowGateEligible: true,
 			enableLsp,
 			get hasEditTool() {
@@ -2696,6 +2791,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 					}
 				: {}),
 			getSessionFile: () => sessionManager.getSessionFile() ?? null,
+			getSessionAgentDir: () => session?.getSessionAgentDir() ?? options.agentDir ?? settings.getAgentDir(),
 			getEvalKernelOwnerId: () => evalKernelOwnerId,
 			assertEvalExecutionAllowed: () => session?.assertEvalExecutionAllowed(),
 			trackEvalExecution: (execution, abortController) =>
@@ -2708,13 +2804,14 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				else signal.addEventListener("abort", () => resolve(), { once: true });
 				return promise;
 			},
+			getSessionId: () => sessionManager.getSessionId(),
 			// Subagents inherit the parent's manager; its registered endpoint is
 			// authoritative for owned-registration keying and endpoint-first
 			// manager lookup (the child's own id is never registered), so tools
 			// pass the same endpoint the manager's completion callback resolves
 			// (review thread P1). For a top-level session this equals the
 			// session id.
-			getSessionId: () => AsyncJobManager.endpointIdOf(asyncJobManager) ?? asyncJobEndpointId,
+			getAsyncEndpointId: () => AsyncJobManager.endpointIdOf(asyncJobManager) ?? asyncJobEndpointId,
 			registerForegroundFoldParticipant: adapter =>
 				session?.registerForegroundFoldParticipant(adapter) ?? (() => {}),
 			hasForegroundBashBackgroundRequestHandler: () => session?.hasForegroundBashBackgroundRequestHandler() ?? false,
@@ -2976,7 +3073,14 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				cwdCapturingToolNames.push(...pluginToolResult.tools.map(tool => tool.name));
 			}
 			for (const q of pluginToolResult.quarantine) {
-				gjcFindings.add({ identity: q.identity, surfaceId: q.surfaceId, code: q.code, message: q.message });
+				gjcFindings.add({
+					identity: q.identity,
+					surfaceId: q.surfaceId,
+					code: q.code,
+					message: q.message,
+					decision: "quarantined",
+					provenance: { source: "plugin-bundle", plugin: q.plugin },
+				});
 				logger.warn("Quarantined GJC plugin surface", { plugin: q.plugin, surface: q.surfaceId, code: q.code });
 			}
 		} catch (error) {
@@ -3066,7 +3170,14 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			try {
 				const { configs, quarantine } = await buildPluginMcpConfigs({ cwd });
 				for (const q of quarantine) {
-					gjcFindings.add({ identity: q.identity, surfaceId: q.surfaceId, code: q.code, message: q.message });
+					gjcFindings.add({
+						identity: q.identity,
+						surfaceId: q.surfaceId,
+						code: q.code,
+						message: q.message,
+						decision: "quarantined",
+						provenance: { source: "plugin-bundle", plugin: q.plugin },
+					});
 					logger.warn("Quarantined GJC plugin MCP", { plugin: q.plugin, surface: q.surfaceId, code: q.code });
 				}
 				const pluginNames = new Set(Object.keys(configs));
@@ -3211,12 +3322,22 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		// Always-on constrained plugin hooks (validated registry surfaces). Additive
 		// and a no-op without installed plugins; the loader denies all dangerous APIs.
 		try {
-			const pluginHookResult = await loadConstrainedPluginHooks({ cwd });
+			const pluginHookResult = await loadConstrainedPluginHooks({
+				cwd,
+				activationGeneration: gjcActivationGeneration,
+			});
 			if (pluginHookResult.hooks.length > 0) {
 				inlineExtensions.push(createPluginHooksExtension(pluginHookResult.hooks));
 			}
 			for (const q of pluginHookResult.quarantine) {
-				gjcFindings.add({ identity: q.identity, surfaceId: q.surfaceId, code: q.code, message: q.message });
+				gjcFindings.add({
+					identity: q.identity,
+					surfaceId: q.surfaceId,
+					code: q.code,
+					message: q.message,
+					decision: "quarantined",
+					provenance: { source: "plugin-bundle", plugin: q.plugin },
+				});
 				logger.warn("Quarantined GJC plugin hook", { plugin: q.plugin, surface: q.surfaceId, code: q.code });
 			}
 		} catch (error) {
@@ -3776,7 +3897,10 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		} else if (!toolRegistry.has("resolve")) {
 			const resolveTool = await logger.time("createTools:resolve:session", HIDDEN_TOOLS.resolve, toolSession);
 			if (resolveTool) {
-				const wrappedResolveTool = wrapToolWithMetaNotice(resolveTool);
+				const resolveWithNotice = wrapToolWithMetaNotice(resolveTool);
+				const wrappedResolveTool = extensionRunner
+					? (new ExtensionToolWrapper(resolveWithNotice, extensionRunner) as AgentTool)
+					: resolveWithNotice;
 				builtinCandidateTools.push(wrappedResolveTool);
 				toolRegistry.set(wrappedResolveTool.name, wrappedResolveTool);
 				builtinToolIdentities.add(wrappedResolveTool);
@@ -3914,6 +4038,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				// Live cwd: the prompt is rebuilt after a rescope, and describing the
 				// retired launcher root there is what makes the model pick wrong paths.
 				cwd: getLiveCwd(),
+				agentDir,
+				profileAuthority,
 				skills,
 				contextFiles,
 				tools: promptTools,
@@ -3924,6 +4050,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				appendSystemPrompt: appendPrompt,
 				pluginAppendices: pluginSystemAppendices,
 				repeatToolDescriptions,
+				reasoningLanguage: settings.get("reasoningLanguage"),
 				intentField,
 				toolDiscoveryActive: effectiveDiscoveryMode === "all" || mcpDiscoveryEnabled,
 				eagerTasks: resolveEagerTasks(),
@@ -4185,21 +4312,21 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			if (!obfuscator?.hasSecrets() || !obfuscateMessagesFn) return converted;
 			return obfuscateMessagesFn(obfuscator, converted);
 		};
-		const transformContext = async (messages: AgentMessage[], _signal?: AbortSignal, scope?: AttemptScopeRef) => {
+		const transformContext = async (messages: AgentMessage[], signal?: AbortSignal, scope?: AttemptScopeRef) => {
 			// External Agent events dispatch listeners without awaiting them. The
 			// session-owned barrier makes any pre-admission artifact transformation
 			// visible before this provider context is normalized.
 			await session?.awaitPendingContextTransformations();
-			return extensionRunner ? await extensionRunner.emitContext(messages, scope) : messages;
+			return extensionRunner ? await extensionRunner.emitContext(messages, scope, signal) : messages;
 		};
 		const onPayload = extensionRunner
-			? async (payload: unknown, _model?: Model, scope?: AttemptScopeRef) => {
-					return await extensionRunner.emitBeforeProviderRequest(payload, scope);
+			? async (payload: unknown, _model?: Model, scope?: AttemptScopeRef, signal?: AbortSignal) => {
+					return await extensionRunner.emitBeforeProviderRequest(payload, scope, signal);
 				}
 			: undefined;
 		const onResponse: SimpleStreamOptions["onResponse"] | undefined = extensionRunner
-			? async (response, model, scope) => {
-					await extensionRunner.emitAfterProviderResponse(response, model, scope);
+			? async (response, model, scope, signal) => {
+					await extensionRunner.emitAfterProviderResponse(response, model, scope, signal);
 				}
 			: undefined;
 
@@ -4257,6 +4384,32 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			).seedNormalizedMessages(options.forkContextSeed.messages);
 		}
 
+		const resolvedCredentialScopes = new Map<string, string | undefined>();
+		const resolveAgentApiKey = async (provider: string, signal?: AbortSignal): Promise<string> => {
+			const liveModel = resolveLiveSessionApiKeyModel(sessionAgent?.state.model, model, provider);
+			const hasExplicitScopePolicy =
+				modelRegistry.authStorage.hasSessionCredentialSelector(provider, credentialSessionId) ||
+				modelRegistry.authStorage.hasSessionCredentialAuto(provider, credentialSessionId);
+			const resolution = await lookupSessionApiKey(
+				modelRegistry,
+				provider,
+				credentialSessionId,
+				liveModel,
+				!hasExplicitScopePolicy,
+				signal,
+			);
+			resolvedCredentialScopes.set(provider, resolution.credentialSessionId);
+			return resolution.apiKey;
+		};
+		const resolvedCredentialType = (provider: string): "api_key" | "oauth" | undefined => {
+			const scope = resolvedCredentialScopes.has(provider)
+				? resolvedCredentialScopes.get(provider)
+				: credentialSessionId;
+			return modelRegistry.authStorage.getEffectiveCredentialType(provider, scope, {
+				owner: modelRegistry.getAuthStorageOwner(),
+			});
+		};
+
 		agent = new Agent({
 			initialState: {
 				systemPrompt,
@@ -4295,44 +4448,42 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			shouldPause: options.shouldPause,
 			preferWebsockets: preferOpenAICodexWebsockets,
 			getToolContext: tc => toolContextStore.getContext(tc),
-			getApiKey: async provider => {
+			getApiKey: provider => {
 				// AgentLoop asks by provider, but the active model carries the
 				// model-scoped credential selector. Read it at call time so model
 				// changes are honored after /new, fork, resume, or branch switches.
-				const liveModel = sessionAgent?.state.model ?? model;
-				const key =
-					liveModel?.provider === provider
-						? await modelRegistry.getApiKey(liveModel, credentialSessionId)
-						: undefined;
-				const providerKey = key ?? (await modelRegistry.getApiKeyForProvider(provider, credentialSessionId));
-				if (!providerKey) {
-					throw new Error(`No API key found for provider "${provider}"`);
-				}
-				return providerKey;
+				return resolveAgentApiKey(provider);
 			},
-			getAuthCredentialType: provider => modelRegistry.getSessionCredentialType(provider, credentialSessionId),
+			getAuthCredentialType: resolvedCredentialType,
 			streamFn: async (streamModel, context, streamOptions) => {
 				const requestStartedAt = performance.now();
 				let stream: Awaited<ReturnType<typeof streamSimple>>;
 				try {
-					const effectiveApiKey = await modelRegistry.getApiKey(streamModel, credentialSessionId);
 					stream = await streamSimple(streamModel, context, {
 						...streamOptions,
-						apiKey: effectiveApiKey,
-						authCredentialType: modelRegistry.getSessionCredentialType(streamModel.provider, credentialSessionId),
 						onAuthError: async (provider, oldKey, error) => {
+							const resolvedScope = resolvedCredentialScopes.has(provider)
+								? resolvedCredentialScopes.get(provider)
+								: credentialSessionId;
 							await modelRegistry.authStorage.invalidateCredentialMatching(provider, oldKey, {
 								signal: streamOptions?.signal,
-								sessionId: credentialSessionId,
+								sessionId: resolvedScope,
 								owner: modelRegistry.getAuthStorageOwner(),
 							});
 							logger.debug("Retrying provider request after credential invalidation", {
 								provider,
 								error: error instanceof Error ? error.message : String(error),
 							});
-							return modelRegistry.getApiKey(streamModel, credentialSessionId, {
-								signal: streamOptions?.signal,
-							});
+							const replacementApiKey = await resolveAgentApiKey(provider, streamOptions?.signal);
+							if (
+								!isStableSessionApiKeyCredentialType(
+									streamOptions?.authCredentialType,
+									resolvedCredentialType(provider),
+								)
+							) {
+								return undefined;
+							}
+							return replacementApiKey;
 						},
 					});
 				} catch (error) {
@@ -4459,6 +4610,28 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			customCommands: customCommandsResult.commands,
 			skills,
 			skillWarnings,
+			reloadSkills:
+				options.skills === undefined
+					? async reloadCwd => {
+							if (!settings.get("skills.enabled")) {
+								return { skills: getEmbeddedDefaultGjcSkills(), warnings: [] };
+							} else {
+								const reloaded = await loadSkills({
+									...settings.getGroup("skills"),
+									agentDir,
+									profileAuthority,
+									cwd: reloadCwd,
+									disabledExtensions: settings.get("disabledExtensions"),
+								});
+								return { skills: withEmbeddedDefaultGjcSkills(reloaded.skills), warnings: reloaded.warnings };
+							}
+						}
+					: undefined,
+			onSkillsReloaded: (reloadedSkills, reloadedWarnings) => {
+				skills = reloadedSkills;
+				skillWarnings = reloadedWarnings;
+				if (!options.parentTaskPrefix) setActiveSkills(reloadedSkills);
+			},
 			skillsSettings: settings.getGroup("skills"),
 			modelRegistry,
 			taskDepth,

package/src/sdk/transport/relay.ts

@@ -56,18 +56,25 @@ function upstreamUrl(url: string, token: string): string {
 	return endpoint.toString();
 }
 
-function waitForDrain(stream: Writable): Promise<void> {
+function waitForDrain(stream: Writable): { promise: Promise<void>; cancel: () => void } {
 	const { promise, reject, resolve } = Promise.withResolvers<void>();
+	let settled = false;
 	const onDrain = (): void => done(resolve);
 	const onError = (error: Error): void => done(() => reject(error));
+	const onClose = (): void => done(() => reject(new Error("downstream_closed")));
 	const done = (callback: () => void): void => {
+		if (settled) return;
+		settled = true;
 		stream.removeListener("drain", onDrain);
 		stream.removeListener("error", onError);
+		stream.removeListener("close", onClose);
 		callback();
 	};
 	stream.once("drain", onDrain);
 	stream.once("error", onError);
-	return promise;
+	stream.once("close", onClose);
+	if (stream.destroyed) onClose();
+	return { promise, cancel: onDrain };
 }
 
 const WEBSOCKET_CONNECTING = 0;
@@ -96,7 +103,9 @@ export async function startRelayPair(options: RelayOptions): Promise<RelayPair>
 	const finished = Promise.withResolvers<void>();
 	let closed = false;
 	let completed = false;
-	let downstreamBuffer = Buffer.alloc(0);
+	let downstreamChunks: Buffer[] = [];
+	let downstreamBytes = 0;
+	let downstreamDrain: { promise: Promise<void>; cancel: () => void } | undefined;
 	const toWs: QueuedFrame[] = [];
 	const toDownstream: QueuedFrame[] = [];
 	let pendingToWs = 0;
@@ -123,6 +132,7 @@ export async function startRelayPair(options: RelayOptions): Promise<RelayPair>
 	const close = async (error?: Error): Promise<void> => {
 		if (closed) return finished.promise.catch(() => undefined);
 		closed = true;
+		downstreamDrain?.cancel();
 		detach();
 		options.downstream.pause();
 		if (ws.readyState === WEBSOCKET_OPEN || ws.readyState === WEBSOCKET_CONNECTING) ws.close();
@@ -175,33 +185,45 @@ export async function startRelayPair(options: RelayOptions): Promise<RelayPair>
 		writingDownstream = true;
 		if (frame.accounted) pendingToDownstream -= frame.bytes.length;
 		try {
-			if (!options.downstreamSink.write(frame.bytes)) await waitForDrain(options.downstreamSink);
+			if (!options.downstreamSink.write(frame.bytes) && !closed) {
+				downstreamDrain = waitForDrain(options.downstreamSink);
+				await downstreamDrain.promise;
+			}
 		} catch (error) {
 			await close(error instanceof Error ? error : new Error(String(error)));
 			return;
 		} finally {
+			downstreamDrain = undefined;
 			writingDownstream = false;
 		}
 		void pumpDownstream();
 	};
 	const consumeLines = (chunk: Buffer): void => {
-		downstreamBuffer = Buffer.concat([downstreamBuffer, chunk]);
-		let newline = downstreamBuffer.indexOf(0x0a);
+		let start = 0;
+		let newline = chunk.indexOf(0x0a);
 		while (newline >= 0) {
-			const line = downstreamBuffer.subarray(0, newline);
-			downstreamBuffer = downstreamBuffer.subarray(newline + 1);
-			if (line.length === 0)
+			const length = downstreamBytes + newline - start;
+			if (length === 0)
 				return fail({ type: "transport_error", code: "protocol_error", direction: "downstream->ws" });
-			if (line.length > REQUEST_FRAME_BYTES)
+			if (length > REQUEST_FRAME_BYTES)
 				return fail({ type: "transport_error", code: "frame_oversize", direction: "downstream->ws" });
+			downstreamChunks.push(chunk.subarray(start, newline));
+			const line = Buffer.concat(downstreamChunks, length);
+			downstreamChunks = [];
+			downstreamBytes = 0;
 			if (options.validateDownstreamFrame && !options.validateDownstreamFrame(line.toString("utf8")))
 				return fail({ type: "transport_error", code: "protocol_error", direction: "downstream->ws" });
 			enqueue(toWs, "downstream->ws", line);
 			if (closed) return;
-			newline = downstreamBuffer.indexOf(0x0a);
+			start = newline + 1;
+			newline = chunk.indexOf(0x0a, start);
+		}
+		if (start < chunk.length) {
+			downstreamBytes += chunk.length - start;
+			if (downstreamBytes > REQUEST_FRAME_BYTES)
+				return fail({ type: "transport_error", code: "frame_oversize", direction: "downstream->ws" });
+			downstreamChunks.push(chunk.subarray(start));
 		}
-		if (downstreamBuffer.length > REQUEST_FRAME_BYTES)
-			fail({ type: "transport_error", code: "frame_oversize", direction: "downstream->ws" });
 	};
 	const onData = (chunk: Buffer | string): void => consumeLines(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
 	const onEnd = (): void => void close();

package/src/sdk/transport/serve-cli.ts

@@ -92,10 +92,10 @@ function brokerSessionRows(sessions: readonly unknown[]): BrokerSessionRow[] {
 }
 
 /** Exhausts strict broker `session.list` pages into one full session snapshot. */
-export async function listBrokerSessions(broker: SdkClient): Promise<BrokerSessionRow[]> {
+export async function listBrokerSessions(broker: SdkClient, explicitSessionId?: string): Promise<BrokerSessionRow[]> {
 	try {
 		const pages = await traverseSessionList(
-			{},
+			{ ...(explicitSessionId ? { resolveSessionId: explicitSessionId } : {}) },
 			async input => await broker.global("session.list", input),
 			response => {
 				brokerResult(response);
@@ -147,7 +147,7 @@ export async function runSdkServe(argv: string[]): Promise<void> {
 		throw new Error("broker_unavailable: SDK broker is not reachable");
 	}
 	try {
-		const sessionId = selectBrokerSession(await listBrokerSessions(broker), parsed.sessionId);
+		const sessionId = selectBrokerSession(await listBrokerSessions(broker, parsed.sessionId), parsed.sessionId);
 		const endpoint = brokerResult(await broker.global("session.get_endpoint", { sessionId }));
 		const url = typeof endpoint.url === "string" && endpoint.url ? endpoint.url : undefined;
 		const token = typeof endpoint.token === "string" ? endpoint.token : "";