@quadient/skillshare 1.9.0 → 1.10.1

package/README.md

@@ -21,12 +21,17 @@ 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`) tasks
-on this computer. The listener reports the installed agents with their models and reasoning
-levels. Choose which computer and configuration runs each kind of task under **Connected
-agents** in Skillshare. Agents run with your full local permissions and configuration,
+`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
@@ -38,7 +43,8 @@ and use the Skillshare MCP; Codex runs in its read-only sandbox. A profile can d
 with `"sandbox": true`.
 
 Optional named profiles in `~/.config/skillshare/agents.json` set a working directory and
-extra arguments. Only the name, agent, model, reasoning and the working directory's last
+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
@@ -53,7 +59,8 @@ segment are sent to Skillshare.
 Starting with 1.7.0, `skillshare teams login` opens a dedicated local browser profile,
 connects your own Teams account to Skillshare and verifies the connection. Sign in with
 the same Microsoft account as Skillshare. The server refreshes captured tokens in the
-background. `teams watch` renews an expired Microsoft grant through local browser SSO.
+background. `teams watch` renews an expired Microsoft grant through local browser SSO; `agents listen` does the same
+while it runs, so a computer that runs agents needs no separate `teams watch` (`--no-teams-watch` turns it off).
 Keep that process running for automatic recovery beyond the SPA refresh token lifetime;
 another interactive CLI login is needed only when SSO cannot complete, for example MFA.
 
@@ -85,7 +92,7 @@ permissions, Microsoft session lifetime and file-tool differences in the hosted
 
 Starting with 1.9.0:
 
-- `agents listen` and `agents status` run Claude Code and Codex tasks from Skillshare on this computer (see [Connected agents](#connected-agents)); `--sandbox` keeps them read-only.
+- `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.

package/dist/agents-claude.js

@@ -0,0 +1,322 @@
+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 ?? [];
+    // Replayed user messages tell when Claude Code took a message, which is how a steered message is known to have joined the turn.
+    const args = ['-p', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose', '--include-partial-messages', '--replay-user-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 = '';
+    /** Messages written to Claude Code whose replay has not come back yet, in order. */
+    echoes = [];
+    /** Steered messages Claude Code will run as their own turn; turn() then only waits for their outcome. */
+    submitted = new Set();
+    /** Outcomes of such turns that ended before turn() asked for them. */
+    early = [];
+    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) => {
+            if (this.submitted.delete(message.id)) {
+                const early = this.early.shift();
+                if (early)
+                    resolve(early);
+                else
+                    this.current = { resolve, interrupted: false };
+                return;
+            }
+            this.current = { resolve, interrupted: false };
+            if (!this.write(message.text)) {
+                this.current = null;
+                reject(new Error('Claude Code is not accepting input.'));
+            }
+        });
+    }
+    /**
+     * Claude Code takes a message written during a turn at its next tool boundary. If the turn ends first, the message starts
+     * a turn of its own; its replay arriving before or after the turn's result tells which happened.
+     */
+    steer(message) {
+        if (!this.current)
+            return Promise.resolve('notSent');
+        return new Promise(resolve => {
+            if (!this.write(message.text, outcome => {
+                if (outcome === 'steered')
+                    this.submitted.delete(message.id);
+                resolve(outcome);
+            }))
+                return resolve('notSent');
+            this.submitted.add(message.id);
+        });
+    }
+    write(text, steered) {
+        const sent = this.process?.write(JSON.stringify({
+            type: 'user', message: { role: 'user', content: text }, parent_tool_use_id: null, session_id: this.sessionId ?? '',
+        }));
+        if (sent)
+            this.echoes.push({ text, steered });
+        return Boolean(sent);
+    }
+    replayed(content) {
+        const text = typeof content === 'string' ? content
+            : Array.isArray(content) ? content.map((block) => typeof block?.text === 'string' ? block.text : '').join('') : '';
+        const index = this.echoes.findIndex(echo => echo.text === text);
+        if (index < 0)
+            return;
+        const [echo] = this.echoes.splice(index, 1);
+        echo.steered?.(this.current ? 'steered' : 'nextTurn');
+    }
+    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 frame.isReplay === true ? this.replayed(frame.message?.content) : 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;
+        const record = (outcome) => current ? current.resolve(outcome) : this.early.push(outcome);
+        // 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 count = (value) => typeof value === 'number' ? value : undefined;
+        const stats = { costUsd: turnCost, inputTokens: input.length > 0 ? input.reduce((a, b) => a + b, 0) : undefined,
+            cachedInputTokens: count(usage.cache_read_input_tokens), cacheWriteTokens: count(usage.cache_creation_input_tokens), outputTokens: count(usage.output_tokens) };
+        if (frame.subtype === 'success' && frame.is_error !== true)
+            return record({ status: 'completed', stats });
+        if (current?.interrupted)
+            return record({ 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'}.`;
+        record({ 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();
+        for (const echo of this.echoes.splice(0))
+            echo.steered?.('notSent');
+        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,292 @@
+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, cached: 0, cacheWrite: 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 });
+    }
+    /** turn/steer adds input to the active turn; Codex refuses it once that turn is over, and the message then runs as the next turn. */
+    async steer(message) {
+        const turnId = this.current?.id;
+        if (!turnId || !this.threadId)
+            return 'notSent';
+        try {
+            await this.request('turn/steer', { threadId: this.threadId, expectedTurnId: turnId, input: [{ type: 'text', text: message.text }] });
+            return 'steered';
+        }
+        catch {
+            return 'notSent';
+        }
+    }
+    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.cached += Number(last.cachedInputTokens) || 0;
+                    this.current.usage.cacheWrite += Number(last.cacheWriteInputTokens) || 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 { usage } = current;
+                const stats = { inputTokens: usage.input, cachedInputTokens: usage.cached, cacheWriteTokens: usage.cacheWrite, outputTokens: 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);
+    }
+}