@quadient/skillshare 1.9.0 → 1.10.1

package/dist/agents-detect.js

@@ -2,6 +2,7 @@ import { execFile } from 'node:child_process';
 import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { basename, isAbsolute, join, resolve } from 'node:path';
+import { startAgentProcess } from './agents-process.js';
 /** Model aliases Claude Code resolves to the latest release; Claude Code itself has no command that lists models. */
 export const CLAUDE_MODELS = ['fable', 'opus', 'sonnet', 'haiku'];
 export const CLAUDE_EFFORT_LEVELS = ['low', 'medium', 'high', 'xhigh', 'max'];
@@ -30,19 +31,11 @@ export async function detectAgents(options = {}) {
     if (codexVersion !== null) {
         const codexHome = env.CODEX_HOME ?? join(home, '.codex');
         const warnings = [];
-        const cache = parseJson(await read(join(codexHome, 'models_cache.json')));
-        const models = Array.isArray(cache?.models) ? cache.models
-            .filter((m) => m?.visibility === 'list' && typeof m.slug === 'string' && NAME.test(m.slug))
-            .map((m) => {
-            const levels = (Array.isArray(m.supported_reasoning_levels) ? m.supported_reasoning_levels : [])
-                .map((level) => typeof level === 'string' ? level : level?.effort)
-                .filter((level) => typeof level === 'string' && NAME.test(level) && level !== 'default');
-            const fallback = typeof m.default_reasoning_level === 'string' && levels.includes(m.default_reasoning_level) ? m.default_reasoning_level : undefined;
-            return { id: m.slug, displayName: typeof m.display_name === 'string' ? m.display_name.slice(0, 100) : undefined,
-                reasoningLevels: levels.slice(0, 16), defaultReasoning: fallback };
-        }).slice(0, 64) : [];
+        // Codex's own model/list reflects the account; its cache file is the fallback when the app-server cannot be asked.
+        const listed = await (options.codexModels ?? (() => codexModelList()))().catch(() => null);
+        const models = listed ?? cachedCodexModels(parseJson(await read(join(codexHome, 'models_cache.json'))));
         if (models.length === 0)
-            warnings.push('No Codex model list found in models_cache.json. Run codex once to refresh it; only the default model is offered.');
+            warnings.push('Codex did not list its models. Run codex once to sign in or refresh it; only the default model is offered.');
         const configured = defaultCodexModel(await read(join(codexHome, 'config.toml')));
         if (configured && models.length > 0 && !models.some(m => m.id === configured))
             warnings.push(`The default model "${configured}" from config.toml is not in the Codex model list and may be rejected; pick a model explicitly.`);
@@ -59,6 +52,74 @@ export async function detectAgents(options = {}) {
         problems,
     };
 }
+/** Keeps the list within what the server accepts: valid names, no "default", and bounded sizes. */
+function codexModel(id, displayName, levels, fallback) {
+    if (typeof id !== 'string' || !NAME.test(id) || id === 'default')
+        return null;
+    const reasoningLevels = levels.filter((level) => typeof level === 'string' && NAME.test(level) && level !== 'default').slice(0, 16);
+    return { id, displayName: typeof displayName === 'string' ? displayName.slice(0, 100) : undefined, reasoningLevels,
+        defaultReasoning: typeof fallback === 'string' && reasoningLevels.includes(fallback) ? fallback : undefined };
+}
+/** Models from model/list of `codex app-server`, the same list the Codex UI offers; hidden models are left out. */
+export function codexModelsFromList(data) {
+    return (Array.isArray(data) ? data : []).filter((m) => m && m.hidden !== true)
+        .map((m) => codexModel(m.id ?? m.model, m.displayName, (Array.isArray(m.supportedReasoningEfforts) ? m.supportedReasoningEfforts : []).map((e) => e?.reasoningEffort), m.defaultReasoningEffort))
+        .filter((m) => m !== null).slice(0, 64);
+}
+function cachedCodexModels(cache) {
+    return (Array.isArray(cache?.models) ? cache.models : []).filter((m) => m?.visibility === 'list')
+        .map((m) => codexModel(m.slug, m.display_name, (Array.isArray(m.supported_reasoning_levels) ? m.supported_reasoning_levels : []).map((level) => typeof level === 'string' ? level : level?.effort), m.default_reasoning_level))
+        .filter((m) => m !== null).slice(0, 64);
+}
+/** Asks a short-lived `codex app-server` for model/list, following pages, and gives up after the timeout. */
+export async function codexModelList(options = {}) {
+    const pending = new Map();
+    let nextId = 0;
+    const agent = startAgentProcess({
+        command: options.command ?? 'codex', args: ['app-server'], cwd: homedir(), env: {}, spawnAgent: options.spawnAgent,
+        onLine: line => {
+            try {
+                const message = JSON.parse(line);
+                if (message.id !== undefined && message.method === undefined)
+                    pending.get(message.id)?.(message);
+            }
+            catch { }
+        },
+    });
+    const request = (method, params) => new Promise((resolvePromise, reject) => {
+        const id = ++nextId;
+        pending.set(id, message => message.error ? reject(new Error(String(message.error.message))) : resolvePromise(message.result ?? {}));
+        if (!agent.write(JSON.stringify({ id, method, params })))
+            reject(new Error('Codex is not accepting input.'));
+    });
+    const ask = async () => {
+        await request('initialize', { clientInfo: { name: 'skillshare', title: 'Skillshare', version: '0.0.0' }, capabilities: { experimentalApi: true } });
+        agent.write(JSON.stringify({ method: 'initialized' }));
+        const data = [];
+        let cursor;
+        for (let page = 0; page < 10; page++) {
+            const result = await request('model/list', cursor ? { cursor } : {});
+            data.push(...(Array.isArray(result.data) ? result.data : []));
+            cursor = typeof result.nextCursor === 'string' && result.nextCursor ? result.nextCursor : undefined;
+            if (!cursor)
+                break;
+        }
+        return codexModelsFromList(data);
+    };
+    let timer;
+    try {
+        const models = await Promise.race([ask(), agent.exited.then(() => null),
+            new Promise(resolvePromise => { timer = setTimeout(() => resolvePromise(null), options.timeoutMs ?? 20_000); })]);
+        return models && models.length > 0 ? models : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+        await agent.kill();
+    }
+}
 export function parseProfiles(text, home, problems = []) {
     if (text === null)
         return [];

package/dist/agents-process.js

@@ -0,0 +1,50 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+/**
+ * Starts an agent that speaks newline-delimited JSON on stdio. Tokens go through the environment only. A separate
+ * process group lets stopping the agent also stop the shell commands it runs.
+ */
+export function startAgentProcess(options) {
+    const posix = process.platform !== 'win32';
+    const child = (options.spawnAgent ?? spawn)(options.command, options.args, {
+        cwd: options.cwd, env: { ...process.env, ...options.env }, stdio: ['pipe', 'pipe', 'pipe'],
+        detached: posix, windowsHide: true, shell: !posix,
+    });
+    let stderr = '';
+    child.stderr?.on('data', chunk => { stderr = (stderr + chunk).slice(-4000); });
+    child.stdin?.on('error', () => { });
+    if (child.stdout)
+        createInterface({ input: child.stdout, crlfDelay: Infinity }).on('line', line => { if (line.trim())
+            options.onLine(line); });
+    const exited = new Promise(resolve => {
+        child.once('error', error => { stderr = (stderr + '\n' + error.message).slice(-4000); resolve(null); });
+        child.once('exit', code => resolve(code));
+    });
+    let killing = null;
+    return {
+        child,
+        exited,
+        stderrTail: () => stderr.trim().split(/\r?\n/).filter(line => line.trim()).slice(-3).join(' ').slice(-300),
+        write: line => child.stdin?.writable ? child.stdin.write(line + '\n') : false,
+        kill() {
+            killing ??= (async () => {
+                const signal = (sig) => {
+                    try {
+                        if (posix && child.pid)
+                            process.kill(-child.pid, sig);
+                        else
+                            child.kill(sig);
+                    }
+                    catch { }
+                };
+                child.stdin?.end();
+                signal('SIGTERM');
+                const timer = setTimeout(() => signal('SIGKILL'), 5000);
+                timer.unref?.();
+                await exited;
+                clearTimeout(timer);
+            })();
+            return killing;
+        },
+    };
+}

package/dist/agents-session.js

@@ -0,0 +1,296 @@
+import { setTimeout as delay } from 'node:timers/promises';
+/** Read-only tools Claude Code may use in a sandboxed session; the session's MCP servers are added per server. */
+export const CLAUDE_SANDBOX_TOOLS = ['Read', 'Grep', 'Glob', 'WebSearch', 'WebFetch'];
+export const SANDBOX_NOTE = 'This session is sandboxed: you can read files, search and use the provided MCP tools, but you cannot change files or ' +
+    'run commands that modify anything.';
+export const DEFAULT = 'default';
+const MAX_TEXT = 50_000;
+export function isSandboxed(configuration, options) {
+    return options.sandbox === true || options.profile?.sandbox === true || configuration.sandbox === true;
+}
+/** MCP server names become tool prefixes and config keys, so they are reduced to a safe alphabet. */
+export function mcpServerName(server, index) {
+    return server.name.replace(/[^A-Za-z0-9_-]/g, '_') || `server_${index}`;
+}
+/** Tokens go to environment variables only, so they never appear in a command line or a protocol frame. */
+export function mcpTokenEnvironment(servers) {
+    return Object.fromEntries(servers.map((server, index) => [`SKILLSHARE_MCP_TOKEN_${index}`, server.bearerToken]));
+}
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function clip(text, length = MAX_TEXT) {
+    return text.length <= length ? text : text.slice(0, length) + '…';
+}
+export function oneLine(text, length = 300) {
+    return clip(text.replace(/\s+/g, ' ').trim(), length);
+}
+/**
+ * Batches a session's events for upload. Updates of the same transcript entry are merged, so a fast stream of text
+ * deltas costs one request per flush, and a slow connection never queues more than one copy of each entry.
+ */
+export class EventQueue {
+    upload;
+    intervalMs;
+    onGone;
+    queue = [];
+    flushing = null;
+    timer = null;
+    gone = false;
+    constructor(upload, intervalMs = 1000, onGone = () => { }) {
+        this.upload = upload;
+        this.intervalMs = intervalMs;
+        this.onGone = onGone;
+    }
+    push(event) {
+        if (this.gone)
+            return;
+        if (event.type === 'item') {
+            const index = this.queue.findIndex(e => e.type === 'item' && e.key === event.key);
+            if (index >= 0) {
+                // Only the latest state of an entry matters; keep its place so the transcript order stays stable.
+                this.queue[index] = { ...this.queue[index], ...event };
+                this.schedule();
+                return;
+            }
+        }
+        this.queue.push(event);
+        if (event.type === 'item')
+            this.schedule();
+        else
+            void this.flush();
+    }
+    schedule() {
+        if (this.timer)
+            return;
+        this.timer = setTimeout(() => { this.timer = null; void this.flush(); }, this.intervalMs);
+    }
+    /** Sends everything queued so far, retrying with backoff until it is accepted or the server rejects the session. */
+    flush() {
+        if (this.flushing)
+            return this.flushing.then(() => this.queue.length > 0 ? this.flush() : undefined);
+        this.flushing = (async () => {
+            let failures = 0;
+            while (this.queue.length > 0 && !this.gone) {
+                const batch = this.queue.slice(0, 200);
+                const result = await this.upload(batch).catch(() => 'retry');
+                if (result === 'gone') {
+                    this.gone = true;
+                    this.queue = [];
+                    this.onGone();
+                    break;
+                }
+                if (result === 'retry') {
+                    await delay(Math.min(30_000, 1000 * 2 ** Math.min(failures++, 5)));
+                    continue;
+                }
+                failures = 0;
+                this.queue.splice(0, batch.length);
+            }
+        })().finally(() => { this.flushing = null; });
+        return this.flushing;
+    }
+}
+/**
+ * Runs one session on this computer: starts the agent, feeds it the user's messages one turn at a time, enforces the turn
+ * timeout, closes the agent after a quiet period and reports everything as SessionEvents. The server decides what happens
+ * next; the runner only reports and obeys.
+ */
+export class SessionRunner {
+    options;
+    sessionId;
+    leaseToken;
+    events;
+    driver;
+    seen = new Set();
+    pending = [];
+    steering = new Set();
+    now;
+    opened = null;
+    openSucceeded = false;
+    turnRunning = false;
+    interruptRequested = false;
+    idleTimer = null;
+    closing = null;
+    closedReported = false;
+    done;
+    resolveDone;
+    constructor(options) {
+        this.options = options;
+        this.sessionId = options.sessionId;
+        this.leaseToken = options.leaseToken;
+        this.now = options.now ?? Date.now;
+        this.done = new Promise(resolve => { this.resolveDone = resolve; });
+        // A rejected lease means the server moved on; the agent must stop without reporting anything more.
+        this.events = new EventQueue(options.upload, options.flushIntervalMs, () => void this.stop());
+        this.driver = options.driver({
+            sessionId: options.sessionId,
+            start: options.start,
+            workdir: options.workdir,
+            profile: options.profile,
+            sandbox: options.sandbox,
+            item: item => this.events.push({ type: 'item', ...item, text: item.text === undefined ? undefined : clip(item.text) }),
+            thread: threadId => this.events.push({ type: 'thread', threadId }),
+            exited: error => void this.finish(error ?? 'The agent stopped unexpectedly.'),
+        });
+    }
+    get stopping() { return this.closing !== null; }
+    /**
+     * Queues messages for the next turns, or steers them into the running turn; the server may send a message again, so
+     * repeats are ignored.
+     */
+    send(messages) {
+        for (const message of messages) {
+            if (this.seen.has(message.id))
+                continue;
+            this.seen.add(message.id);
+            if (message.steer && this.turnRunning && this.openSucceeded && this.driver.steer)
+                this.steer(message);
+            else
+                this.pending.push(message);
+        }
+        void this.pump();
+    }
+    /** A message that misses the running turn becomes the next one, ahead of anything queued after it. */
+    steer(message) {
+        const task = (async () => {
+            let outcome = 'notSent';
+            try {
+                outcome = await this.driver.steer(message);
+            }
+            catch { }
+            if (this.closing)
+                return;
+            if (outcome === 'steered')
+                this.events.push({ type: 'steered', messageId: message.id });
+            else
+                this.pending.unshift(message);
+        })();
+        this.steering.add(task);
+        void task.finally(() => {
+            this.steering.delete(task);
+            void this.pump();
+        });
+    }
+    async interrupt() {
+        if (!this.turnRunning || this.interruptRequested)
+            return;
+        this.interruptRequested = true;
+        await this.driver.interrupt().catch(() => { });
+    }
+    /** Stops the agent and reports the session as closed, so the server can resume it later or finish ending it. */
+    close(error) {
+        return this.finish(error);
+    }
+    /** Stops the agent without reporting, because the server no longer accepts this lease. */
+    stop() {
+        this.closedReported = true;
+        return this.finish();
+    }
+    async pump() {
+        // While a steer is still being placed it decides what runs next; it pumps again once it knows.
+        if (this.turnRunning || this.closing || this.steering.size > 0)
+            return;
+        const message = this.pending.shift();
+        if (!message) {
+            this.armIdle();
+            return;
+        }
+        this.clearIdle();
+        this.turnRunning = true;
+        this.interruptRequested = false;
+        const started = this.now();
+        if (!this.openSucceeded) {
+            try {
+                this.opened ??= this.driver.open();
+                await this.opened;
+                this.openSucceeded = true;
+            }
+            catch (error) {
+                const reason = errorMessage(error);
+                // A failed resume uses up the message as a failed turn, so the server does not ask for the same start again.
+                // A first start that fails has nothing to resume; the server fails the whole session.
+                if (this.options.start.resumeThreadId) {
+                    this.events.push({ type: 'turnStarted', messageId: message.id });
+                    this.events.push({ type: 'turnCompleted', status: 'failed', error: reason });
+                }
+                this.turnRunning = false;
+                await this.finish(reason);
+                return;
+            }
+        }
+        if (this.closing)
+            return;
+        this.events.push({ type: 'turnStarted', messageId: message.id });
+        let outcome;
+        try {
+            outcome = await this.withTimeout(this.driver.turn(message));
+        }
+        catch (error) {
+            outcome = { status: 'failed', error: errorMessage(error) };
+        }
+        if (this.closing)
+            return;
+        if (this.interruptRequested && outcome.status === 'failed' && !outcome.error)
+            outcome = { ...outcome, status: 'interrupted' };
+        this.events.push({ type: 'turnCompleted', status: outcome.status, error: outcome.error,
+            stats: { ...outcome.stats, durationMs: this.now() - started } });
+        this.turnRunning = false;
+        void this.events.flush();
+        void this.pump();
+    }
+    /** Interrupts a turn that runs past its timeout, and gives up on an agent that does not stop when asked. */
+    async withTimeout(turn) {
+        const timeoutMs = Math.max(1, this.options.start.turnTimeoutSeconds) * 1000;
+        let timer;
+        let expired = false;
+        const timedOut = new Promise(resolve => {
+            timer = setTimeout(async () => {
+                expired = true;
+                await this.interrupt();
+                const stopped = await Promise.race([turn.then(() => true), delay(15_000).then(() => false)]);
+                resolve(stopped ? { status: 'interrupted', error: `The turn did not finish within ${this.options.start.turnTimeoutSeconds} seconds.` }
+                    : { status: 'failed', error: `The agent did not stop after ${this.options.start.turnTimeoutSeconds} seconds.` });
+                if (!stopped)
+                    void this.finish(`The agent did not stop after ${this.options.start.turnTimeoutSeconds} seconds.`);
+            }, timeoutMs);
+        });
+        try {
+            const outcome = await Promise.race([turn, timedOut]);
+            // The interrupt usually ends the turn before the timeout path does; the outcome should still say why it stopped.
+            return expired && outcome.status !== 'completed' && !outcome.error
+                ? { ...outcome, error: `The turn did not finish within ${this.options.start.turnTimeoutSeconds} seconds.` } : outcome;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    armIdle() {
+        this.clearIdle();
+        if (this.closing)
+            return;
+        this.idleTimer = setTimeout(() => void this.close(), this.options.idleMs ?? 15 * 60_000);
+    }
+    clearIdle() {
+        if (this.idleTimer)
+            clearTimeout(this.idleTimer);
+        this.idleTimer = null;
+    }
+    finish(error) {
+        this.closing ??= (async () => {
+            this.clearIdle();
+            await this.driver.close().catch(() => { });
+            if (this.turnRunning && !this.closedReported) {
+                this.events.push({ type: 'turnCompleted', status: 'failed', error: error ?? 'The agent was stopped.' });
+                this.turnRunning = false;
+            }
+            if (!this.closedReported) {
+                this.closedReported = true;
+                this.events.push({ type: 'closed', error });
+            }
+            await this.events.flush();
+            this.resolveDone();
+        })();
+        return this.closing;
+    }
+}

package/dist/agents.js

@@ -3,8 +3,10 @@ import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { hostname, platform } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
+import { createClaudeDriver } from './agents-claude.js';
+import { createCodexDriver } from './agents-codex.js';
 import { detectAgents, profilesPath } from './agents-detect.js';
-import { runAgent } from './agents-run.js';
+import { SessionRunner } from './agents-session.js';
 import { readCliVersion } from './help.js';
 const root = '/api/agents';
 const PROFILE_HINT = 'Declare named profiles in ' + profilesPath() + ' to set a working directory or extra arguments.';
@@ -42,7 +44,7 @@ export async function loadListenerId(appDirectory, baseUrl, userId) {
     await writeFile(file, JSON.stringify({ id }, null, 2), { mode: 0o600 });
     return id;
 }
-export async function runAgentsCommand(client, args, flags, appDirectory) {
+export async function runAgentsCommand(client, args, flags, appDirectory, teamsWatch) {
     const action = args[0];
     if (action === 'status') {
         const detected = await detectAgents();
@@ -71,10 +73,18 @@ export async function runAgentsCommand(client, args, flags, appDirectory) {
     console.log(sandbox
         ? 'Sandboxed: agents may read files, search and use the Skillshare MCP tools, but cannot change files or run commands that modify anything.'
         : 'Agents run with your full local permissions and configuration, without permission prompts. Use --sandbox to keep them read-only.');
+    console.log('Sessions keep their agent running between messages and close it after 15 quiet minutes; the next message resumes it.');
+    // Teams 👀 sessions need a live Teams session, so the listener keeps it renewed unless told not to.
+    const teams = teamsWatch && flags['no-teams-watch'] !== 'true'
+        ? teamsWatch(abort.signal, message => console.log(`[teams] ${message}`))
+            .catch(error => console.log(`[teams] Teams renewal stopped: ${error instanceof Error ? error.message : String(error)}`))
+        : Promise.resolve();
     try {
         await listen({ client, listenerId, name: flags.name, workdir, maxConcurrency: max, sandbox, signal: abort.signal, onProgress: console.log });
     }
     finally {
+        abort.abort();
+        await teams;
         process.removeListener('SIGINT', stop);
         process.removeListener('SIGTERM', stop);
     }
@@ -100,11 +110,13 @@ export function renderDetected(listenerId, server, detected) {
 }
 export async function listen(options) {
     const detect = options.detect ?? (() => detectAgents());
-    const run = options.run ?? runAgent;
+    const codex = createCodexDriver({ clientVersion: readCliVersion() });
+    const claude = createClaudeDriver();
+    const driver = options.driver ?? (start => start.configuration.agent === 'codex' ? codex : claude);
     const wait = options.wait ?? (async (ms, signal) => { await delay(ms, undefined, { signal }); });
     const now = options.now ?? Date.now;
     const log = options.onProgress ?? (() => { });
-    const running = new Map();
+    const sessions = new Map();
     let detected = await detect();
     let registeredFingerprint = '';
     let detectedAt = now();
@@ -119,48 +131,52 @@ export async function listen(options) {
         registeredFingerprint = fingerprint;
         for (const problem of detected.problems)
             log(`! ${problem}`);
-        log(`Listening as "${registered.name}" with ${registered.effectiveConcurrency} slot(s): ${describe(detected)}. Choose what runs where under Connected agents on ${options.client.baseUrl}.`);
+        log(`Listening as "${registered.name}" with ${registered.effectiveConcurrency} slot(s): ${describe(detected)}. Start sessions and choose routes under Connected agents on ${options.client.baseUrl}.`);
     }
-    async function report(assignment, result) {
-        const path = `${root}/tasks/${assignment.taskId}/${result.ok ? 'result' : 'failure'}`;
-        const body = result.ok ? { leaseToken: assignment.leaseToken, markdown: result.markdown, stats: result.stats }
-            : { leaseToken: assignment.leaseToken, reason: result.reason, cancelled: result.cancelled, stats: result.stats };
-        for (let attempt = 0; attempt < 5; attempt++) {
+    /** Posts a batch of session events: a rejected lease means the server moved on and the agent must stop. */
+    function uploader(sessionId, leaseToken) {
+        return async (events) => {
             try {
-                await send(options.client, 'POST', path, body);
-                return;
+                await send(options.client, 'POST', `${root}/sessions/${sessionId}/events`, { leaseToken, events });
+                return 'ok';
             }
             catch (error) {
-                // A rejected lease means the server already moved on; retrying cannot help.
-                if (error instanceof AgentsHttpError && error.status >= 400 && error.status < 500) {
-                    log(`Task ${assignment.taskId} result was not accepted: ${error.message}`);
-                    return;
-                }
-                if (attempt < 4)
-                    await delay(2000 * (attempt + 1)).catch(() => { });
+                if (error instanceof AgentsHttpError && error.status >= 400 && error.status < 500)
+                    return 'gone';
+                return 'retry';
             }
-        }
-        log(`Task ${assignment.taskId} result could not be delivered; the server will retry the task after its lease expires.`);
+        };
     }
-    function start(assignment) {
-        if (running.has(assignment.taskId))
+    function start(command) {
+        if (!command.start || !command.leaseToken)
             return;
-        const abort = new AbortController();
-        const profile = assignment.configuration.profile ? detected.profiles.find(p => p.name === assignment.configuration.profile) : undefined;
-        log(`Started task ${assignment.taskId} "${assignment.title}" with ${label(assignment)}.`);
-        const done = (async () => {
-            let result;
-            try {
-                result = await run(assignment, { workdir: options.workdir, profile, sandbox: options.sandbox, signal: abort.signal });
-            }
-            catch (error) {
-                result = { ok: false, reason: `The listener could not run the agent: ${error instanceof Error ? error.message : String(error)}`, cancelled: false, stats: {} };
-            }
-            log(result.ok ? `Finished task ${assignment.taskId}.` : `${result.cancelled ? 'Cancelled' : 'Failed'} task ${assignment.taskId}: ${result.reason}`);
-            await report(assignment, result);
-            running.delete(assignment.taskId);
-        })();
-        running.set(assignment.taskId, { assignment, abort, done });
+        // A start for a session already held replaces its agent, for example to hand it fresh credentials.
+        const previous = sessions.get(command.sessionId);
+        if (previous)
+            void previous.stop();
+        const profile = command.start.configuration.profile ? detected.profiles.find(p => p.name === command.start.configuration.profile) : undefined;
+        const runner = new SessionRunner({
+            sessionId: command.sessionId, leaseToken: command.leaseToken, start: command.start, workdir: options.workdir, profile, sandbox: options.sandbox === true,
+            driver: driver(command.start), upload: uploader(command.sessionId, command.leaseToken), idleMs: options.idleMs, flushIntervalMs: options.flushIntervalMs,
+            now,
+        });
+        sessions.set(command.sessionId, runner);
+        log(`${command.start.resumeThreadId ? 'Resumed' : 'Started'} session ${command.sessionId} "${command.start.title}" with ${label(command.start)}.`);
+        void runner.done.then(() => {
+            if (sessions.get(command.sessionId) === runner)
+                sessions.delete(command.sessionId);
+            log(`Closed session ${command.sessionId}.`);
+        });
+        runner.send(command.messages ?? []);
+    }
+    function handle(command) {
+        const runner = sessions.get(command.sessionId);
+        switch (command.type) {
+            case 'start': return start(command);
+            case 'send': return runner?.send(command.messages ?? []);
+            case 'interrupt': return void runner?.interrupt();
+            case 'close': return void runner?.close();
+        }
     }
     try {
         while (!options.signal.aborted) {
@@ -173,17 +189,14 @@ export async function listen(options) {
                     await register();
                 const polledAt = now();
                 const response = await send(options.client, 'POST', `${root}/listeners/${options.listenerId}/poll`, {
-                    // A task that is already stopping is not reported, otherwise the server would answer every poll with its cancellation.
-                    running: [...running.values()].filter(r => !r.abort.signal.aborted)
-                        .map(r => ({ taskId: Number(r.assignment.taskId), leaseToken: r.assignment.leaseToken })),
+                    // A session that is already closing is not reported, so the server treats its agent as gone.
+                    sessions: [...sessions.values()].filter(r => !r.stopping).map(r => ({ sessionId: r.sessionId, leaseToken: r.leaseToken })),
                     waitSeconds: options.pollWaitSeconds ?? 25,
                 }, options.signal);
                 failures = 0;
-                for (const id of response.cancel)
-                    running.get(id)?.abort.abort();
-                for (const assignment of response.assignments)
-                    start(assignment);
-                if (response.assignments.length === 0 && now() - polledAt < 1000)
+                for (const command of response.commands)
+                    handle(command);
+                if (response.commands.length === 0 && now() - polledAt < 1000)
                     await wait(1000, options.signal).catch(() => { });
             }
             catch (error) {
@@ -206,13 +219,12 @@ export async function listen(options) {
         }
     }
     finally {
-        for (const task of running.values())
-            task.abort.abort();
-        await Promise.all([...running.values()].map(task => task.done));
+        // Closing reports each session as closed, so the server knows at once that the next message must resume it.
+        await Promise.all([...sessions.values()].map(runner => runner.close()));
     }
 }
-function label(assignment) {
-    const { configuration } = assignment;
+function label(start) {
+    const { configuration } = start;
     if (configuration.profile)
         return `profile ${configuration.profile}`;
     return [configuration.agent === 'claude' ? 'Claude Code' : 'Codex', configuration.model, configuration.reasoning]