@turns/dev 0.0.16 → 0.0.18

package/README.md

@@ -38,6 +38,23 @@ process to stay resident. A run narrowed to a directory — watching or `--once`
 never prunes saved upload cursors, so it cannot make the sessions it filtered
 out replay from their first byte the next time the daemon starts.
 
+Native background tasks retain their detached agent anchor after the foreground
+prompt finishes, including while the daemon client is disconnected. Codex child
+agents, Claude/Letta tasks, ACP task tools, Prime/OMP jobs, and DeepSeek jobs
+suspend the normal five-minute idle cleanup. Follow-up prompts remain available;
+the anchor starts a fresh idle countdown after the last known task finishes or
+its transport exits. Explicit shutdown, interruption, transport replacement, and
+turn timeouts retain their existing semantics.
+
+Retention uses native lifecycle events and task-tool results. Assistant prose,
+a completed launch tool, or a failed status query does not prove that a task has
+finished. Copilot, Hermes, and OpenCode captures lack reliable terminal evidence
+in their live streams, so their anchors can stay resident until a later native
+status result, transport exit, or explicit shutdown. No time-based fallback kills
+quiet tasks. One-shot harnesses such as Muse and Antigravity already remain
+foreground-running until their native process exits; there is no warm child
+process for idle cleanup to kill afterward.
+
 The server is selected with `--server URL` or `TURNS_ORIGIN`. Its normalized
 origin is saved and reused by later invocations and daemon starts. On Linux,
 Turns uses the XDG config/state directories and installs this user service:

package/dist/agent-anchor.js

