awb-agent-manager 1.6.199 → 1.6.201

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

@@ -1,12 +1,37 @@
-import { access, constants as fsConstants } from 'node:fs/promises';
+import { access, constants as fsConstants, lstat, mkdir, symlink } from 'node:fs/promises';
 import { randomUUID } from 'node:crypto';
-import { delimiter, dirname, join } from 'node:path';
-import { createAdapter } from './cli-adapters/index.js';
+import { delimiter, join } from 'node:path';
+import { AgentSessionStore, resolveClaudeHome, resolveCodexHome } from './agent-session-store.js';
+import { AGENT_MANAGER_HOME } from './constants.js';
+import { normalizeCredentialFields } from './credential-fields.js';
 import { log } from './logging.js';
 import { terminateDetachedProcessTree } from './process-tree.js';
-import { patchAgentSession, postAgentSessionEvents, } from './rest.js';
+import { fetchSessionCredential, postAgentSessionEvents, postAgentSessionRpcResponse, } from './rest.js';
+import { createRuntimeCliAdapter } from './runtime/runtime-registry.js';
 import { AcpClient } from './runtime/acp/acp-client.js';
 import { resolveHermesAcpCommand } from './runtime/hermes/hermes-command.js';
+export const SESSION_CLI_CREDENTIAL_PREFIX = {
+    claude: 'claude_',
+    codex: 'codex_',
+};
+const SESSION_REQUIRED_CREDENTIAL_FIELDS = {
+    claude_subscription: ['credentials_json'],
+    claude_api_key: ['api_key'],
+    claude_oauth_token: ['oauth_token'],
+    codex_subscription: ['auth_json'],
+    codex_api_key: ['api_key'],
+};
+export function redactSecrets(text) {
+    return String(text ?? '')
+        .replace(/Bearer\s+[^\s"'`]+/gi, 'Bearer <redacted>')
+        .replace(/sk-ant-[A-Za-z0-9_-]{8,}/g, 'sk-ant-<redacted>')
+        .replace(/sk-[A-Za-z0-9_-]{16,}/g, 'sk-<redacted>')
+        .replace(/(api[_-]?key|oauth[_-]?token|access[_-]?token|refresh[_-]?token)(["']?\s*[:=]\s*["']?)[^\s"',}]+/gi, '$1$2<redacted>');
+}
+const SESSION_STORE_SUBDIR = {
+    claude: 'projects',
+    codex: 'sessions',
+};
 const DEFAULT_IDLE_MINUTES = 30;
 const DEFAULT_PERMISSION_TIMEOUT_MS = 15 * 60_000;
 const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
@@ -15,6 +40,7 @@ const DEFAULT_FLUSH_INTERVAL_MS = 150;
 const MAX_TOOL_TEXT_CHARS = 16_000;
 const MAX_PAYLOAD_CHARS = 200_000;
 const ALLOW_KINDS = new Set(['allow_once', 'allow_always', 'allow_session']);
+export const ACP_SESSION_CLIS = ['claude', 'codex', 'hermes'];
 function truncateText(value, max) {
     return value.length > max ? `${value.slice(0, max)}\n…[truncated ${value.length - max} chars]` : value;
 }
@@ -42,7 +68,7 @@ function boundedPayload(payload) {
         return bounded;
     return { truncated: true, preview: serialized.slice(0, 4_000) };
 }
-async function findOnPath(name) {
+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)) {
         if (!dir)
@@ -63,45 +89,48 @@ function parseCommandLine(line) {
     const parts = line.trim().split(/\s+/).filter(Boolean);
     return { command: parts[0] || '', args: parts.slice(1) };
 }
-export async function resolveAcpCommandForRuntime(runtime, ctx) {
-    const extra = (ctx.runtime_config?.extra ?? {});
-    if (typeof extra.acp_command === 'string' && extra.acp_command.trim()) {
-        const args = Array.isArray(extra.acp_args) ? extra.acp_args.map((a) => String(a)) : [];
-        return { command: extra.acp_command.trim(), args };
-    }
-    const envOverride = process.env[`AWB_ACP_COMMAND_${runtime.toUpperCase()}`]?.trim();
+export async function resolveAcpCommandForCli(cli) {
+    const envOverride = process.env[`AWB_ACP_COMMAND_${cli.toUpperCase()}`]?.trim();
     if (envOverride)
         return parseCommandLine(envOverride);
-    switch (runtime) {
-        case 'claude':
-        case 'deepseek': {
+    switch (cli) {
+        case 'claude': {
             const found = await findOnPath('claude-agent-acp');
-            return found
-                ? { command: found, args: [] }
-                : { command: 'npx', args: ['--yes', '@agentclientprotocol/claude-agent-acp'] };
+            return found ? { command: found, args: [] } : { command: 'npx', args: ['--yes', '@agentclientprotocol/claude-agent-acp'] };
         }
         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', '@zed-industries/codex-acp'] };
         }
         case 'hermes': {
             const resolved = await resolveHermesAcpCommand();
             return { command: resolved.command, args: [...resolved.argsPrefix] };
         }
         default:
-            throw new Error(`No ACP adapter is known for runtime "${runtime}". Set runtime_config.extra.acp_command on the agent.`);
+            throw new Error(`No ACP adapter is known for CLI "${cli}".`);
     }
 }
+export async function detectAcpSessionClis(env = process.env) {
+    const out = [];
+    if (env.AWB_ACP_COMMAND_CLAUDE || await findOnPath('claude-agent-acp') || await findOnPath('claude'))
+        out.push('claude');
+    if (env.AWB_ACP_COMMAND_CODEX || await findOnPath('codex-acp') || await findOnPath('codex'))
+        out.push('codex');
+    if (env.AWB_ACP_COMMAND_HERMES || env.HERMES_ACP_COMMAND || await findOnPath('hermes-acp') || await findOnPath('hermes'))
+        out.push('hermes');
+    return out;
+}
 export class AgentSessionRunner {
     #config;
     #options;
+    #store;
     #live = new Map();
     #opening = new Map();
-    constructor(config, options = {}) {
+    constructor(config, options) {
         this.#config = config;
+        this.#store = options.store ?? new AgentSessionStore();
         this.#options = {
+            getManagerId: options.getManagerId,
             idleMinutes: options.idleMinutes ?? DEFAULT_IDLE_MINUTES,
             permissionTimeoutMs: options.permissionTimeoutMs ?? DEFAULT_PERMISSION_TIMEOUT_MS,
             requestTimeoutMs: options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
@@ -110,13 +139,18 @@ export class AgentSessionRunner {
             commandResolver: options.commandResolver,
             baseEnv: options.baseEnv,
             clientVersion: options.clientVersion,
+            mcpServers: options.mcpServers,
+            sessionHomesDir: options.sessionHomesDir ?? join(AGENT_MANAGER_HOME, 'session-homes'),
+            credentialFetcher: options.credentialFetcher,
         };
     }
+    get store() {
+        return this.#store;
+    }
     _snapshot() {
         return Array.from(this.#live.values()).map((live) => ({
+            cli: live.cli,
             session_id: live.sessionId,
-            agent_id: live.agentId,
-            runtime: live.runtime,
             busy: live.turn !== null || live.pendingPermissions.size > 0,
             pid: live.client.process.pid ?? null,
         }));
@@ -124,194 +158,247 @@ export class AgentSessionRunner {
     countInFlight() {
         return this._snapshot().filter((s) => s.busy).length;
     }
-    async handle(request, ctx) {
-        const sid = request.session_id;
-        if (!sid || !request.agent_id)
-            return;
-        const tag = `[agent-session ${sid.slice(0, 8)}]`;
-        if (!ctx) {
-            if (request.op === 'open' || request.op === 'prompt' || request.op === 'set_mode') {
-                log(`${tag} ${request.op}: agent ${request.agent_id.slice(0, 8)} has no bootstrapped context on this manager`);
-                await patchAgentSession(this.#config, sid, request.agent_id, {
-                    status: 'error',
-                    last_error: 'This agent is registered on the Runtime Host but its runtime context is not bootstrapped (missing api key / working_dir). Spawn or restart the agent from the AI Agents page, then prompt again.',
-                    reason: 'agent_context_missing',
-                });
-            }
+    #ref(cli, sessionId) {
+        return { manager_id: this.#options.getManagerId(), cli, session_id: sessionId };
+    }
+    #key(cli, sessionId) {
+        return `${cli}:${sessionId}`;
+    }
+    async handle(request) {
+        const cli = String(request.cli || '').toLowerCase();
+        const sessionId = request.session_id || '';
+        const tag = `[agent-session ${cli}${sessionId ? ` ${sessionId.slice(0, 8)}` : ''}]`;
+        if (request.request_id) {
+            await this.#handleRpc(request, cli, sessionId, tag);
             return;
         }
-        const rest = { ...this.#config, apiKey: ctx.api_key, retryApiKey: this.#config.apiKey };
-        const liveBefore = this.#live.get(sid);
+        const liveBefore = sessionId ? this.#live.get(this.#key(cli, sessionId)) : undefined;
         try {
             switch (request.op) {
-                case 'open':
-                    await this.#ensureLive(request, ctx, rest);
-                    return;
                 case 'prompt': {
-                    const live = await this.#ensureLive(request, ctx, rest);
+                    if (!sessionId)
+                        return;
+                    const live = await this.#ensureLive(cli, sessionId, request.cwd || '', request.title || '', request);
                     await this.#runPrompt(live, request.turn_id || randomUUID(), request.text || '');
                     return;
                 }
                 case 'permission':
-                    this.#resolvePermission(sid, request.request_id || '', request.option_id ?? null);
+                    this.#resolvePermission(cli, sessionId, request.permission_request_id || '', request.option_id ?? null);
                     return;
                 case 'cancel': {
-                    const live = this.#live.get(sid);
-                    if (!live)
-                        return;
-                    await live.client.cancel(live.nativeSessionId).catch(() => undefined);
+                    const live = this.#live.get(this.#key(cli, sessionId));
+                    if (live)
+                        await live.client.cancel(live.sessionId).catch(() => undefined);
                     return;
                 }
                 case 'set_mode': {
-                    const live = await this.#ensureLive(request, ctx, rest);
+                    const live = this.#live.get(this.#key(cli, sessionId));
                     const modeId = request.mode_id || '';
-                    if (!modeId)
+                    if (!live || !modeId)
                         return;
-                    await live.client.request('session/set_mode', { sessionId: live.nativeSessionId, modeId }, { timeoutMs: this.#options.requestTimeoutMs });
+                    await live.client.request('session/set_mode', { sessionId: live.sessionId, modeId }, { timeoutMs: this.#options.requestTimeoutMs });
                     this.#enqueue(live, [{ type: 'system', payload: { text: `Mode set to ${modeId}.` } }], { current_mode: modeId, reason: 'mode' });
                     return;
                 }
                 case 'close':
-                    await this.#closeLive(sid, 'closed');
+                    await this.#closeLive(cli, sessionId, 'closed');
                     return;
                 default:
                     log(`${tag} unknown op ${String(request.op)}`);
             }
-            const settled = this.#live.get(sid) ?? liveBefore;
+            const settled = this.#live.get(this.#key(cli, sessionId)) ?? liveBefore;
             if (settled)
                 await settled.postChain;
         }
         catch (err) {
-            const message = err?.message ?? String(err);
+            const message = redactSecrets(err?.message ?? String(err));
             log(`${tag} ${request.op} failed: ${message}`);
-            const live = this.#live.get(sid);
+            const live = this.#live.get(this.#key(cli, sessionId));
+            const failure = { type: 'error', payload: { message, code: err?.code ?? undefined }, turn_id: request.turn_id };
+            const state = { status: live?.turn ? 'busy' : 'error', last_error: message, reason: `${request.op}_failed` };
             if (live) {
-                this.#enqueue(live, [{ type: 'error', payload: { message, code: err?.code ?? undefined }, turn_id: request.turn_id }], {
-                    status: live.turn ? 'busy' : 'error',
-                    last_error: message,
-                    reason: `${request.op}_failed`,
-                });
+                this.#enqueue(live, [failure], state);
+                await live.postChain;
             }
-            else {
-                await postAgentSessionEvents(rest, sid, ctx.agent_id, [{ type: 'error', payload: { message, code: err?.code ?? undefined }, turn_id: request.turn_id }], {
-                    status: 'error',
-                    last_error: message,
-                    reason: `${request.op}_failed`,
-                });
+            else if (sessionId) {
+                await postAgentSessionEvents(this.#config, this.#ref(cli, sessionId), [{ ...failure, seq: 0, id: `${sessionId}:err:${Date.now()}`, created_at: new Date().toISOString() }], state);
             }
         }
     }
+    async #handleRpc(request, cli, sessionId, tag) {
+        const requestId = request.request_id;
+        const managerId = this.#options.getManagerId();
+        try {
+            switch (request.op) {
+                case 'list': {
+                    const sessions = await this.#store.listSessions(cli);
+                    const withLive = sessions.map((s) => ({ ...s, live_status: this.#live.get(this.#key(cli, s.session_id)) ? this.#statusOf(this.#live.get(this.#key(cli, s.session_id))) : undefined }));
+                    await postAgentSessionRpcResponse(this.#config, managerId, requestId, { ok: true, result: { sessions: withLive } });
+                    return;
+                }
+                case 'history': {
+                    if (!sessionId)
+                        throw Object.assign(new Error('session_id is required'), { code: 'not_found' });
+                    const history = await this.#store.readHistory(cli, sessionId);
+                    const live = this.#live.get(this.#key(cli, sessionId));
+                    if (!history.session && !live) {
+                        await postAgentSessionRpcResponse(this.#config, managerId, requestId, { ok: false, error: 'Session not found on this Runtime Host.', code: 'not_found' });
+                        return;
+                    }
+                    await postAgentSessionRpcResponse(this.#config, managerId, requestId, {
+                        ok: true,
+                        result: {
+                            session: history.session ?? (live ? this.#summaryOf(live) : null),
+                            events: history.events,
+                            truncated: history.truncated,
+                            live: live ? this.#stateOf(live) : null,
+                        },
+                    });
+                    return;
+                }
+                case 'open': {
+                    const live = await this.#ensureLive(cli, sessionId, request.cwd || '', request.title || '', request);
+                    await postAgentSessionRpcResponse(this.#config, managerId, requestId, { ok: true, result: this.#stateOf(live) });
+                    return;
+                }
+                default:
+                    await postAgentSessionRpcResponse(this.#config, managerId, requestId, { ok: false, error: `Unknown RPC op ${String(request.op)}`, code: 'bad_request' });
+            }
+        }
+        catch (err) {
+            const message = redactSecrets(err?.message ?? String(err));
+            log(`${tag} ${request.op} rpc failed: ${message}`);
+            await postAgentSessionRpcResponse(this.#config, managerId, requestId, { ok: false, error: message, code: err?.code ?? 'manager_error' });
+        }
+    }
     async stopAll(reason = 'manager_shutdown') {
-        const ids = Array.from(this.#live.keys());
-        await Promise.all(ids.map((id) => this.#closeLive(id, 'suspended', reason).catch(() => undefined)));
-    }
-    async #ensureLive(request, ctx, rest) {
-        const sid = request.session_id;
-        const existing = this.#live.get(sid);
-        if (existing && !existing.exited && !existing.closing)
-            return existing;
-        const inFlight = this.#opening.get(sid);
-        if (inFlight)
-            return inFlight;
-        const opening = this.#open(request, ctx, rest).finally(() => this.#opening.delete(sid));
-        this.#opening.set(sid, opening);
+        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)));
+    }
+    async #ensureLive(cli, sessionId, cwd, title, request) {
+        if (sessionId) {
+            const existing = this.#live.get(this.#key(cli, sessionId));
+            if (existing && !existing.exited && !existing.closing) {
+                const wanted = request.credential_id || '';
+                if (existing.credentialId === wanted || existing.turn)
+                    return existing;
+                log(`[agent-session ${cli} ${sessionId.slice(0, 8)}] credential binding changed (${existing.credentialId || 'operator-login'} → ${wanted || 'operator-login'}); reopening`);
+                await this.#closeLive(cli, sessionId, 'idle', 'credential_changed');
+            }
+            const inFlight = this.#opening.get(this.#key(cli, sessionId));
+            if (inFlight)
+                return inFlight;
+        }
+        const opening = this.#open(cli, sessionId, cwd, title, request);
+        if (sessionId) {
+            this.#opening.set(this.#key(cli, sessionId), opening);
+            opening.finally(() => this.#opening.delete(this.#key(cli, sessionId))).catch(() => undefined);
+        }
         return opening;
     }
-    async #open(request, ctx, rest) {
-        const sid = request.session_id;
-        const tag = `[agent-session ${sid.slice(0, 8)}]`;
-        const runtime = (request.runtime || ctx.cli || 'claude').toLowerCase();
-        const cwd = (request.cwd || ctx.cwd || '').trim();
+    async #open(cli, requestedSessionId, requestedCwd, title, request) {
+        const tag = `[agent-session ${cli}${requestedSessionId ? ` ${requestedSessionId.slice(0, 8)}` : ' new'}]`;
+        let cwd = requestedCwd.trim();
+        if (requestedSessionId && !cwd) {
+            const history = await this.#store.readHistory(cli, requestedSessionId).catch(() => null);
+            cwd = history?.session?.cwd || '';
+        }
         if (!cwd)
-            throw new Error('No working directory: set cwd on the session or working_dir on the agent.');
+            throw new Error('No working directory: pass cwd for a new session.');
         try {
             await access(cwd, fsConstants.R_OK);
         }
         catch {
             throw new Error(`Working directory does not exist on this Runtime Host: ${cwd}`);
         }
-        const resolver = this.#options.commandResolver ?? resolveAcpCommandForRuntime;
-        const { command, args } = await resolver(runtime, ctx);
-        const env = this.#buildEnv(runtime, ctx, sid);
-        log(`${tag} spawning ACP adapter runtime=${runtime} cmd=${command} ${args.join(' ')} cwd=${cwd}`);
+        const resolver = this.#options.commandResolver ?? resolveAcpCommandForCli;
+        const { command, args } = await resolver(cli);
+        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 client = await AcpClient.spawn({
             command,
             args,
             cwd,
-            env,
+            env: this.#buildEnv(cli, requestedSessionId || 'new', auth),
             requestTimeoutMs: this.#options.requestTimeoutMs,
-            onEvent: (event) => this.#onEvent(sid, event),
-            onPermissionRequest: (permission) => this.#onPermission(sid, permission),
-            onStderr: (line) => log(`${tag} stderr: ${line}`),
+            onEvent: (event) => { if (live)
+                this.#onEvent(live, event); },
+            onPermissionRequest: (permission) => (live ? this.#onPermission(live, permission) : Promise.resolve({ outcome: 'cancelled' })),
+            onStderr: (line) => log(`${tag} stderr: ${redactSecrets(line)}`),
             spawnOptions: { detached: process.platform !== 'win32' },
         });
-        const live = {
-            sessionId: sid,
-            agentId: ctx.agent_id,
-            workspaceId: request.workspace_id,
-            runtime,
-            cwd,
-            client,
-            nativeSessionId: '',
-            loadSupported: false,
-            permissionPolicy: request.permission_policy || 'ask',
-            rest,
-            pendingPermissions: new Map(),
-            turn: null,
-            textBuffer: '',
-            reasoningBuffer: '',
-            flushTimer: null,
-            idleTimer: null,
-            postChain: Promise.resolve(),
-            closing: false,
-            exited: false,
-        };
-        this.#live.set(sid, live);
-        client.process.once('exit', (code, signal) => this.#onProcessExit(sid, code, signal));
         try {
             const initialized = await client.initialize({
                 clientInfo: { name: 'awb-agent-session', version: this.#options.clientVersion || '1' },
                 clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
             });
             const caps = (initialized?.agentCapabilities ?? {});
-            live.loadSupported = caps.loadSession === true;
-            const mcpServers = this.#mcpServers(ctx, sid);
+            const loadSupported = caps.loadSession === true;
+            const sessionIdForMcp = requestedSessionId || 'new';
+            const mcpServers = this.#options.mcpServers ? this.#options.mcpServers(sessionIdForMcp) : this.#defaultMcpServers(sessionIdForMcp);
+            live = {
+                cli,
+                sessionId: requestedSessionId,
+                cwd,
+                title,
+                client,
+                loadSupported,
+                loading: false,
+                pendingPermissions: new Map(),
+                turn: null,
+                textBuffer: '',
+                reasoningBuffer: '',
+                flushTimer: null,
+                idleTimer: null,
+                postChain: Promise.resolve(),
+                seq: 0,
+                nonce: randomUUID().slice(0, 8),
+                credentialId: request.credential_id || '',
+                closing: false,
+                exited: false,
+            };
+            let modes;
             let resumed = false;
-            let modes = undefined;
-            if (request.native_session_id && live.loadSupported) {
+            if (requestedSessionId) {
+                if (!loadSupported) {
+                    throw Object.assign(new Error(`The ${cli} ACP adapter cannot resume existing sessions (no loadSession capability).`), { code: 'resume_unsupported' });
+                }
+                live.loading = true;
                 try {
-                    const loaded = await client.loadSession({ sessionId: request.native_session_id, cwd, mcpServers });
-                    live.nativeSessionId = request.native_session_id;
+                    const loaded = await client.loadSession({ sessionId: requestedSessionId, cwd, mcpServers });
                     modes = loaded?.modes;
                     resumed = true;
                 }
-                catch (err) {
-                    log(`${tag} session/load failed (${err?.message ?? err}); opening a fresh session`);
+                finally {
+                    live.loading = false;
                 }
             }
-            if (!resumed) {
+            else {
                 const created = await client.newSession({ cwd, mcpServers });
-                live.nativeSessionId = created.sessionId;
+                live.sessionId = created.sessionId;
                 modes = created.modes;
+                await this.#store.recordAwbSession({ cli, session_id: live.sessionId, cwd, title }).catch(() => undefined);
             }
+            if (!live.sessionId)
+                throw new Error('ACP adapter returned no session id.');
+            const key = this.#key(cli, live.sessionId);
+            this.#live.set(key, live);
+            client.process.once('exit', (code, signal) => this.#onProcessExit(key, code, signal));
             const modeInfo = this.#parseModes(modes);
             this.#enqueue(live, [{
                     type: 'system',
                     payload: {
-                        text: resumed
-                            ? `Session resumed (${runtime}, ${cwd}).`
-                            : `Session opened (${runtime}, ${cwd}).`,
-                        runtime,
-                        cwd,
-                        resumed,
-                        command: `${command} ${args.join(' ')}`.trim(),
+                        text: resumed ? `Session resumed (${cli}, ${cwd}).` : `Session opened (${cli}, ${cwd}).`,
+                        cli, cwd, resumed, command: `${command} ${args.join(' ')}`.trim(),
                     },
                 }], {
                 status: 'ready',
-                native_session_id: live.nativeSessionId,
-                resume_supported: live.loadSupported,
+                cwd,
+                ...(title ? { title } : {}),
                 current_mode: modeInfo.current,
                 available_modes: modeInfo.available,
+                resume_supported: loadSupported,
                 last_error: null,
                 reason: resumed ? 'resumed' : 'opened',
             });
@@ -319,43 +406,86 @@ export class AgentSessionRunner {
             return live;
         }
         catch (err) {
-            this.#live.delete(sid);
-            await this.#killClient(live).catch(() => undefined);
+            const child = client.process;
+            client.close();
+            if (child?.pid)
+                await terminateDetachedProcessTree(child.pid, 250, { child }).catch(() => undefined);
             throw err;
         }
     }
-    #buildEnv(runtime, ctx, sessionId) {
+    #buildEnv(cli, sessionId, auth) {
         const env = { ...(this.#options.baseEnv ?? process.env) };
-        if (runtime === 'hermes') {
-            if (ctx.cli_home_dir)
-                env.HERMES_HOME = join(dirname(ctx.cli_home_dir), 'hermes');
-        }
-        else if (ctx.cli_home_dir) {
-            try {
-                const adapter = createAdapter(runtime === 'deepseek' ? 'deepseek' : runtime);
-                const configDirEnv = adapter.configDirEnv();
-                if (configDirEnv)
-                    env[configDirEnv] = ctx.cli_home_dir;
-            }
-            catch {
-            }
-        }
-        Object.assign(env, ctx.extra_env ?? {});
-        env.AWB_AGENT_ID = ctx.agent_id;
-        env.AWB_SESSION_ID = sessionId;
-        env.AWB_API_KEY = ctx.api_key;
+        for (const key of auth.stripEnvKeys)
+            delete env[key];
+        Object.assign(env, auth.env);
         env.AWB_URL = this.#config.url;
+        env.AWB_MANAGER_ID = this.#options.getManagerId();
+        env.AWB_SESSION_CLI = cli;
+        env.AWB_SESSION_ID = sessionId;
         return env;
     }
-    #mcpServers(ctx, sessionId) {
+    async #prepareAuth(cli, cwd, request) {
+        const none = { label: 'operator-login', env: {}, stripEnvKeys: [], cliHome: null };
+        const credentialId = request.credential_id || '';
+        if (!credentialId)
+            return none;
+        const prefix = SESSION_CLI_CREDENTIAL_PREFIX[cli];
+        if (!prefix)
+            throw Object.assign(new Error(`${cli} sessions cannot use an AWB credential.`), { code: 'credential_unsupported' });
+        const fetcher = this.#options.credentialFetcher
+            ?? ((id, ws) => fetchSessionCredential(this.#config, this.#options.getManagerId(), id, ws));
+        const fetched = await fetcher(credentialId, request.workspace_id || '');
+        if (!fetched)
+            throw Object.assign(new Error('The credential assigned in CLI settings could not be fetched from AWB.'), { code: 'credential_unavailable' });
+        if (!fetched.provider.startsWith(prefix)) {
+            throw Object.assign(new Error(`CLI settings credential provider ${fetched.provider} does not match ${cli}.`), { code: 'credential_provider_mismatch' });
+        }
+        const { fields, repaired } = normalizeCredentialFields(fetched.fields);
+        if (repaired.length)
+            log(`[agent-session ${cli}] credential ${fetched.credential_id.slice(0, 8)} whitespace repaired in: ${repaired.join(', ')}`);
+        const missing = (SESSION_REQUIRED_CREDENTIAL_FIELDS[fetched.provider] ?? []).filter((key) => !fields[key]);
+        if (missing.length) {
+            throw Object.assign(new Error(`CLI settings credential ${fetched.provider} is missing ${missing.join(', ')} — re-save it in Settings → Credentials.`), { code: 'credential_incomplete' });
+        }
+        const credential = { ...fetched, fields };
+        const adapter = createRuntimeCliAdapter(cli);
+        const cliHome = join(this.#options.sessionHomesDir, cli, credential.credential_id);
+        await mkdir(cliHome, { recursive: true, mode: 0o700 });
+        await this.#linkSessionStore(cli, cliHome);
+        const prep = await adapter.prepareCliHome(cliHome, credential, null);
+        const env = { ...(prep.extraEnv ?? {}) };
+        const configDirEnv = adapter.configDirEnv();
+        if (configDirEnv)
+            env[configDirEnv] = cliHome;
+        const stripEnvKeys = adapter.authEnvKeys().filter((key) => !(key in env));
+        await adapter.ensureWorkspaceTrust(cliHome, cwd).catch((err) => log(`[agent-session ${cli}] trust seed failed: ${err?.message ?? err}`));
+        return { label: `credential:${credential.provider}`, env, stripEnvKeys, cliHome };
+    }
+    async #linkSessionStore(cli, cliHome) {
+        const subdir = SESSION_STORE_SUBDIR[cli];
+        if (!subdir)
+            return;
+        const operatorHome = cli === 'claude' ? resolveClaudeHome(this.#options.baseEnv ?? process.env) : resolveCodexHome(this.#options.baseEnv ?? process.env);
+        const target = join(operatorHome, subdir);
+        const linkPath = join(cliHome, subdir);
+        await mkdir(target, { recursive: true });
+        try {
+            const existing = await lstat(linkPath);
+            if (existing.isSymbolicLink() || existing.isDirectory())
+                return;
+        }
+        catch {
+        }
+        await symlink(target, linkPath, process.platform === 'win32' ? 'junction' : 'dir');
+    }
+    #defaultMcpServers(sessionId) {
         return [{
                 type: 'http',
                 name: 'awb',
                 url: `${this.#config.url.replace(/\/$/, '')}/mcp`,
                 headers: [
-                    { name: 'Authorization', value: `Bearer ${ctx.api_key}` },
+                    { name: 'Authorization', value: `Bearer ${this.#config.apiKey}` },
                     { name: 'X-AWB-Client-Type', value: 'agent-session' },
-                    { name: 'X-AWB-Agent-Id', value: ctx.agent_id },
                     { name: 'X-AWB-Session-Id', value: sessionId },
                 ],
             }];
@@ -376,6 +506,28 @@ export class AgentSessionRunner {
         }));
         return { current, available };
     }
+    #statusOf(live) {
+        if (live.exited || live.closing)
+            return 'idle';
+        if (live.pendingPermissions.size > 0)
+            return 'awaiting_permission';
+        if (live.turn)
+            return 'busy';
+        return 'ready';
+    }
+    #summaryOf(live) {
+        const now = new Date().toISOString();
+        return { cli: live.cli, session_id: live.sessionId, cwd: live.cwd, title: live.title, created_at: now, updated_at: now, source: 'awb' };
+    }
+    #stateOf(live) {
+        return {
+            session_id: live.sessionId,
+            cwd: live.cwd,
+            title: live.title,
+            status: this.#statusOf(live),
+            resume_supported: live.loadSupported,
+        };
+    }
     async #runPrompt(live, turnId, text) {
         if (live.turn) {
             this.#enqueue(live, [{ type: 'error', payload: { message: 'A turn is already in progress.', code: 'turn_in_progress' }, turn_id: turnId }]);
@@ -383,9 +535,13 @@ export class AgentSessionRunner {
         }
         live.turn = { turnId, startedAt: Date.now() };
         this.#clearIdle(live);
-        this.#enqueue(live, [{ type: 'turn', payload: { phase: 'started' }, turn_id: turnId }], { status: 'busy', reason: 'turn_started' });
+        if (!live.title) {
+            live.title = text.trim().replace(/\s+/g, ' ').slice(0, 80);
+            await this.#store.touchAwbSession(live.cli, live.sessionId, { title: live.title }).catch(() => undefined);
+        }
+        this.#enqueue(live, [{ type: 'turn', payload: { phase: 'started' }, turn_id: turnId }], { status: 'busy', title: live.title, reason: 'turn_started' });
         try {
-            const response = await live.client.prompt({ sessionId: live.nativeSessionId, prompt: [{ type: 'text', text }] }, { timeoutMs: this.#options.promptTimeoutMs });
+            const response = await live.client.prompt({ sessionId: live.sessionId, prompt: [{ type: 'text', text }] }, { timeoutMs: this.#options.promptTimeoutMs });
             this.#flushBuffers(live, turnId);
             const events = [];
             if (response?.usage) {
@@ -403,23 +559,24 @@ export class AgentSessionRunner {
             }
             events.push({ type: 'turn', payload: { phase: 'finished', stop_reason: response?.stopReason || 'end_turn' }, turn_id: turnId });
             this.#enqueue(live, events, { status: 'ready', last_error: null, reason: 'turn_finished' });
+            await this.#store.touchAwbSession(live.cli, live.sessionId).catch(() => undefined);
         }
         catch (err) {
             this.#flushBuffers(live, turnId);
-            const message = err?.message ?? String(err);
+            const message = redactSecrets(err?.message ?? String(err));
             this.#enqueue(live, [
                 { type: 'error', payload: { message, code: err?.code ?? undefined }, turn_id: turnId },
                 { type: 'turn', payload: { phase: 'finished', stop_reason: 'error' }, turn_id: turnId },
-            ], { status: live.exited ? 'suspended' : 'error', last_error: message, reason: 'turn_failed' });
+            ], { status: live.exited ? 'idle' : 'error', last_error: message, reason: 'turn_failed' });
         }
         finally {
             live.turn = null;
             this.#touch(live);
+            await live.postChain;
         }
     }
-    #onEvent(sessionId, event) {
-        const live = this.#live.get(sessionId);
-        if (!live)
+    #onEvent(live, event) {
+        if (live.loading)
             return;
         const turnId = live.turn?.turnId;
         switch (event.type) {
@@ -443,7 +600,7 @@ export class AgentSessionRunner {
                 return;
             }
             case 'tool_updated':
-            case 'tool_completed': {
+            case 'tool_completed':
                 this.#flushBuffers(live, turnId);
                 this.#enqueue(live, [{
                         type: 'tool_update',
@@ -451,22 +608,14 @@ export class AgentSessionRunner {
                         turn_id: turnId,
                     }]);
                 return;
-            }
             case 'child_finished':
                 this.#flushBuffers(live, turnId);
-                this.#enqueue(live, [{
-                        type: 'tool_update',
-                        payload: { tool_call_id: event.childRunId, status: event.status, output: boundedValue(event.output) },
-                        turn_id: turnId,
-                    }]);
+                this.#enqueue(live, [{ type: 'tool_update', payload: { tool_call_id: event.childRunId, status: event.status, output: boundedValue(event.output) }, turn_id: turnId }]);
                 return;
             case 'usage':
                 this.#enqueue(live, [{
                         type: 'usage',
-                        payload: {
-                            input_tokens: event.inputTokens, output_tokens: event.outputTokens, total_tokens: event.totalTokens,
-                            cached_read_tokens: event.cachedReadTokens, thought_tokens: event.thoughtTokens,
-                        },
+                        payload: { input_tokens: event.inputTokens, output_tokens: event.outputTokens, total_tokens: event.totalTokens, cached_read_tokens: event.cachedReadTokens, thought_tokens: event.thoughtTokens },
                         turn_id: turnId,
                     }]);
                 return;
@@ -479,43 +628,32 @@ export class AgentSessionRunner {
                         this.#enqueue(live, [], { current_mode: modeId, reason: 'mode' });
                     return;
                 }
-                log(`[agent-session ${sessionId.slice(0, 8)}] diagnostic ${event.method}${kind ? ` (${kind})` : ''}`);
+                log(`[agent-session ${live.cli} ${live.sessionId.slice(0, 8)}] diagnostic ${event.method}${kind ? ` (${kind})` : ''}`);
                 return;
             }
             default:
                 return;
         }
     }
-    async #onPermission(sessionId, permission) {
-        const live = this.#live.get(sessionId);
-        if (!live)
+    async #onPermission(live, permission) {
+        if (live.loading)
             return { outcome: 'cancelled' };
         const turnId = live.turn?.turnId;
         this.#flushBuffers(live, turnId);
         const requestId = randomUUID();
         const options = (permission.options ?? []).map((o) => ({ option_id: o.optionId, name: o.name, kind: o.kind }));
-        const requestEvent = {
-            type: 'permission_request',
-            payload: {
-                request_id: requestId,
-                tool_call_id: permission.toolCall?.toolCallId ?? '',
-                title: permission.toolCall?.title ?? '',
-                kind: permission.toolCall?.kind ?? '',
-                options,
-                raw_input: boundedValue(permission.toolCall?.rawInput ?? permission.toolCall?.raw_input),
-            },
-            turn_id: turnId,
-        };
-        if (live.permissionPolicy === 'auto_allow') {
-            const pick = (permission.options ?? []).find((o) => ALLOW_KINDS.has(o.kind)) ?? permission.options?.[0];
-            this.#enqueue(live, [requestEvent, {
-                    type: 'permission_decision',
-                    payload: { request_id: requestId, outcome: pick ? 'selected' : 'cancelled', option_id: pick?.optionId ?? null, decided_by: 'policy' },
-                    turn_id: turnId,
-                }]);
-            return pick ? { outcome: 'selected', optionId: pick.optionId } : { outcome: 'cancelled' };
-        }
-        this.#enqueue(live, [requestEvent], { status: 'awaiting_permission', reason: 'permission' });
+        this.#enqueue(live, [{
+                type: 'permission_request',
+                payload: {
+                    request_id: requestId,
+                    tool_call_id: permission.toolCall?.toolCallId ?? '',
+                    title: permission.toolCall?.title ?? '',
+                    kind: permission.toolCall?.kind ?? '',
+                    options,
+                    raw_input: boundedValue(permission.toolCall?.rawInput ?? permission.toolCall?.raw_input),
+                },
+                turn_id: turnId,
+            }], { status: 'awaiting_permission', reason: 'permission' });
         return new Promise((resolve) => {
             const timer = setTimeout(() => {
                 live.pendingPermissions.delete(requestId);
@@ -530,17 +668,23 @@ export class AgentSessionRunner {
             live.pendingPermissions.set(requestId, { resolve, timer });
         });
     }
-    #resolvePermission(sessionId, requestId, optionId) {
-        const live = this.#live.get(sessionId);
+    #resolvePermission(cli, sessionId, requestId, optionId) {
+        const live = this.#live.get(this.#key(cli, sessionId));
         if (!live)
             return;
         const pending = live.pendingPermissions.get(requestId);
         if (!pending) {
-            log(`[agent-session ${sessionId.slice(0, 8)}] permission ${requestId.slice(0, 8)} not pending (late or duplicate decision)`);
+            log(`[agent-session ${cli} ${sessionId.slice(0, 8)}] permission ${requestId.slice(0, 8)} not pending (late or duplicate decision)`);
             return;
         }
         clearTimeout(pending.timer);
         live.pendingPermissions.delete(requestId);
+        const allowed = !!optionId && (ALLOW_KINDS.size > 0);
+        this.#enqueue(live, [{
+                type: 'permission_decision',
+                payload: { request_id: requestId, outcome: optionId ? 'selected' : 'cancelled', option_id: optionId, decided_by: 'user' },
+                turn_id: live.turn?.turnId,
+            }], { status: 'busy', reason: allowed ? 'permission_allowed' : 'permission_denied' });
         pending.resolve(optionId ? { outcome: 'selected', optionId } : { outcome: 'cancelled' });
     }
     #scheduleFlush(live) {
@@ -568,10 +712,17 @@ export class AgentSessionRunner {
         if (events.length)
             this.#enqueue(live, events);
     }
-    #enqueue(live, events, patch) {
-        const bounded = events.map((e) => ({ ...e, payload: boundedPayload(e.payload) }));
+    #enqueue(live, events, state) {
+        const now = new Date().toISOString();
+        const stamped = events.map((e) => {
+            live.seq += 1;
+            return { ...e, payload: boundedPayload(e.payload), seq: live.seq, id: `${live.sessionId}:live:${live.nonce}:${live.seq}`, created_at: now };
+        });
+        const ref = this.#ref(live.cli, live.sessionId);
         live.postChain = live.postChain
-            .then(() => postAgentSessionEvents(live.rest, live.sessionId, live.agentId, bounded, patch ?? null))
+            .then(() => (stamped.length || state
+            ? postAgentSessionEvents(this.#config, ref, stamped, state ?? null)
+            : Promise.resolve({ ok: true, status: 204 })))
             .then(() => undefined, () => undefined);
     }
     #touch(live) {
@@ -586,7 +737,7 @@ export class AgentSessionRunner {
                 this.#touch(live);
                 return;
             }
-            void this.#closeLive(live.sessionId, 'suspended', 'idle');
+            void this.#closeLive(live.cli, live.sessionId, 'idle', 'idle');
         }, ms);
         live.idleTimer.unref?.();
     }
