awb-agent-manager 1.6.205 → 1.6.207

package/dist/lib/agent-session-runner.d.ts

@@ -1,11 +1,11 @@
 import { AgentSessionStore } from './agent-session-store.js';
-import { type AwbConfig } from './rest.js';
+import { type AgentSessionConfigOptionPatch, type AwbConfig } from './rest.js';
 import type { AcpMcpServer } from './runtime/acp/acp-types.js';
 export interface AgentSessionRequest {
     manager_id: string;
     workspace_id?: string;
     cli: string;
-    op: 'list' | 'history' | 'open' | 'prompt' | 'permission' | 'cancel' | 'set_mode' | 'close';
+    op: 'list' | 'history' | 'open' | 'prompt' | 'permission' | 'elicitation' | 'cancel' | 'set_mode' | 'set_config_option' | 'close';
     request_id?: string;
     session_id?: string | null;
     cwd?: string;
@@ -15,6 +15,11 @@ export interface AgentSessionRequest {
     permission_request_id?: string;
     option_id?: string | null;
     mode_id?: string;
+    config_id?: string;
+    config_value?: string | boolean;
+    elicitation_id?: string;
+    elicitation_action?: 'accept' | 'decline' | 'cancel';
+    elicitation_content?: Record<string, unknown> | null;
     credential_id?: string | null;
     driver_user_id: string;
     issued_at: string;
@@ -45,7 +50,19 @@ export interface SessionCredential {
 }
 export declare const SESSION_CLI_CREDENTIAL_PREFIX: Record<string, string>;
 export declare function redactSecrets(text: string): string;
+type CommandPatch = {
+    name: string;
+    description: string;
+    input_hint?: string;
+};
 export declare const ACP_SESSION_CLIS: readonly ["claude", "codex", "hermes"];
+export declare function parseConfigOptions(raw: unknown): AgentSessionConfigOptionPatch[];
+export declare function parseCommands(raw: unknown): CommandPatch[];
+export declare function parsePlanEntries(raw: unknown): Array<{
+    content: string;
+    priority: string;
+    status: string;
+}> | null;
 export declare function findOnPath(name: string): Promise<string | null>;
 export declare function resolveAcpCommandForCli(cli: string): Promise<ResolvedAcpCommand>;
 export declare function detectAcpSessionClis(env?: NodeJS.ProcessEnv): Promise<string[]>;
@@ -63,3 +80,4 @@ export declare class AgentSessionRunner {
     handle(request: AgentSessionRequest): Promise<void>;
     stopAll(reason?: string): Promise<void>;
 }
+export {};

package/dist/lib/agent-session-runner.js

@@ -68,6 +68,89 @@ function boundedPayload(payload) {
         return bounded;
     return { truncated: true, preview: serialized.slice(0, 4_000) };
 }
+export function parseConfigOptions(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    for (const entry of raw) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const o = entry;
+        const configId = typeof o.configId === 'string' ? o.configId : typeof o.config_id === 'string' ? o.config_id : '';
+        if (!configId)
+            continue;
+        const type = typeof o.type === 'string' ? o.type : (typeof o.currentValue === 'boolean' ? 'boolean' : 'select');
+        const options = [];
+        const pushOption = (v, group) => {
+            if (!v || typeof v !== 'object')
+                return;
+            const opt = v;
+            const value = typeof opt.value === 'string' ? opt.value : typeof opt.id === 'string' ? opt.id : '';
+            if (!value)
+                return;
+            options.push({
+                value,
+                name: typeof opt.name === 'string' && opt.name ? opt.name : value,
+                ...(typeof opt.description === 'string' && opt.description ? { description: opt.description } : {}),
+                ...(group ? { group } : {}),
+            });
+        };
+        if (Array.isArray(o.options)) {
+            for (const v of o.options) {
+                const g = v;
+                if (g && typeof g === 'object' && Array.isArray(g.options)) {
+                    const label = typeof g.name === 'string' ? g.name : typeof g.group === 'string' ? g.group : '';
+                    for (const inner of g.options)
+                        pushOption(inner, label || undefined);
+                }
+                else {
+                    pushOption(v);
+                }
+            }
+        }
+        const current = o.currentValue ?? o.current_value;
+        out.push({
+            config_id: configId,
+            name: typeof o.name === 'string' && o.name ? o.name : configId,
+            ...(typeof o.description === 'string' && o.description ? { description: o.description } : {}),
+            category: typeof o.category === 'string' && o.category ? o.category : 'unknown',
+            type,
+            current_value: typeof current === 'boolean' ? current : typeof current === 'string' ? current : null,
+            options,
+        });
+    }
+    return out;
+}
+export function parseCommands(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    for (const entry of raw) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const c = entry;
+        const name = typeof c.name === 'string' ? c.name.trim().replace(/^\//, '') : '';
+        if (!name)
+            continue;
+        const input = c.input && typeof c.input === 'object' ? c.input : null;
+        const hint = input && typeof input.hint === 'string' ? input.hint : '';
+        out.push({ name, description: typeof c.description === 'string' ? c.description : '', ...(hint ? { input_hint: hint } : {}) });
+    }
+    return out;
+}
+export function parsePlanEntries(raw) {
+    if (!Array.isArray(raw))
+        return null;
+    const entries = raw
+        .filter((e) => !!e && typeof e === 'object')
+        .map((e) => ({
+        content: typeof e.content === 'string' ? e.content.slice(0, 2_000) : '',
+        priority: typeof e.priority === 'string' ? e.priority : 'medium',
+        status: typeof e.status === 'string' ? e.status : 'pending',
+    }))
+        .filter((e) => e.content);
+    return entries;
+}
 export async function findOnPath(name) {
     const candidates = process.platform === 'win32' ? [`${name}.cmd`, `${name}.exe`, name] : [name];
     for (const dir of (process.env.PATH || '').split(delimiter)) {
@@ -100,7 +183,7 @@ export async function resolveAcpCommandForCli(cli) {
         }
         case 'codex': {
             const found = await findOnPath('codex-acp');
-            return found ? { command: found, args: [] } : { command: 'npx', args: ['--yes', '@zed-industries/codex-acp'] };
+            return found ? { command: found, args: [] } : { command: 'npx', args: ['--yes', '@agentclientprotocol/codex-acp'] };
         }
         case 'hermes': {
             const resolved = await resolveHermesAcpCommand();
@@ -126,6 +209,7 @@ export class AgentSessionRunner {
     #store;
     #live = new Map();
     #opening = new Map();
+    #exited = [];
     constructor(config, options) {
         this.#config = config;
         this.#store = options.store ?? new AgentSessionStore();
@@ -151,7 +235,7 @@ export class AgentSessionRunner {
         return Array.from(this.#live.values()).map((live) => ({
             cli: live.cli,
             session_id: live.sessionId,
-            busy: live.turn !== null || live.pendingPermissions.size > 0,
+            busy: live.turn !== null || live.pendingPermissions.size > 0 || live.pendingElicitations.size > 0,
             pid: live.client.process.pid ?? null,
         }));
     }
@@ -185,6 +269,16 @@ export class AgentSessionRunner {
                 case 'permission':
                     this.#resolvePermission(cli, sessionId, request.permission_request_id || '', request.option_id ?? null);
                     return;
+                case 'elicitation':
+                    this.#resolveElicitation(cli, sessionId, request.elicitation_id || '', request.elicitation_action || 'cancel', request.elicitation_content ?? null);
+                    return;
+                case 'set_config_option': {
+                    const live = this.#live.get(this.#key(cli, sessionId));
+                    if (!live || !request.config_id || request.config_value === undefined)
+                        return;
+                    await this.#setConfigOption(live, request.config_id, request.config_value);
+                    return;
+                }
                 case 'cancel': {
                     const live = this.#live.get(this.#key(cli, sessionId));
                     if (live)
@@ -197,6 +291,7 @@ export class AgentSessionRunner {
                     if (!live || !modeId)
                         return;
                     await live.client.request('session/set_mode', { sessionId: live.sessionId, modeId }, { timeoutMs: this.#options.requestTimeoutMs });
+                    live.currentMode = modeId;
                     this.#enqueue(live, [{ type: 'system', payload: { text: `Mode set to ${modeId}.` } }], { current_mode: modeId, reason: 'mode' });
                     return;
                 }
@@ -245,11 +340,17 @@ export class AgentSessionRunner {
                         await postAgentSessionRpcResponse(this.#config, managerId, requestId, { ok: false, error: 'Session not found on this Runtime Host.', code: 'not_found' });
                         return;
                     }
+                    const pending = live
+                        ? [...Array.from(live.pendingPermissions.values()), ...Array.from(live.pendingElicitations.values())].map((p) => p.event)
+                        : [];
+                    const events = pending.length
+                        ? [...history.events, ...pending.map((e, i) => ({ ...e, seq: history.events.length + i + 1 }))]
+                        : history.events;
                     await postAgentSessionRpcResponse(this.#config, managerId, requestId, {
                         ok: true,
                         result: {
                             session: history.session ?? (live ? this.#summaryOf(live) : null),
-                            events: history.events,
+                            events,
                             truncated: history.truncated,
                             live: live ? this.#stateOf(live) : null,
                         },
@@ -274,6 +375,10 @@ export class AgentSessionRunner {
     async stopAll(reason = 'manager_shutdown') {
         const keys = Array.from(this.#live.values()).map((l) => [l.cli, l.sessionId]);
         await Promise.all(keys.map(([cli, id]) => this.#closeLive(cli, id, 'idle', reason).catch(() => undefined)));
+        const drains = this.#exited.splice(0).map((l) => l.postChain);
+        if (drains.length) {
+            await Promise.race([Promise.all(drains), new Promise((resolve) => setTimeout(resolve, 3_000).unref?.())]);
+        }
     }
     async #ensureLive(cli, sessionId, cwd, title, request) {
         if (sessionId) {
@@ -316,25 +421,34 @@ export class AgentSessionRunner {
         const auth = await this.#prepareAuth(cli, cwd, request);
         log(`${tag} spawning ACP adapter cmd=${command} ${args.join(' ')} cwd=${cwd} auth=${auth.label}`);
         let live = null;
+        const env = this.#buildEnv(cli, requestedSessionId || 'new', auth);
         const client = await AcpClient.spawn({
             command,
             args,
             cwd,
-            env: this.#buildEnv(cli, requestedSessionId || 'new', auth),
+            env,
             requestTimeoutMs: this.#options.requestTimeoutMs,
             onEvent: (event) => { if (live)
                 this.#onEvent(live, event); },
             onPermissionRequest: (permission) => (live ? this.#onPermission(live, permission) : Promise.resolve({ outcome: 'cancelled' })),
+            onElicitation: (elicitation) => (live ? this.#onElicitation(live, elicitation) : Promise.resolve({ action: 'cancel' })),
             onStderr: (line) => log(`${tag} stderr: ${redactSecrets(line)}`),
             spawnOptions: { detached: process.platform !== 'win32' },
         });
         try {
             const initialized = await client.initialize({
                 clientInfo: { name: 'awb-agent-session', version: this.#options.clientVersion || '1' },
-                clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
+                clientCapabilities: {
+                    fs: { readTextFile: false, writeTextFile: false },
+                    terminal: false,
+                    elicitation: { form: {}, url: {} },
+                    session: { configOptions: { boolean: {} } },
+                    plan: {},
+                },
             });
             const caps = (initialized?.agentCapabilities ?? {});
             const loadSupported = caps.loadSession === true;
+            const authMethods = Array.isArray(initialized?.authMethods) ? initialized.authMethods : [];
             const sessionIdForMcp = requestedSessionId || 'new';
             const mcpServers = this.#options.mcpServers ? this.#options.mcpServers(sessionIdForMcp) : this.#defaultMcpServers(sessionIdForMcp);
             live = {
@@ -346,6 +460,11 @@ export class AgentSessionRunner {
                 loadSupported,
                 loading: false,
                 pendingPermissions: new Map(),
+                pendingElicitations: new Map(),
+                configOptions: [],
+                availableCommands: [],
+                currentMode: null,
+                availableModes: [],
                 turn: null,
                 textBuffer: '',
                 reasoningBuffer: '',
@@ -359,6 +478,7 @@ export class AgentSessionRunner {
                 exited: false,
             };
             let modes;
+            let configOptions;
             let resumed = false;
             if (requestedSessionId) {
                 if (!loadSupported) {
@@ -366,8 +486,9 @@ export class AgentSessionRunner {
                 }
                 live.loading = true;
                 try {
-                    const loaded = await client.loadSession({ sessionId: requestedSessionId, cwd, mcpServers });
+                    const loaded = await this.#withAuthRetry(client, cli, authMethods, env, () => client.loadSession({ sessionId: requestedSessionId, cwd, mcpServers }));
                     modes = loaded?.modes;
+                    configOptions = loaded?.configOptions;
                     resumed = true;
                 }
                 finally {
@@ -375,9 +496,10 @@ export class AgentSessionRunner {
                 }
             }
             else {
-                const created = await client.newSession({ cwd, mcpServers });
+                const created = await this.#withAuthRetry(client, cli, authMethods, env, () => client.newSession({ cwd, mcpServers }));
                 live.sessionId = created.sessionId;
                 modes = created.modes;
+                configOptions = created.configOptions;
                 await this.#store.recordAwbSession({ cli, session_id: live.sessionId, cwd, title }).catch(() => undefined);
             }
             if (!live.sessionId)
@@ -386,6 +508,9 @@ export class AgentSessionRunner {
             this.#live.set(key, live);
             client.process.once('exit', (code, signal) => this.#onProcessExit(key, code, signal));
             const modeInfo = this.#parseModes(modes);
+            live.currentMode = modeInfo.current;
+            live.availableModes = modeInfo.available;
+            live.configOptions = parseConfigOptions(configOptions);
             this.#enqueue(live, [{
                     type: 'system',
                     payload: {
@@ -398,6 +523,8 @@ export class AgentSessionRunner {
                 ...(title ? { title } : {}),
                 current_mode: modeInfo.current,
                 available_modes: modeInfo.available,
+                config_options: live.configOptions,
+                available_commands: live.availableCommands,
                 resume_supported: loadSupported,
                 last_error: null,
                 reason: resumed ? 'resumed' : 'opened',
@@ -422,8 +549,52 @@ export class AgentSessionRunner {
         env.AWB_MANAGER_ID = this.#options.getManagerId();
         env.AWB_SESSION_CLI = cli;
         env.AWB_SESSION_ID = sessionId;
+        if (cli === 'codex' && env.NO_BROWSER === undefined)
+            env.NO_BROWSER = '1';
         return env;
     }
+    async #withAuthRetry(client, cli, authMethods, env, run) {
+        try {
+            return await run();
+        }
+        catch (err) {
+            const rpcCode = err?.rpcCode ?? err?.code;
+            const message = String(err?.message ?? '');
+            const authRequired = rpcCode === -32000 || /auth(entication)? required|not (logged|signed) in|unauthenticated/i.test(message);
+            if (!authRequired)
+                throw err;
+            const methods = authMethods
+                .filter((m) => !!m && typeof m === 'object')
+                .map((m) => ({ id: String(m.id ?? ''), name: String(m.name ?? m.id ?? ''), type: String(m.type ?? '') }))
+                .filter((m) => m.id);
+            const hasApiKey = !!(env.CODEX_API_KEY || env.OPENAI_API_KEY || env.ANTHROPIC_API_KEY || env.CLAUDE_CODE_OAUTH_TOKEN);
+            const apiKeyMethod = methods.find((m) => /api[-_]?key|token/i.test(m.id) || /api[-_]?key|token/i.test(m.name));
+            if (hasApiKey && apiKeyMethod) {
+                log(`[agent-session ${cli}] authentication required — trying ACP auth method ${apiKeyMethod.id}`);
+                await client.authenticate(apiKeyMethod.id, { timeoutMs: this.#options.requestTimeoutMs });
+                return await run();
+            }
+            const listed = methods.length ? ` Available methods: ${methods.map((m) => m.name || m.id).join(', ')}.` : '';
+            throw Object.assign(new Error(`Authentication required for ${cli} on this Runtime Host — run \`${cli} login\` there, or bind a credential in CLI settings.${listed}`), { code: 'auth_required' });
+        }
+    }
+    async #setConfigOption(live, configId, value) {
+        const before = live.configOptions.find((o) => o.config_id === configId);
+        const response = await live.client.setConfigOption(typeof value === 'boolean'
+            ? { sessionId: live.sessionId, configId, type: 'boolean', value }
+            : { sessionId: live.sessionId, configId, type: 'id', value }, { timeoutMs: this.#options.requestTimeoutMs });
+        if (Array.isArray(response?.configOptions))
+            live.configOptions = parseConfigOptions(response.configOptions);
+        else if (before) {
+            before.current_value = value;
+        }
+        const after = live.configOptions.find((o) => o.config_id === configId);
+        const label = after?.name || before?.name || configId;
+        const chosen = typeof value === 'boolean'
+            ? (value ? 'on' : 'off')
+            : (after?.options.find((o) => o.value === value)?.name || String(value));
+        this.#enqueue(live, [{ type: 'system', payload: { text: `${label} set to ${chosen}.` } }], { config_options: live.configOptions, reason: 'config_option' });
+    }
     async #prepareAuth(cli, cwd, request) {
         const none = { label: 'operator-login', env: {}, stripEnvKeys: [], cliHome: null };
         const credentialId = request.credential_id || '';
@@ -511,6 +682,8 @@ export class AgentSessionRunner {
             return 'idle';
         if (live.pendingPermissions.size > 0)
             return 'awaiting_permission';
+        if (live.pendingElicitations.size > 0)
+            return 'awaiting_input';
         if (live.turn)
             return 'busy';
         return 'ready';
@@ -526,6 +699,10 @@ export class AgentSessionRunner {
             title: live.title,
             status: this.#statusOf(live),
             resume_supported: live.loadSupported,
+            current_mode: live.currentMode,
+            available_modes: live.availableModes,
+            config_options: live.configOptions,
+            available_commands: live.availableCommands,
         };
     }
     async #runPrompt(live, turnId, text) {
@@ -622,10 +799,53 @@ export class AgentSessionRunner {
             case 'diagnostic': {
                 const data = (event.data ?? {});
                 const kind = String(data.sessionUpdate ?? data.session_update ?? '');
-                if (event.method === 'session/update' && kind === 'current_mode_update') {
-                    const modeId = String(data.currentModeId ?? data.current_mode_id ?? '');
-                    if (modeId)
-                        this.#enqueue(live, [], { current_mode: modeId, reason: 'mode' });
+                if (event.method === 'session/update') {
+                    switch (kind) {
+                        case 'current_mode_update': {
+                            const modeId = String(data.currentModeId ?? data.current_mode_id ?? '');
+                            if (modeId) {
+                                live.currentMode = modeId;
+                                this.#enqueue(live, [], { current_mode: modeId, reason: 'mode' });
+                            }
+                            return;
+                        }
+                        case 'config_option_update':
+                            live.configOptions = parseConfigOptions(data.configOptions ?? data.config_options);
+                            this.#enqueue(live, [], { config_options: live.configOptions, reason: 'config_option' });
+                            return;
+                        case 'available_commands_update':
+                            live.availableCommands = parseCommands(data.availableCommands ?? data.available_commands);
+                            this.#enqueue(live, [], { available_commands: live.availableCommands, reason: 'commands' });
+                            return;
+                        case 'plan':
+                        case 'plan_update': {
+                            const entries = parsePlanEntries(kind === 'plan' ? data.entries : data.plan?.entries ?? data.entries);
+                            if (entries) {
+                                this.#flushBuffers(live, turnId);
+                                this.#enqueue(live, [{ type: 'plan', payload: { entries }, turn_id: turnId }]);
+                            }
+                            return;
+                        }
+                        case 'plan_removed':
+                            return;
+                        case 'session_info_update': {
+                            const title = typeof data.title === 'string' ? data.title.trim().slice(0, 200) : '';
+                            if (title && title !== live.title) {
+                                live.title = title;
+                                this.#enqueue(live, [], { title, reason: 'title' });
+                                void this.#store.touchAwbSession(live.cli, live.sessionId, { title }).catch(() => undefined);
+                            }
+                            return;
+                        }
+                        default:
+                            break;
+                    }
+                }
+                if (event.method === 'elicitation/complete') {
+                    const elicitationId = String(data.elicitationId ?? data.elicitation_id ?? '');
+                    if (elicitationId) {
+                        this.#enqueue(live, [{ type: 'elicitation_decision', payload: { elicitation_id: elicitationId, action: 'accept', decided_by: 'agent' }, turn_id: turnId }]);
+                    }
                     return;
                 }
                 log(`[agent-session ${live.cli} ${live.sessionId.slice(0, 8)}] diagnostic ${event.method}${kind ? ` (${kind})` : ''}`);
@@ -642,12 +862,16 @@ export class AgentSessionRunner {
         this.#flushBuffers(live, turnId);
         const requestId = randomUUID();
         const options = (permission.options ?? []).map((o) => ({ option_id: o.optionId, name: o.name, kind: o.kind }));
-        this.#enqueue(live, [{
+        const meta = (permission._meta?.permission ?? null);
+        const title = permission.title || permission.toolCall?.title || (typeof meta?.title === 'string' ? meta.title : '');
+        const description = permission.description || (typeof meta?.description === 'string' ? meta.description : '');
+        const [requestEvent] = this.#enqueue(live, [{
                 type: 'permission_request',
                 payload: {
                     request_id: requestId,
-                    tool_call_id: permission.toolCall?.toolCallId ?? '',
-                    title: permission.toolCall?.title ?? '',
+                    tool_call_id: permission.toolCall?.toolCallId ?? permission.subject?.toolCallId ?? '',
+                    title,
+                    ...(description ? { description } : {}),
                     kind: permission.toolCall?.kind ?? '',
                     options,
                     raw_input: boundedValue(permission.toolCall?.rawInput ?? permission.toolCall?.raw_input),
@@ -665,9 +889,88 @@ export class AgentSessionRunner {
                 resolve({ outcome: 'cancelled' });
             }, this.#options.permissionTimeoutMs);
             timer.unref?.();
-            live.pendingPermissions.set(requestId, { resolve, timer });
+            live.pendingPermissions.set(requestId, { resolve, timer, event: requestEvent });
         });
     }
+    #cancelPendingPermissions(live) {
+        const events = [];
+        for (const [requestId, pending] of live.pendingPermissions) {
+            clearTimeout(pending.timer);
+            live.pendingPermissions.delete(requestId);
+            events.push({
+                type: 'permission_decision',
+                payload: { request_id: requestId, outcome: 'cancelled', option_id: null, decided_by: 'system' },
+                turn_id: live.turn?.turnId,
+            });
+            pending.resolve({ outcome: 'cancelled' });
+        }
+        for (const [elicitationId, pending] of live.pendingElicitations) {
+            clearTimeout(pending.timer);
+            live.pendingElicitations.delete(elicitationId);
+            events.push({
+                type: 'elicitation_decision',
+                payload: { elicitation_id: elicitationId, action: 'cancel', decided_by: 'system' },
+                turn_id: live.turn?.turnId,
+            });
+            pending.resolve({ action: 'cancel' });
+        }
+        if (events.length)
+            this.#enqueue(live, events);
+    }
+    async #onElicitation(live, request) {
+        if (live.loading)
+            return { action: 'cancel' };
+        const turnId = live.turn?.turnId;
+        this.#flushBuffers(live, turnId);
+        const mode = request.mode === 'url' ? 'url' : 'form';
+        const elicitationId = (mode === 'url' && typeof request.elicitationId === 'string' && request.elicitationId) ? request.elicitationId : randomUUID();
+        const payload = {
+            elicitation_id: elicitationId,
+            mode,
+            message: typeof request.message === 'string' ? request.message.slice(0, 8_000) : '',
+            tool_call_id: typeof request.toolCallId === 'string' ? request.toolCallId : '',
+        };
+        if (mode === 'form')
+            payload.schema = boundedValue(request.requestedSchema ?? {});
+        if (mode === 'url')
+            payload.url = typeof request.url === 'string' ? request.url.slice(0, 2_048) : '';
+        if (mode === 'url') {
+            this.#enqueue(live, [{ type: 'elicitation_request', payload, turn_id: turnId }]);
+            return { action: 'accept' };
+        }
+        const [requestEvent] = this.#enqueue(live, [{ type: 'elicitation_request', payload, turn_id: turnId }], { status: 'awaiting_input', reason: 'elicitation' });
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                live.pendingElicitations.delete(elicitationId);
+                this.#enqueue(live, [{
+                        type: 'elicitation_decision',
+                        payload: { elicitation_id: elicitationId, action: 'cancel', decided_by: 'timeout' },
+                        turn_id: live.turn?.turnId,
+                    }], { status: this.#statusOf(live) === 'awaiting_input' ? 'busy' : this.#statusOf(live), reason: 'elicitation_timeout' });
+                resolve({ action: 'cancel' });
+            }, this.#options.permissionTimeoutMs);
+            timer.unref?.();
+            live.pendingElicitations.set(elicitationId, { resolve, timer, event: requestEvent });
+        });
+    }
+    #resolveElicitation(cli, sessionId, elicitationId, action, content) {
+        const live = this.#live.get(this.#key(cli, sessionId));
+        if (!live)
+            return;
+        const pending = live.pendingElicitations.get(elicitationId);
+        if (!pending) {
+            log(`[agent-session ${cli} ${sessionId.slice(0, 8)}] elicitation ${elicitationId.slice(0, 8)} not pending (late or duplicate answer)`);
+            return;
+        }
+        clearTimeout(pending.timer);
+        live.pendingElicitations.delete(elicitationId);
+        this.#enqueue(live, [{
+                type: 'elicitation_decision',
+                payload: { elicitation_id: elicitationId, action, ...(action === 'accept' ? { content: boundedValue(content ?? {}) } : {}), decided_by: 'user' },
+                turn_id: live.turn?.turnId,
+            }], { status: live.pendingPermissions.size > 0 ? 'awaiting_permission' : 'busy', reason: `elicitation_${action}` });
+        pending.resolve(action === 'accept' ? { action: 'accept', content: content ?? {} } : { action });
+    }
     #resolvePermission(cli, sessionId, requestId, optionId) {
         const live = this.#live.get(this.#key(cli, sessionId));
         if (!live)
@@ -724,6 +1027,7 @@ export class AgentSessionRunner {
             ? postAgentSessionEvents(this.#config, ref, stamped, state ?? null)
             : Promise.resolve({ ok: true, status: 204 })))
             .then(() => undefined, () => undefined);
+        return stamped;
     }
     #touch(live) {
         this.#clearIdle(live);
@@ -733,7 +1037,7 @@ export class AgentSessionRunner {
         if (ms <= 0)
             return;
         live.idleTimer = setTimeout(() => {
-            if (live.turn || live.pendingPermissions.size > 0) {
+            if (live.turn || live.pendingPermissions.size > 0 || live.pendingElicitations.size > 0) {
                 this.#touch(live);
                 return;
             }
@@ -752,19 +1056,20 @@ export class AgentSessionRunner {
         if (!live)
             return;
         live.exited = true;
-        for (const [id, pending] of live.pendingPermissions) {
-            clearTimeout(pending.timer);
-            pending.resolve({ outcome: 'cancelled' });
-            live.pendingPermissions.delete(id);
-        }
         this.#clearIdle(live);
-        if (live.closing)
+        if (live.closing) {
+            this.#cancelPendingPermissions(live);
             return;
+        }
         this.#live.delete(key);
         const detail = `Agent process exited (${signal ? `signal ${signal}` : `code ${code ?? 'unknown'}`}).`;
         log(`[agent-session ${live.cli} ${live.sessionId.slice(0, 8)}] ${detail}`);
         this.#flushBuffers(live, live.turn?.turnId);
-        this.#enqueue(live, [{ type: 'system', payload: { text: `${detail} The next prompt reopens the session.` } }], live.turn ? undefined : { status: 'idle', reason: 'process_exit' });
+        this.#cancelPendingPermissions(live);
+        this.#enqueue(live, [{ type: 'system', payload: { text: `${detail} The next prompt reopens the session.` } }], { status: 'idle', reason: 'process_exit' });
+        this.#exited.push(live);
+        if (this.#exited.length > 50)
+            this.#exited.splice(0, this.#exited.length - 50);
     }
     async #closeLive(cli, sessionId, finalStatus, reason = finalStatus) {
         const key = this.#key(cli, sessionId);
@@ -773,11 +1078,7 @@ export class AgentSessionRunner {
             return;
         live.closing = true;
         this.#clearIdle(live);
-        for (const [id, pending] of live.pendingPermissions) {
-            clearTimeout(pending.timer);
-            pending.resolve({ outcome: 'cancelled' });
-            live.pendingPermissions.delete(id);
-        }
+        this.#cancelPendingPermissions(live);
         if (live.turn)
             await live.client.cancel(live.sessionId).catch(() => undefined);
         this.#flushBuffers(live, live.turn?.turnId);