@quadient/skillshare 1.8.1 → 1.10.0

package/README.md

@@ -19,6 +19,41 @@ bun run index.ts install 12 0.1.0 --target ./installed
 bun run index.ts install --skill-version-id 42 --target ./installed
 ```
 
+## Connected agents
+
+`skillshare agents listen` lets Skillshare run Claude Code (`claude`) or Codex (`codex`) sessions
+on this computer. Start a session under **Sessions** in Skillshare and keep talking to the agent
+there; Teams 👀 sessions go to the computer chosen under **Connected agents**. The listener
+reports the installed agents with their models and reasoning levels. Agents use the login you
+already have in `claude` and `codex`, and run with your full local permissions and configuration,
+without permission prompts.
+
+Codex runs as `codex app-server` and Claude Code with stream-json input and output. The agent
+keeps running between your messages and stops after 15 quiet minutes; the next message resumes
+the same Codex thread or Claude Code session. Sessions need CLI 1.10.0 or newer.
+
+```sh
+skillshare agents status
+skillshare agents listen --workdir ~/Research
+skillshare agents listen --name desktop --max-concurrency 2
+```
+
+`--sandbox` keeps every agent read-only. Claude Code may only read files, search the web
+and use the Skillshare MCP; Codex runs in its read-only sandbox. A profile can do the same
+with `"sandbox": true`.
+
+Optional named profiles in `~/.config/skillshare/agents.json` set a working directory and
+extra arguments. For Claude Code the arguments are added to `claude`; for Codex only
+configuration overrides (`-c`, `--config`, `--enable`, `--disable`) apply to `codex app-server`. Only the name, agent, model, reasoning and the working directory's last
+segment are sent to Skillshare.
+
+```json
+{ "profiles": [
+  { "name": "piq-opus-high", "agent": "claude", "model": "opus", "reasoning": "high",
+    "workdir": "~/Research/piq-modules", "args": ["--add-dir", "~/Research/piq-projects"] }
+] }
+```
+
 ## Teams MCP
 
 Starting with 1.7.0, `skillshare teams login` opens a dedicated local browser profile,
@@ -54,6 +89,13 @@ permissions, Microsoft session lifetime and file-tool differences in the hosted
 
 ## Behavior
 
+Starting with 1.9.0:
+
+- `agents listen` and `agents status` run Claude Code and Codex sessions from Skillshare on this computer (see [Connected agents](#connected-agents)); `--sandbox` keeps them read-only.
+- Commands print readable text. Scripts that parsed JSON from `whoami`, `list`, `show`, `upload`, `pages list|show|runtime|upload` or `teams status|test|upload` must add `--json`; with `--json` progress goes to stderr and stdout contains only JSON.
+- `show` accepts a skill name as well as an id.
+- `pages upload` refuses build output folder names such as `dist` or `build` without `--slug`, says whether it creates or replaces a page, refuses pages owned by someone else unless you are an admin, and prints the page URL.
+
 Starting with 1.8.0:
 
 - `install` and `update` download into a staging directory first, so a failed transfer leaves the existing install untouched. Files that a new version no longer contains are removed.
@@ -213,7 +255,7 @@ npx @quadient/skillshare update 12 --target ./installed
 
 Publish an authenticated static page. The upload replaces the page's complete
 content, and the directory must contain `index.html` at its root. By default the
-directory name is used as the page slug:
+directory name is used as the page slug; build output folders such as `dist` need `--slug`:
 
 ```bash
 npx @quadient/skillshare pages upload ./release-notes

package/dist/agents-claude.js