@@ -596,8 +747,8 @@ export class AgentSessionRunner {
             live.idleTimer = null;
         }
     }
-    #onProcessExit(sessionId, code, signal) {
-        const live = this.#live.get(sessionId);
+    #onProcessExit(key, code, signal) {
+        const live = this.#live.get(key);
         if (!live)
             return;
         live.exited = true;
@@ -609,19 +760,17 @@ export class AgentSessionRunner {
         this.#clearIdle(live);
         if (live.closing)
             return;
-        this.#live.delete(sessionId);
+        this.#live.delete(key);
         const detail = `Agent process exited (${signal ? `signal ${signal}` : `code ${code ?? 'unknown'}`}).`;
-        log(`[agent-session ${sessionId.slice(0, 8)}] ${detail}`);
+        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: 'suspended', reason: 'process_exit' });
+        this.#enqueue(live, [{ type: 'system', payload: { text: `${detail} The next prompt reopens the session.` } }], live.turn ? undefined : { status: 'idle', reason: 'process_exit' });
     }
-    async #closeLive(sessionId, finalStatus, reason = finalStatus) {
-        const live = this.#live.get(sessionId);
-        if (!live) {
-            if (finalStatus === 'closed')
-                return;
+    async #closeLive(cli, sessionId, finalStatus, reason = finalStatus) {
+        const key = this.#key(cli, sessionId);
+        const live = this.#live.get(key);
+        if (!live)
             return;
-        }
         live.closing = true;
         this.#clearIdle(live);
         for (const [id, pending] of live.pendingPermissions) {
@@ -630,29 +779,25 @@ export class AgentSessionRunner {
             live.pendingPermissions.delete(id);
         }
         if (live.turn)
-            await live.client.cancel(live.nativeSessionId).catch(() => undefined);
+            await live.client.cancel(live.sessionId).catch(() => undefined);
         this.#flushBuffers(live, live.turn?.turnId);
-        if (!live.exited && live.nativeSessionId) {
-            await live.client.closeSession(live.nativeSessionId).catch(() => undefined);
-        }
-        this.#live.delete(sessionId);
-        await this.#killClient(live);
-        const text = finalStatus === 'closed'
-            ? 'Agent process stopped.'
-            : reason === 'idle'
-                ? `Idle for ${this.#options.idleMinutes} min — agent process stopped. The next prompt reopens the session.`
-                : `Agent process stopped (${reason}). The next prompt reopens the session.`;
-        this.#enqueue(live, [{ type: 'system', payload: { text } }], finalStatus === 'closed'
-            ? { reason: 'process_stopped' }
-            : { status: 'suspended', reason });
-        await live.postChain;
-    }
-    async #killClient(live) {
+        if (!live.exited)
+            await live.client.closeSession(live.sessionId).catch(() => undefined);
+        this.#live.delete(key);
         const child = live.client.process;
         const pid = child?.pid;
         live.client.close();
         if (pid && child)
             await terminateDetachedProcessTree(pid, 250, { child }).catch(() => undefined);
+        const text = finalStatus === 'closed'
+            ? 'Agent process stopped.'
+            : reason === 'idle'
+                ? `Idle for ${this.#options.idleMinutes} min — agent process stopped. The next prompt reopens the session.`
+                : reason === 'credential_changed'
+                    ? 'CLI settings changed — reopening the session with the new credential.'
+                    : `Agent process stopped (${reason}). The next prompt reopens the session.`;
+        this.#enqueue(live, [{ type: 'system', payload: { text } }], { status: finalStatus, reason });
+        await live.postChain;
     }
 }
 //# sourceMappingURL=agent-session-runner.js.map