@@ -12,6 +12,7 @@ import { ACP_PROFILES, lettaHeadlessEnvironment, lettaSessionIdentity, PROCESS_H
 import { asyncQuestionInteractions, asyncQuestionReplyText, isAsyncQuestionInteraction, parseAsyncQuestionReplies, } from "./codex-async-questions.js";
 import { recordLettaSessionContext } from "./letta-session-context.js";
 import { recoverAsyncQuestion } from "./codex-async-question-recovery.js";
+import { BackgroundTaskState } from "./background-task-state.js";
 const socketIndex = process.argv.indexOf('--socket');
 const socketPath = socketIndex >= 0 ? path.resolve(process.argv[socketIndex + 1] || '') : '';
 if (!socketPath)
@@ -98,6 +99,7 @@ function childResult(child, timeoutMs) {
     return result.promise;
 }
 class LineTransport {
+    backgroundTasks;
     anchor;
     harness;
     nextId;
@@ -107,6 +109,7 @@ class LineTransport {
     constructor(anchor, harness, command, args, cwd, env = {}) {
         this.anchor = anchor;
         this.harness = harness;
+        this.backgroundTasks = new BackgroundTaskState(anchor.source);
         this.nextId = 1;
         this.pending = new Map();
         this.lastEventAt = Date.now();
@@ -135,6 +138,9 @@ class LineTransport {
             for (const waiter of this.pending.values())
                 waiter.reject(error);
             this.pending.clear();
+            this.backgroundTasks.clear();
+            if (this.anchor.transport === this && this.anchor.status === 'idle')
+                this.anchor.scheduleExit();
             this.onClose?.(error);
         });
     }
@@ -157,6 +163,11 @@ class LineTransport {
             json = JSON.parse(line);
         }
         catch { }
+        const wasActive = this.backgroundTasks.active;
+        this.backgroundTasks.observe({ json }, this.anchor.agentSessionId);
+        if (wasActive !== this.backgroundTasks.active && this.anchor.transport === this && this.anchor.status === 'idle') {
+            this.anchor.scheduleExit();
+        }
         this.anchor.emitLive({
             direction: 'in',
             source: `${this.harness}.stdout`,
@@ -188,7 +199,6 @@ class LineTransport {
     }
 }
 class ClaudeTransport extends LineTransport {
-    backgroundTasks = new Set();
     sessionId;
     permissionMode;
     turnWaiter;
@@ -228,18 +238,6 @@ class ClaudeTransport extends LineTransport {
     onFrame(frame) {
         if (!frame || typeof frame !== 'object')
             return;
-        if (frame.type === 'system' && typeof frame.task_id === 'string') {
-            if (frame.subtype === 'task_started' && frame.is_backgrounded !== false) {
-                this.backgroundTasks.add(frame.task_id);
-            }
-            else if (frame.subtype === 'task_notification') {
-                this.backgroundTasks.delete(frame.task_id);
-            }
-            // A result completes the foreground prompt, not the tasks it launched.
-            // Keep accepting new prompts while those tasks retain the warm process.
-            if (this.anchor.status === 'idle')
-                this.anchor.scheduleExit();
-        }
         if (frame.type === 'system' && frame.subtype === 'init' && frame.session_id) {
             this.sessionId = String(frame.session_id);
             if (this.sessionId !== this.anchor.agentSessionId)
@@ -269,9 +267,6 @@ class ClaudeTransport extends LineTransport {
             void this.answerReverse(frame);
     }
     onClose(error) {
-        this.backgroundTasks.clear();
-        if (this.anchor.status === 'idle')
-            this.anchor.scheduleExit();
         if (this.turnWaiter) {
             this.turnWaiter.reject(error);
             this.turnWaiter = null;
@@ -335,6 +330,28 @@ class ClaudeTransport extends LineTransport {
         timer.unref?.();
         return waiter.promise.finally(() => clearTimeout(timer));
     }
+    /**
+     * Claude Code folds a stdin `user` frame that arrives during a turn into that
+     * turn: the model reads it after the tool calls in flight finish, within the
+     * same `result`, and the transcript records it as a `queued_command`
+     * attachment rather than a new user row (verified on 2.1.280). `priority`
+     * selects what happens to the running work. `next` is the fold described
+     * above and matches what the interactive TUI does when the user types while
+     * Claude works. `now` would end the running turn with `aborted_tools` and
+     * answer the message as a fresh turn, which is the interrupt fallback the
+     * queue already offers, so it is not used here.
+     */
+    steer(text, _messageId = '') {
+        if (!this.turnWaiter)
+            throw new Error('Claude has no active turn to steer.');
+        this.emit({
+            type: 'user',
+            session_id: this.sessionId,
+            message: { role: 'user', content: [{ type: 'text', text }] },
+            parent_tool_use_id: null,
+            priority: 'next',
+        });
+    }
     async interrupt() {
         try {
             await this.controlRequest('interrupt');
@@ -1184,6 +1201,7 @@ class OmpRpcTransport extends RpcTransport {
     }
 }
 class DeepseekTransport {
+    backgroundTasks;
     anchor;
     sessionId;
     waiter;
@@ -1191,6 +1209,7 @@ class DeepseekTransport {
     base;
     constructor(anchor) {
         this.anchor = anchor;
+        this.backgroundTasks = new BackgroundTaskState('deepseek');
         this.sessionId = anchor.agentSessionId;
         this.waiter = null;
         this.socket = null;
@@ -1200,6 +1219,13 @@ class DeepseekTransport {
         this.base = base;
         this.socket = new WebSocket(`${base.replace(/^http/, 'ws')}/api/events.mux`);
         this.socket.on('message', (bytes) => this.receive(String(bytes)));
+        this.socket.once('close', () => {
+            this.backgroundTasks.clear();
+            this.waiter?.reject(new Error('DeepSeek transport closed.'));
+            this.waiter = null;
+            if (this.anchor.transport === this && this.anchor.status === 'idle')
+                this.anchor.scheduleExit();
+        });
         await new Promise((resolve, reject) => {
             this.socket.once('open', resolve);
             this.socket.once('error', reject);
@@ -1223,6 +1249,11 @@ class DeepseekTransport {
         }
         if (String(frame?.payload?.sessionId || '') !== this.sessionId)
             return;
+        const wasActive = this.backgroundTasks.active;
+        this.backgroundTasks.observe({ json: frame });
+        if (wasActive !== this.backgroundTasks.active && this.anchor.transport === this && this.anchor.status === 'idle') {
+            this.anchor.scheduleExit();
+        }
         this.anchor.emitLive({
             direction: 'in',
             source: 'deepseek.websocket',
@@ -1291,10 +1322,20 @@ class DeepseekTransport {
     async prompt(text, timeoutMs) {
         const waiter = deferred();
         this.waiter = waiter;
-        await this.rpc('session.prompt', { sessionId: this.sessionId, mode: 'queue', content: [{ type: 'text', text }] });
         const timer = setTimeout(() => waiter.reject(new Error('DeepSeek turn timed out.')), timeoutMs);
         timer.unref?.();
-        return waiter.promise.finally(() => clearTimeout(timer));
+        // Observe both promises immediately: the event socket can close before the
+        // HTTP acknowledgement arrives, and must not produce an unhandled rejection.
+        return Promise.all([
+            this.rpc('session.prompt', { sessionId: this.sessionId, mode: 'queue', content: [{ type: 'text', text }] }),
+            waiter.promise,
+        ])
+            .then(([, result]) => result)
+            .finally(() => {
+            clearTimeout(timer);
+            if (this.waiter === waiter)
+                this.waiter = null;
+        });
     }
     interrupt() {
         return this.rpc('session.cancel', { sessionId: this.sessionId });
@@ -1574,7 +1615,7 @@ class Anchor {
     }
     scheduleExit() {
         clearTimeout(this.idleTimer);
-        if (this.status === 'running' || this.pendingInteractions.size || this.transport?.backgroundTasks?.size) {
+        if (this.status === 'running' || this.pendingInteractions.size || this.transport?.backgroundTasks?.active) {
             this.idleTimer = null;
             return;
         }

package/dist/background-task-state.js

@@ -0,0 +1,471 @@
+/** Native background-work leases owned by the detached anchor, not its client.
+ * This intentionally consumes protocol envelopes rather than searching stdout,
+ * user prompts, assistant prose, or command output for apparent task statuses. */
+const RUNNING = new Set([
+    'accepted',
+    'active',
+    'created',
+    'dispatched',
+    'in_progress',
+    'inprogress',
+    'pending',
+    'queued',
+    'running',
+    'started',
+    'working',
+]);
+const TERMINAL = new Set([
+    'aborted',
+    'cancelled',
+    'canceled',
+    'completed',
+    'complete',
+    'done',
+    'error',
+    'errored',
+    'exited',
+    'failed',
+    'failure',
+    'finished',
+    'idle',
+    'killed',
+    'rejected',
+    'result_ready',
+    'stopped',
+    'succeeded',
+    'success',
+    'terminated',
+]);
+const STATUS_TOOLS = /^(?:taskoutput|task_output|tasklist|task_list|taskstop|task_stop|list_agents|wait_agent|read_agent|subagent_status|subagent_wait|subagent_read_result|read_subagent|list_background_processes|read_background_output|job_list|job_output|job_kill|hub|shell_status|shell_wait|shell_list|manage_subagents|get_command_or_subagent_output)$/u;
+const ID_KEYS = [
+    'task_id',
+    'taskId',
+    'agent_id',
+    'agentId',
+    'subagent_id',
+    'subagentId',
+    'agent_path',
+    'agentPath',
+    'delegation_id',
+    'delegationId',
+    'job_id',
+    'jobId',
+    'shell_id',
+    'shellId',
+    'rlm_child_id',
+    'rlmChildId',
+    'backgroundTaskId',
+];
+const MAX_HISTORY = 512;
+const object = (value) => (value && typeof value === 'object' && !Array.isArray(value) ? value : null);
+const string = (value) => (typeof value === 'string' ? value : '');
+const normalized = (value) => string(value)
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/gu, '_')
+    .replace(/^_|_$/gu, '');
+function decode(value) {
+    if (typeof value !== 'string')
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function status(value) {
+    if (object(value))
+        value = Object.keys(value).find((key) => RUNNING.has(normalized(key)) || TERMINAL.has(normalized(key)));
+    const key = normalized(value);
+    if (RUNNING.has(key))
+        return 'running';
+    if (TERMINAL.has(key) || /^exited_\d+$/u.test(key))
+        return 'terminal';
+}
+function background(value) {
+    const input = object(decode(value));
+    return Boolean(input &&
+        (input.run_in_background === true ||
+            input.runInBackground === true ||
+            input.background === true ||
+            input.is_background === true ||
+            input.isBackground === true ||
+            input.async === true ||
+            input.mode === 'background'));
+}
+function nativeIds(value) {
+    const record = object(value);
+    if (!record)
+        return [];
+    return ID_KEYS.flatMap((key) => typeof record[key] === 'string' || typeof record[key] === 'number' ? [String(record[key])] : []).slice(0, 1);
+}
+function textIds(value) {
+    const ids = [];
+    for (const pattern of [
+        /(?:task|agent|subagent|delegation|job|shell)[ _-]?id\s*[:=]\s*["'`]?([A-Za-z0-9_./:-]+)/giu,
+        /(?:background with ID:|Backgrounded as job|started background job)\s*([A-Za-z0-9_./:-]+)/giu,
+        /(?:background\s*\(PID:\s*|\[PID\s+)(\d+)/giu,
+        /\bShell\s+([A-Za-z0-9_.:-]+)(?:,|\n)/gu,
+        /\brlm_child_id=['"]([^'"]+)['"]/gu,
+        /\/delegation\/live\/([^/\s"']+)/gu,
+    ])
+        for (const match of value.matchAll(pattern))
+            ids.push(match[1].replace(/[.,;]+$/u, ''));
+    return [...new Set(ids)];
+}
+function contents(value, depth = 0) {
+    if (depth > 10)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    if (Array.isArray(value))
+        return value.map((child) => contents(child, depth + 1)).join('\n');
+    return object(value)
+        ? contents(value.text ?? value.content ?? value.output ?? value.observation ?? '', depth + 1)
+        : '';
+}
+function textStatus(value) {
+    // Only provider status headers, not words inside a shell command or its output.
+    const reported = value.match(/(?:^|\n|,\s*)(?:status|state|final_sub_status)\s*[:=]\s*["']?([\w -]+)/iu)?.[1];
+    if (reported)
+        return status(reported.split(/[,\n]/u)[0].trim());
+    if (/^(?:Subagent completed:|Agent (?:completed|finished)|<task-notification>)/u.test(value))
+        return 'terminal';
+    if (/\b(?:Command moved to background|Command running in background with ID:|Agent started in background|Backgrounded as job|started background job)\b/u.test(value))
+        return 'running';
+}
+export class BackgroundTaskState {
+    activeIds = new Set();
+    calls = new Map();
+    aliases = new Map();
+    terminalIds = new Set();
+    children = new Set();
+    harness;
+    sessionId;
+    constructor(harness, sessionId = '') {
+        this.harness = harness;
+        this.sessionId = sessionId;
+    }
+    get active() {
+        return this.activeIds.size > 0;
+    }
+    clear() {
+        this.activeIds.clear();
+        this.calls.clear();
+        this.aliases.clear();
+        this.terminalIds.clear();
+        this.children.clear();
+    }
+    update(id, state, restart = false) {
+        if (typeof id !== 'string' || !id || id.length > 512)
+            return;
+        const key = this.aliases.get(id) || id;
+        const next = status(state);
+        if (next === 'terminal') {
+            this.activeIds.delete(key);
+            this.terminalIds.add(key);
+            while (this.terminalIds.size > MAX_HISTORY) {
+                const oldest = this.terminalIds.values().next().value;
+                this.terminalIds.delete(oldest);
+                this.children.delete(oldest);
+                for (const [alias, target] of this.aliases)
+                    if (target === oldest)
+                        this.aliases.delete(alias);
+            }
+        }
+        else if (next === 'running' && (restart || !this.terminalIds.has(key))) {
+            if (restart)
+                this.terminalIds.delete(key);
+            this.activeIds.add(key);
+        }
+    }
+    bind(callId, ids) {
+        if (!ids.length)
+            return;
+        this.activeIds.delete(`call:${callId}`);
+        for (const id of ids)
+            this.update(id, 'running');
+    }
+    tool(id, name, input, output, failed = false) {
+        if (typeof id !== 'string' || !id)
+            return;
+        const args = object(decode(input));
+        const previous = this.calls.get(id);
+        const toolName = normalized(name).slice(0, 512) || previous?.name || '';
+        const launch = previous?.launch ||
+            background(args) ||
+            /^(?:spawn_agent|spawn_subagent|subagent_spawn|invoke_subagent)$/u.test(toolName);
+        const targets = args
+            ? [
+                ...nativeIds(args),
+                ...(Array.isArray(args.task_ids) ? args.task_ids : []),
+                ...(Array.isArray(args.ids) ? args.ids : []),
+                ...(this.harness === 'poolside' && args.name ? [args.name] : []),
+            ].filter((value) => typeof value === 'string')
+            : previous?.targets || [];
+        const delegation = previous?.delegation || (this.harness === 'hermes' && /\/delegation\/live\//u.test(string(name)));
+        if (delegation)
+            targets.push(...textIds(string(name)));
+        const call = { name: toolName, launch, targets, delegation };
+        this.calls.delete(id);
+        this.calls.set(id, call);
+        if (this.calls.size > MAX_HISTORY) {
+            for (const key of this.calls.keys()) {
+                // Keep pending launch correlation even during a burst of tool traffic.
+                if (key !== id && !this.activeIds.has(`call:${key}`))
+                    this.calls.delete(key);
+                if (this.calls.size <= MAX_HISTORY)
+                    break;
+            }
+        }
+        // Provider-native lifecycle supplies Devin and Prime identities directly.
+        const nativeLaunch = (this.harness === 'devin' && toolName === 'run_subagent') || (this.harness === 'prime' && toolName === 'ipython');
+        if (launch && !nativeLaunch && !previous?.launch)
+            this.update(`call:${id}`, 'running');
+        if (failed && launch)
+            this.update(`call:${id}`, 'failed');
+        if (output === undefined || failed)
+            return;
+        const text = contents(output);
+        const outputLaunch = /^(?:bash|shell|run_shell_command)$/u.test(toolName) &&
+            /^(?:Command moved to background|Command running in background with ID:|Backgrounded as job|started background job)/u.test(text);
+        const hermes = this.harness === 'hermes' && (/^delegate/u.test(toolName) || delegation);
+        if (!(launch ||
+            outputLaunch ||
+            STATUS_TOOLS.test(toolName) ||
+            hermes ||
+            (this.harness === 'muse' && toolName.startsWith('subagent'))))
+            return;
+        const found = new Set();
+        const visit = (value, depth = 0) => {
+            if (depth > 10)
+                return;
+            let parsed = decode(value);
+            if (Array.isArray(parsed)) {
+                for (const child of parsed)
+                    visit(child, depth + 1);
+                return;
+            }
+            if (object(parsed)) {
+                const ids = nativeIds(parsed);
+                // Native list rows use an unqualified id, unlike enclosing tool calls.
+                if (typeof parsed.id === 'string' && (parsed.status || parsed.state))
+                    ids.push(parsed.id);
+                if (this.harness === 'antigravity' && typeof parsed.conversationId === 'string')
+                    ids.push(parsed.conversationId);
+                for (const task of ids) {
+                    found.add(task);
+                    this.update(task, this.harness === 'muse' ? parsed.roster?.[0]?.state || parsed.status : (parsed.status ?? parsed.state));
+                }
+                if (!ids.length && !parsed.jobs && !parsed.agents && STATUS_TOOLS.test(toolName)) {
+                    for (const task of targets)
+                        this.update(task, parsed.status ?? parsed.state);
+                }
+                for (const [key, child] of Object.entries(parsed)) {
+                    if (/prompt$|description$/iu.test(key) ||
+                        ['command', 'label', 'detailedContent', 'stdout', 'stderr'].includes(key))
+                        continue;
+                    // A task row's output is arbitrary program/agent text, not another status record.
+                    if (status(parsed.status ?? parsed.state) && ['output', 'message', 'result'].includes(key))
+                        continue;
+                    visit(child, depth + 1);
+                }
+            }
+            else if (typeof parsed === 'string') {
+                parsed = parsed
+                    .replace(/<output>[\s\S]*?(?:<\/output>|$)/gu, '')
+                    .split(/\n(?:output|stdout|stderr):\s*\n/iu)[0];
+                const xmlId = /<task_id>([^<]+)<\/task_id>/u.exec(parsed)?.[1];
+                const xmlStatus = /<status>([^<]+)<\/status>/u.exec(parsed)?.[1];
+                if (xmlId && xmlStatus) {
+                    found.add(xmlId);
+                    this.update(xmlId, xmlStatus);
+                }
+                for (const match of parsed.matchAll(/<task\s+([^>]+)>/gu)) {
+                    const task = /\bid=["']([^"']+)["']/u.exec(match[1])?.[1];
+                    const state = /\bstate=["']([^"']+)["']/u.exec(match[1])?.[1];
+                    if (task) {
+                        found.add(task);
+                        this.update(task, state);
+                    }
+                }
+                if (this.harness === 'antigravity' && toolName === 'manage_subagents') {
+                    const list = parsed.slice(parsed.indexOf('['));
+                    if (Array.isArray(decode(list)))
+                        visit(decode(list), depth + 1);
+                }
+                const ids = textIds(parsed);
+                for (const task of ids)
+                    found.add(task);
+                // PID and job listings expose one status per line, not a global status.
+                for (const line of parsed.split('\n')) {
+                    const pid = /\[PID\s+(\d+)\]\s+(RUNNING|EXITED)/u.exec(line);
+                    const job = /^([\w.-]+)\s+\[[^\]]+\]\s+(\w+)/u.exec(line);
+                    if (pid)
+                        this.update(pid[1], pid[2]);
+                    if (job)
+                        this.update(job[1], job[2]);
+                }
+                const state = textStatus(parsed);
+                const addressed = ids.length ? ids : targets;
+                if (state)
+                    for (const task of addressed)
+                        this.update(task, state === 'terminal' ? 'completed' : 'running');
+                if (hermes && /\bresult\s+\|\s+terminal ok\b/u.test(parsed)) {
+                    for (const task of [...ids, ...targets])
+                        this.update(task, 'completed');
+                }
+            }
+        };
+        visit(output);
+        if (launch || outputLaunch) {
+            this.bind(id, [...found]);
+            // A failed native launch may complete the tool with an error payload.
+            if (!found.size && object(output)?.isError === true)
+                this.update(`call:${id}`, 'failed');
+        }
+    }
+    observe(event, sessionId = this.sessionId) {
+        if (event?.direction === 'out' || String(event?.source || '').endsWith('.stderr'))
+            return;
+        const frame = object(event?.json) || object(decode(event?.raw));
+        if (!frame)
+            return;
+        if (this.harness === 'codex') {
+            const params = frame.params || {};
+            const thread = params.threadId;
+            if (thread && thread !== sessionId && this.children.has(thread)) {
+                if (frame.method === 'turn/started')
+                    this.update(thread, 'running', true);
+                if (['turn/completed', 'turn/failed', 'turn/aborted'].includes(frame.method))
+                    this.update(thread, 'completed');
+                if (frame.method === 'thread/status/changed')
+                    this.update(thread, params.status?.type);
+            }
+            if (thread && sessionId && thread !== sessionId && !this.children.has(thread))
+                return;
+            const item = params.item;
+            if (!['item/started', 'item/completed'].includes(frame.method) || !object(item))
+                return;
+            if (item.type === 'subAgentActivity' || item.type === 'sub_agent_activity') {
+                const id = item.agentThreadId || item.agent_thread_id || item.agentPath || item.agent_path;
+                if (typeof id === 'string') {
+                    this.children.add(id);
+                    const alias = item.agentPath || item.agent_path;
+                    if (alias)
+                        this.aliases.set(alias, id);
+                    this.update(id, item.kind, frame.method === 'item/started' && item.kind === 'started');
+                }
+            }
+            if (item.type === 'collabAgentToolCall') {
+                for (const id of Array.isArray(item.receiverThreadIds) ? item.receiverThreadIds : []) {
+                    this.children.add(id);
+                    if (['spawnAgent', 'spawn_agent', 'resumeAgent', 'resume_agent', 'sendInput', 'send_input'].includes(item.tool) &&
+                        item.status !== 'failed')
+                        this.update(id, 'running', frame.method === 'item/started');
+                    if (['closeAgent', 'close_agent'].includes(item.tool) &&
+                        frame.method === 'item/completed' &&
+                        item.status === 'completed')
+                        this.update(id, 'completed');
+                }
+                for (const [id, state] of Object.entries(item.agentsStates || item.agentsStatus || {})) {
+                    this.children.add(id);
+                    this.update(id, object(state)?.status ?? state);
+                }
+            }
+            return;
+        }
+        if (frame.type === 'system' && ['claude', 'letta'].includes(this.harness)) {
+            if (frame.subtype === 'task_started' && frame.is_backgrounded !== false)
+                this.update(frame.task_id, 'running', true);
+            if (frame.subtype === 'task_notification')
+                this.update(frame.task_id, 'completed');
+        }
+        const update = frame.params?.update;
+        if (object(update) && ['session/update', '_x.ai/session_notification'].includes(frame.method)) {
+            if (sessionId && frame.params.sessionId && frame.params.sessionId !== sessionId)
+                return;
+            const meta = update._meta || {};
+            const started = meta['cognition.ai/subagent_started'];
+            const ended = meta['cognition.ai/subagent_completed'];
+            if (started?.isBackground)
+                this.update(started.agentId, 'running', true);
+            if (ended)
+                this.update(ended.agentId, 'completed');
+            if (['tool_call', 'tool_call_update'].includes(update.sessionUpdate)) {
+                const known = this.calls.get(update.toolCallId);
+                const toolName = meta.toolName ||
+                    meta.tool_name ||
+                    meta['codebuddy.ai/toolName'] ||
+                    meta['cognition.ai/inferenceToolName'] ||
+                    meta['x.ai/tool']?.name ||
+                    known?.name ||
+                    update.title ||
+                    string(update.toolCallId).split('__call_')[0];
+                const out = update.status !== 'pending' &&
+                    (update.status === 'completed' ||
+                        update.rawOutput !== undefined ||
+                        (this.harness === 'hermes' && known?.delegation))
+                    ? this.harness === 'qwen'
+                        ? // Qwen's rawOutput is often only 'Listed N background agents';
+                            // the native IDs and per-agent statuses live in content.
+                            [update.rawOutput, update.content]
+                        : (update.rawOutput ?? update.content)
+                    : undefined;
+                this.tool(update.toolCallId, toolName, update.rawInput, out, update.status === 'failed');
+            }
+            return;
+        }
+        if (this.harness === 'gemini' && frame.method === 'session/request_permission' && frame.params?.toolCall) {
+            const call = frame.params.toolCall;
+            this.tool(call.toolCallId, string(call.toolCallId).split('__call_')[0], call.rawInput);
+        }
+        if (['claude', 'letta'].includes(this.harness)) {
+            const message = frame.message || frame;
+            for (const block of Array.isArray(message.content) ? message.content : []) {
+                if (block.type === 'tool_use')
+                    this.tool(block.id, block.name, block.input);
+                if (block.type === 'tool_result')
+                    this.tool(block.tool_use_id, '', undefined, block.content, block.is_error === true);
+            }
+            if (frame.message_type === 'tool_call_message')
+                this.tool(frame.tool_call?.tool_call_id, frame.tool_call?.name, frame.tool_call?.arguments);
+            if (frame.message_type === 'tool_return_message')
+                this.tool(frame.tool_call_id, '', undefined, frame.tool_return, frame.status === 'error');
+        }
+        if (['omp', 'prime', 'pi'].includes(this.harness)) {
+            if (frame.type === 'tool_execution_start')
+                this.tool(frame.toolCallId, frame.toolName, frame.args);
+            if (frame.type === 'tool_execution_end')
+                this.tool(frame.toolCallId, frame.toolName, undefined, frame.result, frame.isError);
+            if (frame.type === 'rlm_child_update' && this.harness === 'prime')
+                this.update(frame.child?.id, frame.child?.status);
+        }
+        if (this.harness === 'deepseek' && frame.method === 'session/event') {
+            const event = frame.payload?.event;
+            const data = event?.data || {};
+            if (event?.type === 'tool/call')
+                this.tool(data.callId, data.name, data.arguments);
+            if (event?.type === 'tool/result')
+                for (const part of Array.isArray(data.message?.content) ? data.message.content : []) {
+                    if (part.type === 'tool-result')
+                        this.tool(part.toolCallId, '', undefined, part.content, part.isError);
+                }
+        }
+        if (this.harness === 'antigravity' && frame.event === 'step_update') {
+            const step = frame.step_update;
+            for (const child of Array.isArray(step?.subagent_info?.subagents) ? step.subagent_info.subagents : [])
+                this.update(child.conversation_id, 'running');
+            const tool = step?.tool_info;
+            if (tool)
+                this.tool(String(step.step_index), tool.name, tool.parameters, tool.output);
+        }
+        if (this.harness === 'muse' && frame.payload?.kind === 'task_lifecycle') {
+            const event = frame.payload.event;
+            if (event?.kind === 'proposed')
+                this.tool(event.task_id, string(event.task_kind).replace(/^tool\./u, ''), undefined);
+            if (event?.kind === 'output')
+                this.tool(event.task_id, '', undefined, event.chunk);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turns/dev",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "description": "Upload local AI agent sessions to turns.dev",
   "license": "MIT",
   "type": "module",