@@ -0,0 +1,274 @@
+import { randomUUID } from 'node:crypto';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { startAgentProcess } from './agents-process.js';
+import { CLAUDE_SANDBOX_TOOLS, DEFAULT, SANDBOX_NOTE, clip, isSandboxed, mcpServerName, mcpTokenEnvironment, oneLine, } from './agents-session.js';
+/**
+ * Claude Code in print mode with stream-json in both directions: the same protocol the Agent SDK speaks, but against the
+ * user's own claude install, so their login and settings apply. MCP config and the session's instructions are passed per
+ * process; tokens only through the environment.
+ */
+export function claudeArgs(context, mcpConfigPath) {
+    const { start } = context;
+    const sandbox = isSandboxed(start.configuration, context);
+    const servers = start.mcpServers ?? [];
+    const args = ['-p', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose', '--include-partial-messages',
+        ...(sandbox
+            // A sandboxed session never prompts: anything outside the read-only allowlist is denied.
+            ? ['--permission-mode', 'dontAsk', '--allowedTools', ...CLAUDE_SANDBOX_TOOLS, ...servers.map((server, index) => `mcp__${mcpServerName(server, index)}`)]
+            : ['--dangerously-skip-permissions'])];
+    if (start.configuration.model !== DEFAULT)
+        args.push('--model', start.configuration.model);
+    if (start.configuration.reasoning !== DEFAULT)
+        args.push('--effort', start.configuration.reasoning);
+    if (mcpConfigPath)
+        args.push('--mcp-config', mcpConfigPath);
+    const instructions = [start.instructions?.trim(), sandbox ? SANDBOX_NOTE : undefined].filter(Boolean).join('\n\n');
+    if (instructions)
+        args.push('--append-system-prompt', instructions);
+    if (start.resumeThreadId)
+        args.push('--resume', start.resumeThreadId);
+    return [...args, ...(context.profile?.args ?? [])];
+}
+export function claudeMcpConfig(servers) {
+    return JSON.stringify({
+        mcpServers: Object.fromEntries(servers.map((server, index) => [mcpServerName(server, index),
+            { type: 'http', url: server.url, headers: { Authorization: `Bearer \${SKILLSHARE_MCP_TOKEN_${index}}` } }])),
+    }, null, 2);
+}
+/** A tool call as a transcript entry: shell commands and file edits get their own kinds, everything else is a tool. */
+export function claudeToolItem(block) {
+    const input = block.input ?? {};
+    const name = String(block.name ?? 'tool');
+    const key = String(block.id);
+    const text = (value) => typeof value === 'string' ? value : '';
+    switch (name) {
+        case 'Bash': return { key, kind: 'command', status: 'inProgress', title: oneLine(text(input.command)), detail: text(input.description) || undefined };
+        case 'Edit':
+        case 'MultiEdit':
+        case 'Write':
+            return { key, kind: 'fileChange', status: 'inProgress', title: text(input.file_path) };
+        case 'NotebookEdit': return { key, kind: 'fileChange', status: 'inProgress', title: text(input.notebook_path) };
+        case 'TodoWrite': {
+            const todos = Array.isArray(input.todos) ? input.todos : [];
+            return { key, kind: 'plan', status: 'completed',
+                text: clip(todos.map((todo) => `- [${todo.status === 'completed' ? 'x' : ' '}] ${todo.content ?? ''}`).join('\n')) };
+        }
+        case 'Task':
+        case 'Agent': return { key, kind: 'tool', status: 'inProgress', title: oneLine(`Subagent: ${text(input.description) || text(input.subagent_type)}`) };
+    }
+    const mcp = /^mcp__(.+?)__(.+)$/.exec(name);
+    if (mcp)
+        return { key, kind: 'tool', status: 'inProgress', title: `${mcp[1]} · ${mcp[2]}` };
+    const subject = text(input.file_path) || text(input.pattern) || text(input.url) || text(input.query) || text(input.path);
+    return { key, kind: 'tool', status: 'inProgress', title: oneLine(subject ? `${name} ${subject}` : name) };
+}
+export function createClaudeDriver(options = {}) {
+    return context => new ClaudeDriver(context, options);
+}
+class ClaudeDriver {
+    context;
+    options;
+    process = null;
+    directory = null;
+    sessionId = null;
+    current = null;
+    controls = new Map();
+    /** Text and tool entries by key, so later frames can update an entry the transcript already shows. */
+    items = new Map();
+    blocks = new Map();
+    streamed = new Map();
+    messageId = '';
+    costSoFar = 0;
+    closing = false;
+    constructor(context, options) {
+        this.context = context;
+        this.options = options;
+    }
+    async open() {
+        const servers = this.context.start.mcpServers ?? [];
+        let mcpConfig;
+        if (servers.length > 0) {
+            this.directory = await mkdtemp(join(tmpdir(), 'skillshare-session-'));
+            mcpConfig = join(this.directory, 'mcp.json');
+            await writeFile(mcpConfig, claudeMcpConfig(servers), { mode: 0o600 });
+        }
+        this.process = startAgentProcess({
+            command: this.options.command ?? 'claude',
+            args: claudeArgs(this.context, mcpConfig),
+            cwd: this.context.profile?.workdir ?? this.context.workdir,
+            env: {
+                ...mcpTokenEnvironment(servers), SKILLSHARE_SESSION_ID: this.context.sessionId,
+                // Claude Code lets auto-memory write to its own folder even under the read-only allowlist; a sandboxed session writes nothing.
+                ...(isSandboxed(this.context.start.configuration, this.context) ? { CLAUDE_CODE_DISABLE_AUTO_MEMORY: '1' } : {}),
+            },
+            spawnAgent: this.options.spawnAgent,
+            onLine: line => this.receive(line),
+        });
+        void this.process.exited.then(code => this.onExit(code));
+        // Claude Code answers initialize once it is ready, which turns a bad install or a bad flag into a clear start failure.
+        await this.control({ subtype: 'initialize' });
+        if (this.context.start.resumeThreadId)
+            this.adopt(this.context.start.resumeThreadId);
+    }
+    turn(message) {
+        return new Promise((resolve, reject) => {
+            this.current = { resolve, interrupted: false };
+            const sent = this.process?.write(JSON.stringify({
+                type: 'user', message: { role: 'user', content: message.text }, parent_tool_use_id: null, session_id: this.sessionId ?? '',
+            }));
+            if (!sent) {
+                this.current = null;
+                reject(new Error('Claude Code is not accepting input.'));
+            }
+        });
+    }
+    async interrupt() {
+        if (!this.current)
+            return;
+        this.current.interrupted = true;
+        await this.control({ subtype: 'interrupt' }).catch(() => { });
+    }
+    async close() {
+        this.closing = true;
+        await this.process?.kill();
+        if (this.directory)
+            await rm(this.directory, { recursive: true, force: true }).catch(() => { });
+    }
+    control(request) {
+        const requestId = randomUUID();
+        return new Promise((resolve, reject) => {
+            this.controls.set(requestId, { resolve, reject });
+            if (!this.process?.write(JSON.stringify({ type: 'control_request', request_id: requestId, request }))) {
+                this.controls.delete(requestId);
+                reject(new Error('Claude Code is not accepting input.'));
+            }
+        });
+    }
+    adopt(sessionId) {
+        if (sessionId === this.sessionId)
+            return;
+        this.sessionId = sessionId;
+        this.context.thread(sessionId);
+    }
+    emit(item) {
+        this.items.set(item.key, item);
+        this.context.item(item);
+    }
+    receive(line) {
+        let frame;
+        try {
+            frame = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        switch (frame.type) {
+            case 'control_response': {
+                const response = frame.response ?? {};
+                const waiter = this.controls.get(response.request_id);
+                if (!waiter)
+                    return;
+                this.controls.delete(response.request_id);
+                if (response.subtype === 'error')
+                    waiter.reject(new Error(String(response.error ?? 'Claude Code rejected the request.')));
+                else
+                    waiter.resolve(response.response ?? {});
+                return;
+            }
+            case 'control_request':
+                // Permission prompts never reach a session: it runs without prompts or with a read-only allowlist.
+                this.process?.write(JSON.stringify({ type: 'control_response',
+                    response: { subtype: 'error', request_id: frame.request_id, error: 'Skillshare sessions do not answer this request.' } }));
+                return;
+            case 'system':
+                if (frame.subtype === 'init' && typeof frame.session_id === 'string')
+                    this.adopt(frame.session_id);
+                return;
+            case 'stream_event':
+                return this.streamEvent(frame.event ?? {});
+            case 'assistant':
+                return this.assistant(frame.message ?? {});
+            case 'user':
+                return this.toolResults(frame.message?.content);
+            case 'result':
+                return this.result(frame);
+        }
+    }
+    /** Text arrives in deltas first; the complete assistant frame later replaces it under the same key. */
+    streamEvent(event) {
+        if (event.type === 'message_start' && typeof event.message?.id === 'string')
+            this.messageId = event.message.id;
+        if (event.type !== 'content_block_delta' || !this.messageId)
+            return;
+        const delta = event.delta ?? {};
+        const kind = delta.type === 'text_delta' ? 'assistant' : delta.type === 'thinking_delta' ? 'reasoning' : null;
+        if (!kind)
+            return;
+        const key = `${this.messageId}:${event.index}`;
+        const text = (this.streamed.get(key) ?? '') + String(delta.text ?? delta.thinking ?? '');
+        this.streamed.set(key, text);
+        if (text.trim())
+            this.emit({ key, kind, status: 'inProgress', text });
+    }
+    assistant(message) {
+        const id = String(message.id ?? '');
+        for (const block of Array.isArray(message.content) ? message.content : []) {
+            const index = this.blocks.get(id) ?? 0;
+            this.blocks.set(id, index + 1);
+            const key = `${id}:${index}`;
+            if (block.type === 'text' && typeof block.text === 'string')
+                this.emit({ key, kind: 'assistant', status: 'completed', text: block.text });
+            else if (block.type === 'thinking' && typeof block.thinking === 'string' && block.thinking.trim())
+                this.emit({ key, kind: 'reasoning', status: 'completed', text: block.thinking });
+            else if (block.type === 'tool_use' && block.id)
+                this.emit(claudeToolItem(block));
+        }
+    }
+    toolResults(content) {
+        if (!Array.isArray(content))
+            return;
+        for (const block of content) {
+            if (block?.type !== 'tool_result')
+                continue;
+            const item = this.items.get(String(block.tool_use_id));
+            if (item && item.status === 'inProgress')
+                this.emit({ ...item, status: block.is_error ? 'failed' : 'completed' });
+        }
+    }
+    result(frame) {
+        if (typeof frame.session_id === 'string')
+            this.adopt(frame.session_id);
+        const current = this.current;
+        this.current = null;
+        if (!current)
+            return;
+        // Costs are totals for the process; a turn's share is the difference.
+        const cost = typeof frame.total_cost_usd === 'number' ? frame.total_cost_usd : undefined;
+        const turnCost = cost === undefined ? undefined : Math.max(0, cost - this.costSoFar);
+        if (cost !== undefined)
+            this.costSoFar = cost;
+        const usage = frame.usage ?? {};
+        const input = [usage.input_tokens, usage.cache_creation_input_tokens, usage.cache_read_input_tokens].filter((n) => typeof n === 'number');
+        const stats = { costUsd: turnCost, inputTokens: input.length > 0 ? input.reduce((a, b) => a + b, 0) : undefined,
+            outputTokens: typeof usage.output_tokens === 'number' ? usage.output_tokens : undefined };
+        if (frame.subtype === 'success' && frame.is_error !== true)
+            return current.resolve({ status: 'completed', stats });
+        if (current.interrupted)
+            return current.resolve({ status: 'interrupted', stats });
+        const detail = typeof frame.result === 'string' && frame.result ? frame.result
+            : Array.isArray(frame.errors) && frame.errors.length > 0 ? frame.errors.join(' ') : `Claude Code ended the turn with ${frame.subtype ?? 'an error'}.`;
+        current.resolve({ status: 'failed', error: clip(detail, 2000), stats });
+    }
+    onExit(code) {
+        const reason = `Claude Code exited${code === null ? '' : ` with code ${code}`}${this.process?.stderrTail() ? `: ${this.process.stderrTail()}` : '.'}`;
+        for (const waiter of this.controls.values())
+            waiter.reject(new Error(reason));
+        this.controls.clear();
+        this.current?.resolve({ status: 'failed', error: reason });
+        this.current = null;
+        if (!this.closing)
+            this.context.exited(reason);
+    }
+}

package/dist/agents-codex.js

@@ -0,0 +1,276 @@
+import { startAgentProcess } from './agents-process.js';
+import { DEFAULT, SANDBOX_NOTE, clip, isSandboxed, mcpServerName, mcpTokenEnvironment, oneLine, } from './agents-session.js';
+/** Profile arguments that make sense for a long-running app-server; anything else belongs to codex exec only. */
+export function codexConfigArgs(args) {
+    const kept = [];
+    for (let index = 0; index < args.length; index++) {
+        const arg = args[index];
+        if (['-c', '--config', '--enable', '--disable'].includes(arg) && args[index + 1] !== undefined)
+            kept.push(arg, args[++index]);
+        else if (/^(-c|--config|--enable|--disable)=/.test(arg))
+            kept.push(arg);
+    }
+    return kept;
+}
+/** thread/start and thread/resume share these: where to work, what may run, the session's MCP servers and instructions. */
+export function codexThreadParams(context) {
+    const { start } = context;
+    const sandbox = isSandboxed(start.configuration, context);
+    const servers = start.mcpServers ?? [];
+    const instructions = [start.instructions?.trim(), sandbox ? SANDBOX_NOTE : undefined].filter(Boolean).join('\n\n');
+    return {
+        cwd: context.profile?.workdir ?? context.workdir,
+        ...(start.configuration.model !== DEFAULT ? { model: start.configuration.model } : {}),
+        // Nobody watches for approval prompts, so the agent never asks: full access, or a read-only sandbox.
+        approvalPolicy: 'never',
+        sandbox: sandbox ? 'read-only' : 'danger-full-access',
+        ...(instructions ? { developerInstructions: instructions } : {}),
+        config: {
+            'tools.update_plan.enabled': true,
+            ...(servers.length > 0 ? {
+                mcp_servers: Object.fromEntries(servers.map((server, index) => [mcpServerName(server, index), { url: server.url, bearer_token_env_var: `SKILLSHARE_MCP_TOKEN_${index}` }])),
+            } : {}),
+        },
+    };
+}
+/** Codex errors often arrive as the provider's JSON body; the readable part is its message. */
+export function codexErrorText(message) {
+    if (typeof message !== 'string')
+        return undefined;
+    try {
+        const parsed = JSON.parse(message);
+        const nested = parsed?.error?.message ?? parsed?.message;
+        if (typeof nested === 'string' && nested)
+            return nested;
+    }
+    catch { }
+    return message;
+}
+const STATUS = { inProgress: 'inProgress', completed: 'completed', failed: 'failed', declined: 'failed' };
+/** Turns one Codex thread item into a transcript entry; items the user already sees, such as their own message, are skipped. */
+export function codexItem(item) {
+    const key = typeof item?.id === 'string' ? item.id : null;
+    if (!key)
+        return null;
+    const status = STATUS[item.status] ?? undefined;
+    switch (item.type) {
+        case 'agentMessage': return { key, kind: 'assistant', text: String(item.text ?? '') };
+        case 'reasoning': {
+            const summary = Array.isArray(item.summary) ? item.summary.join('\n\n') : '';
+            return summary ? { key, kind: 'reasoning', text: summary } : null;
+        }
+        case 'plan': return { key, kind: 'plan', text: String(item.text ?? '') };
+        case 'commandExecution':
+            return { key, kind: 'command', status, title: oneLine(String(item.command ?? '')),
+                detail: typeof item.exitCode === 'number' && item.exitCode !== 0 ? `exit code ${item.exitCode}` : undefined };
+        case 'fileChange': {
+            const paths = (Array.isArray(item.changes) ? item.changes : []).map((change) => String(change?.path ?? '')).filter(Boolean);
+            return { key, kind: 'fileChange', status, title: paths.slice(0, 5).join(', ') + (paths.length > 5 ? ` and ${paths.length - 5} more` : '') };
+        }
+        case 'mcpToolCall': return { key, kind: 'tool', status, title: `${item.server} · ${item.tool}` };
+        case 'dynamicToolCall': return { key, kind: 'tool', status, title: String(item.tool ?? 'tool') };
+        case 'webSearch': return { key, kind: 'tool', status: 'completed', title: oneLine(`Web search: ${item.query ?? ''}`) };
+        case 'collabAgentToolCall': return { key, kind: 'tool', status, title: `Subagent: ${item.tool}` };
+        case 'imageView': return { key, kind: 'tool', status: 'completed', title: oneLine(`View image ${item.path ?? ''}`) };
+        case 'imageGeneration': return { key, kind: 'tool', status, title: 'Generate image' };
+        case 'contextCompaction': return { key, kind: 'notice', text: 'Context compacted.' };
+        default: return null;
+    }
+}
+/** Codex through `codex app-server`: JSON-RPC over stdio, one app-server process and one thread per session. */
+export function createCodexDriver(options = {}) {
+    return context => new CodexDriver(context, options);
+}
+class CodexDriver {
+    context;
+    options;
+    process = null;
+    nextId = 0;
+    pending = new Map();
+    threadId = null;
+    current = null;
+    texts = new Map();
+    closing = false;
+    constructor(context, options) {
+        this.context = context;
+        this.options = options;
+    }
+    async open() {
+        const { start } = this.context;
+        const servers = start.mcpServers ?? [];
+        this.process = startAgentProcess({
+            command: this.options.command ?? 'codex',
+            args: ['app-server', ...codexConfigArgs(this.context.profile?.args ?? [])],
+            cwd: this.context.profile?.workdir ?? this.context.workdir,
+            env: { ...mcpTokenEnvironment(servers), SKILLSHARE_SESSION_ID: this.context.sessionId },
+            spawnAgent: this.options.spawnAgent,
+            onLine: line => this.receive(line),
+        });
+        void this.process.exited.then(code => this.onExit(code));
+        await this.request('initialize', {
+            clientInfo: { name: 'skillshare', title: 'Skillshare', version: this.options.clientVersion ?? '0.0.0' },
+            // Unified diffs are not shown in the transcript, so Codex need not send them.
+            capabilities: { experimentalApi: true, optOutNotificationMethods: ['turn/diff/updated', 'mcpServer/startupStatus/updated'] },
+        });
+        this.notify('initialized');
+        const params = codexThreadParams(this.context);
+        const result = start.resumeThreadId
+            ? await this.request('thread/resume', { threadId: start.resumeThreadId, ...params })
+            : await this.request('thread/start', params);
+        const threadId = result?.thread?.id;
+        if (typeof threadId !== 'string')
+            throw new Error('Codex did not return a thread.');
+        this.threadId = threadId;
+        this.context.thread(threadId);
+    }
+    turn(message) {
+        const { configuration } = this.context.start;
+        return new Promise((resolve, reject) => {
+            this.current = { resolve, usage: { input: 0, output: 0 } };
+            this.request('turn/start', {
+                threadId: this.threadId, input: [{ type: 'text', text: message.text }],
+                ...(configuration.reasoning !== DEFAULT ? { effort: configuration.reasoning } : {}),
+            }).then(result => {
+                if (this.current && typeof result?.turn?.id === 'string')
+                    this.current.id ??= result.turn.id;
+            }, error => {
+                this.current = null;
+                reject(error);
+            });
+        });
+    }
+    async interrupt() {
+        if (this.current?.id && this.threadId)
+            await this.request('turn/interrupt', { threadId: this.threadId, turnId: this.current.id });
+    }
+    async close() {
+        this.closing = true;
+        await this.process?.kill();
+    }
+    request(method, params) {
+        if (!this.process)
+            return Promise.reject(new Error('Codex is not running.'));
+        const id = ++this.nextId;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            if (!this.process.write(JSON.stringify({ id, method, params }))) {
+                this.pending.delete(id);
+                reject(new Error('Codex is not accepting input.'));
+            }
+        });
+    }
+    notify(method, params) {
+        this.process?.write(JSON.stringify(params === undefined ? { method } : { method, params }));
+    }
+    receive(line) {
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (message.id !== undefined && typeof message.method === 'string')
+            return this.answer(message);
+        if (message.id !== undefined) {
+            const pending = this.pending.get(message.id);
+            if (!pending)
+                return;
+            this.pending.delete(message.id);
+            if (message.error)
+                pending.reject(new Error(codexErrorText(message.error.message) ?? 'Codex rejected the request.'));
+            else
+                pending.resolve(message.result);
+            return;
+        }
+        if (typeof message.method === 'string')
+            this.notification(message.method, message.params ?? {});
+    }
+    /** Codex asks the client only for approvals and input, which a session never gives: the approval policy is never. */
+    answer(message) {
+        const reply = /requestApproval$/.test(message.method) ? { id: message.id, result: { decision: 'decline' } }
+            : { id: message.id, error: { code: -32601, message: 'Skillshare sessions do not answer this request.' } };
+        this.process?.write(JSON.stringify(reply));
+    }
+    notification(method, params) {
+        // Subagent threads report on the same connection; only the session's own thread is transcribed.
+        if (typeof params.threadId === 'string' && this.threadId && params.threadId !== this.threadId)
+            return;
+        switch (method) {
+            case 'item/started':
+            case 'item/completed': {
+                const item = codexItem(params.item);
+                if (!item)
+                    return;
+                if (item.kind === 'assistant' || item.kind === 'reasoning') {
+                    if (method === 'item/completed' || item.text)
+                        this.texts.set(item.key, item.text ?? '');
+                    else
+                        item.text = this.texts.get(item.key) ?? '';
+                    item.status = method === 'item/completed' ? 'completed' : 'inProgress';
+                }
+                this.context.item(item);
+                return;
+            }
+            case 'item/agentMessage/delta':
+            case 'item/reasoning/summaryTextDelta': {
+                const key = String(params.itemId ?? '');
+                if (!key)
+                    return;
+                const text = (this.texts.get(key) ?? '') + String(params.delta ?? '');
+                this.texts.set(key, text);
+                this.context.item({ key, kind: method === 'item/agentMessage/delta' ? 'assistant' : 'reasoning', status: 'inProgress', text });
+                return;
+            }
+            case 'turn/plan/updated': {
+                const steps = Array.isArray(params.plan) ? params.plan : [];
+                const text = steps.map((step) => `- [${step.status === 'completed' ? 'x' : ' '}] ${step.step ?? ''}`).join('\n');
+                if (text && params.turnId)
+                    this.context.item({ key: `plan-${params.turnId}`, kind: 'plan', text: clip(text) });
+                return;
+            }
+            case 'thread/tokenUsage/updated': {
+                // total covers the whole thread, including turns from before a resume; last is one model request, so a turn adds them up.
+                const last = params.tokenUsage?.last;
+                if (last && this.current) {
+                    this.current.usage.input += Number(last.inputTokens) || 0;
+                    this.current.usage.output += Number(last.outputTokens) || 0;
+                }
+                return;
+            }
+            case 'error': {
+                const text = codexErrorText(params.error?.message);
+                if (this.current && text)
+                    this.current.error = text;
+                return;
+            }
+            case 'turn/started':
+                if (this.current && typeof params.turn?.id === 'string')
+                    this.current.id ??= params.turn.id;
+                return;
+            case 'turn/completed': {
+                const turn = params.turn ?? {};
+                const current = this.current;
+                if (!current || current.id && turn.id && turn.id !== current.id)
+                    return;
+                this.current = null;
+                const status = turn.status === 'completed' ? 'completed' : turn.status === 'interrupted' ? 'interrupted' : 'failed';
+                const stats = { inputTokens: current.usage.input, outputTokens: current.usage.output };
+                current.resolve(status === 'failed'
+                    ? { status, error: codexErrorText(turn.error?.message) ?? current.error ?? 'The turn failed.', stats }
+                    : { status, stats });
+                return;
+            }
+        }
+    }
+    onExit(code) {
+        const reason = `Codex exited${code === null ? '' : ` with code ${code}`}${this.process?.stderrTail() ? `: ${this.process.stderrTail()}` : '.'}`;
+        for (const pending of this.pending.values())
+            pending.reject(new Error(reason));
+        this.pending.clear();
+        this.current?.resolve({ status: 'failed', error: reason });
+        this.current = null;
+        if (!this.closing)
+            this.context.exited(reason);
+    }
+}