@addai/node 0.25.0 → 0.27.0

package/dist/kimi-spawn.d.ts

@@ -11,7 +11,9 @@ export interface KimiInput {
     model?: string;
     /** Resume an existing session (mapped to `--session <id>`). */
     resumeSessionId?: string;
-    /** Skip approval prompts. Maps to --yolo. */
+    /** Accepted for interface parity with the other adapters and deliberately
+     *  ignored: prompt mode always runs in "auto" permission mode, and passing
+     *  --yolo alongside --prompt is a hard error in the CLI. */
     bypassPermissions?: boolean;
     /** When set, kimi runs against a sandboxed mcp config that contains
      *  ONLY these MCP servers (host's ~/.kimi/mcp.json suppressed). */
@@ -20,12 +22,12 @@ export interface KimiInput {
      *  --system-prompt flag, so we prepend it to the user prompt with a
      *  separator the model can recognise. */
     appendSystemPrompt?: string;
-    /** Per-run reasoning effort. The kimi CLI has no verified reasoning-effort
-     *  flag (unlike claude `--effort` / codex `reasoning.effort`), so by
-     *  default this is NOT forwarded — emitting an unsupported flag would make
-     *  every effort-tagged kimi run fail to spawn. The level IS exported as an
-     *  env var (KIMI_REASONING_EFFORT) so a kimi wrapper/config that opts in
-     *  can read it without us guessing at a CLI flag that might not exist. */
+    /** Per-run reasoning effort. kimi has no effort FLAG, but it does read
+     *  KIMI_MODEL_THINKING_EFFORT from the environment, which bypasses the
+     *  model's declared support_efforts list. (The old code set
+     *  KIMI_REASONING_EFFORT, a name that appears nowhere in the CLI, so effort
+     *  was simply ignored.) 'max' is migrated to 'high' by kimi itself; we send
+     *  'high' rather than rely on that. */
     effortLevel?: RuntimeEffortLevel;
 }
 export interface KimiHandle {
@@ -39,16 +41,58 @@ export interface KimiHandle {
     onActivity(cb: () => void): void;
     done: Promise<number>;
 }
-/** Write a sandbox $HOME with an empty .kimi dir so kimi's default
- *  `~/.kimi/mcp.json` resolves to nothing. Caller is responsible for
- *  cleanup (we drop it under os.tmpdir() so the OS reaps it). */
-export declare function writeKimiSandboxHome(servers: KimiMcpServer[]): {
-    homeDir: string;
-    mcpConfigPath: string;
-};
-/** Parse one stream-json line into 0+ RuntimeEvents. Kimi's shapes are
- *  similar in spirit to claude's: assistant text deltas, tool calls,
- *  turn completion, and session metadata. Anything we don't recognise
- *  is forwarded as `kimi:<type>` opaque events. */
+/**
+ * Write the entity's MCP servers where kimi will actually read them:
+ * `<workDir>/.kimi-code/mcp.json`, the last and highest-precedence of the
+ * three files it merges (user `~/.kimi-code/mcp.json`, project-root
+ * `.mcp.json`, then this one).
+ *
+ * The two alternatives are both worse. `--mcp-config-file` — what this used
+ * to pass — is not a flag kimi has, so it took the whole run down at argument
+ * parsing. Pointing KIMI_CODE_HOME at a throwaway dir WOULD isolate the user
+ * file, but that dir also holds kimi's credentials, config.toml and session
+ * index: it would log the daemon out on every run. Same trap as the HOME
+ * override this file already backed away from.
+ *
+ * The cost is that a server configured on the host machine still merges in.
+ * Ours always win on key collision, and the file is rewritten on every spawn
+ * so a detached MCP disappears on the next run rather than lingering.
+ */
+export declare function writeKimiProjectMcpConfig(workingDirectory: string, servers: KimiMcpServer[]): string;
+/**
+ * Parse one stream-json line into 0+ RuntimeEvents.
+ *
+ * kimi's prompt-mode stream is OpenAI-CHAT shaped, not claude shaped: every
+ * content line is keyed by `role`, and only the three metadata lines carry a
+ * `type` at all (`system.version`, `session.resume_hint`,
+ * `turn.step.retrying`). The role branches therefore come first. Without them
+ * every real line fell through to the opaque passthrough at the bottom, which
+ * meant a kimi run that worked perfectly would still have delivered an empty
+ * reply — a second, independent bug hiding behind the argument-parsing one.
+ *
+ * Shapes, from PromptJsonWriter in the shipped bundle:
+ *   {role:"assistant", content?:string, tool_calls?:[{id,function:{name,arguments}}]}
+ *   {role:"tool", tool_call_id:string, content:string}
+ *   {role:"meta", type:"...", ...}
+ *
+ * Note there is no terminal line and no usage line: the runner keys
+ * completion off process exit, and kimi runs report no token counts.
+ *
+ * The `type`-keyed branches below are kept for older builds, and anything
+ * unrecognised is still forwarded as `kimi:<type>` rather than dropped.
+ */
 export declare function lineToEvents(line: Record<string, unknown>): RuntimeEvent[];
+/**
+ * The kimi command line for one prompt-mode run.
+ *
+ * Extracted so the flag set is testable without spawning anything — this is
+ * the surface where four invented flags shipped undetected, each one killing
+ * the run before a single token was generated. Every flag below is present in
+ * the CLI's own option table.
+ *
+ * Not here on purpose: --work-dir (kimi reads process.cwd(), which the spawn
+ * sets), --mcp-config-file (config comes from <cwd>/.kimi-code/mcp.json), and
+ * --yolo (prompt mode forces "auto" permissions and rejects the flag).
+ */
+export declare function buildKimiArgs(input: KimiInput): string[];
 export declare function spawnKimi(input: KimiInput): KimiHandle;

package/dist/kimi-spawn.js

@@ -1,11 +1,29 @@
 "use strict";
-// kimi --print --output-format stream-json adapter.
+// kimi --prompt --output-format stream-json adapter.
 //
-// Mirrors claude-print.ts: spawns `kimi` non-interactively with a
-// JSONL output stream, parses each line into our normalised RuntimeEvent
-// shape, and resolves on exit. Kimi's stream-json shape is documented
-// upstream but we passthrough unknown event types as `kimi:<type>` for
-// safe forward-compat.
+// Mirrors claude-print.ts: spawns `kimi` non-interactively with a JSONL
+// output stream, parses each line into our normalised RuntimeEvent shape,
+// and resolves on exit.
+//
+// Everything here is read out of the shipped bundle (@moonshot-ai/kimi-code
+// 0.36.0, dist/main.mjs), not the docs, because the previous version of this
+// file was written from the docs and got FOUR things wrong at once — every
+// one of them fatal:
+//
+//   --print              does not exist. `-p, --prompt <prompt>` IS prompt
+//                        mode and takes the prompt as its value. Every kimi
+//                        run died at argument parsing, silently laddering to
+//                        claude.
+//   --work-dir <dir>     does not exist. kimi takes its work dir from
+//                        process.cwd(), which spawn() already sets.
+//   --mcp-config-file    does not exist. kimi merges three files; the
+//                        highest-precedence one is <cwd>/.kimi-code/mcp.json.
+//   --yolo               is REJECTED alongside --prompt ("Cannot combine
+//                        --prompt with --yolo"). It is also unnecessary:
+//                        prompt mode calls forceAuto() and runs the whole
+//                        turn in "auto" permission mode by itself.
+//
+// The output format was wrong too — see lineToEvents.
 //
 // Reference: https://moonshotai.github.io/kimi-cli/en/reference/kimi-command.html
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -42,24 +60,46 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeKimiSandboxHome = writeKimiSandboxHome;
+exports.writeKimiProjectMcpConfig = writeKimiProjectMcpConfig;
 exports.lineToEvents = lineToEvents;
+exports.buildKimiArgs = buildKimiArgs;
 exports.spawnKimi = spawnKimi;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
-const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const kimi_binary_1 = require("./kimi-binary");
 const win_1 = require("./win");
 const events_1 = require("./events");
 const think_split_1 = require("./think-split");
 const mcp_headers_1 = require("./mcp-headers");
-/** Write a sandbox $HOME with an empty .kimi dir so kimi's default
- *  `~/.kimi/mcp.json` resolves to nothing. Caller is responsible for
- *  cleanup (we drop it under os.tmpdir() so the OS reaps it). */
-function writeKimiSandboxHome(servers) {
-    const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'entities-kimi-'));
-    fs.mkdirSync(path.join(homeDir, '.kimi'), { mode: 0o700 });
+/** kimi forwards this string to the provider verbatim — the override exists
+ *  precisely to bypass the model's declared support_efforts — so a level kimi
+ *  has never heard of reaches the API as-is. It retired 'max' (it migrates a
+ *  stored 'max' to 'high' on load) and never had our 'xhigh', so both collapse
+ *  to the highest level it does know. */
+function kimiEffort(level) {
+    return level === 'max' || level === 'xhigh' ? 'high' : level;
+}
+/**
+ * Write the entity's MCP servers where kimi will actually read them:
+ * `<workDir>/.kimi-code/mcp.json`, the last and highest-precedence of the
+ * three files it merges (user `~/.kimi-code/mcp.json`, project-root
+ * `.mcp.json`, then this one).
+ *
+ * The two alternatives are both worse. `--mcp-config-file` — what this used
+ * to pass — is not a flag kimi has, so it took the whole run down at argument
+ * parsing. Pointing KIMI_CODE_HOME at a throwaway dir WOULD isolate the user
+ * file, but that dir also holds kimi's credentials, config.toml and session
+ * index: it would log the daemon out on every run. Same trap as the HOME
+ * override this file already backed away from.
+ *
+ * The cost is that a server configured on the host machine still merges in.
+ * Ours always win on key collision, and the file is rewritten on every spawn
+ * so a detached MCP disappears on the next run rather than lingering.
+ */
+function writeKimiProjectMcpConfig(workingDirectory, servers) {
+    const configDir = path.join(workingDirectory, '.kimi-code');
+    fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
     const mcpConfig = { mcpServers: {} };
     for (const s of servers) {
         if (!s.slug || !s.command)
@@ -90,15 +130,76 @@ function writeKimiSandboxHome(servers) {
             ...(s.env && Object.keys(s.env).length > 0 ? { env: s.env } : {}),
         };
     }
-    const mcpConfigPath = path.join(homeDir, '.kimi', 'mcp.json');
+    // 0600: stdio servers carry their credentials in `env` and remote ones in
+    // `headers`, and this file lives inside the entity's working directory.
+    const mcpConfigPath = path.join(configDir, 'mcp.json');
     fs.writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), { mode: 0o600 });
-    return { homeDir, mcpConfigPath };
+    return mcpConfigPath;
 }
-/** Parse one stream-json line into 0+ RuntimeEvents. Kimi's shapes are
- *  similar in spirit to claude's: assistant text deltas, tool calls,
- *  turn completion, and session metadata. Anything we don't recognise
- *  is forwarded as `kimi:<type>` opaque events. */
+/**
+ * Parse one stream-json line into 0+ RuntimeEvents.
+ *
+ * kimi's prompt-mode stream is OpenAI-CHAT shaped, not claude shaped: every
+ * content line is keyed by `role`, and only the three metadata lines carry a
+ * `type` at all (`system.version`, `session.resume_hint`,
+ * `turn.step.retrying`). The role branches therefore come first. Without them
+ * every real line fell through to the opaque passthrough at the bottom, which
+ * meant a kimi run that worked perfectly would still have delivered an empty
+ * reply — a second, independent bug hiding behind the argument-parsing one.
+ *
+ * Shapes, from PromptJsonWriter in the shipped bundle:
+ *   {role:"assistant", content?:string, tool_calls?:[{id,function:{name,arguments}}]}
+ *   {role:"tool", tool_call_id:string, content:string}
+ *   {role:"meta", type:"...", ...}
+ *
+ * Note there is no terminal line and no usage line: the runner keys
+ * completion off process exit, and kimi runs report no token counts.
+ *
+ * The `type`-keyed branches below are kept for older builds, and anything
+ * unrecognised is still forwarded as `kimi:<type>` rather than dropped.
+ */
 function lineToEvents(line) {
+    const role = typeof line.role === 'string' ? line.role : '';
+    if (role === 'assistant') {
+        const out = [];
+        if (typeof line.content === 'string' && line.content) {
+            out.push({ type: 'assistant_text', delta: line.content });
+        }
+        const calls = Array.isArray(line.tool_calls) ? line.tool_calls : [];
+        for (const c of calls) {
+            // Arguments arrive as a JSON string (streamed in parts, joined by the
+            // writer). Keep the raw string if it doesn't parse — a malformed
+            // argument list is worth showing, not worth losing the tool call over.
+            const rawArgs = c?.function?.arguments;
+            let input = rawArgs;
+            if (typeof rawArgs === 'string' && rawArgs.length > 0) {
+                try {
+                    input = JSON.parse(rawArgs);
+                }
+                catch {
+                    input = rawArgs;
+                }
+            }
+            out.push({
+                type: 'tool_use',
+                id: String(c?.id ?? ''),
+                name: String(c?.function?.name ?? ''),
+                input,
+            });
+        }
+        // An assistant line with neither content nor calls shouldn't happen (the
+        // writer skips empty flushes) — pass it through rather than swallow it.
+        return out.length > 0 ? out : [{ type: 'kimi:assistant', raw: line }];
+    }
+    if (role === 'tool') {
+        // kimi has no error channel on tool results; failures come back as text.
+        return [{
+                type: 'tool_result',
+                id: String(line.tool_call_id ?? ''),
+                content: line.content,
+                isError: false,
+            }];
+    }
     const type = typeof line.type === 'string' ? line.type : '';
     // Assistant text — kimi emits 'assistant_message' or 'assistant.delta'
     // depending on version.
@@ -179,6 +280,36 @@ function lineToEvents(line) {
     // Anything else — opaque passthrough
     return [{ type: `kimi:${type || 'unknown'}`, raw: line }];
 }
+/**
+ * The kimi command line for one prompt-mode run.
+ *
+ * Extracted so the flag set is testable without spawning anything — this is
+ * the surface where four invented flags shipped undetected, each one killing
+ * the run before a single token was generated. Every flag below is present in
+ * the CLI's own option table.
+ *
+ * Not here on purpose: --work-dir (kimi reads process.cwd(), which the spawn
+ * sets), --mcp-config-file (config comes from <cwd>/.kimi-code/mcp.json), and
+ * --yolo (prompt mode forces "auto" permissions and rejects the flag).
+ */
+function buildKimiArgs(input) {
+    // --output-format is only accepted in prompt mode, which --prompt turns on.
+    const args = ['--output-format', 'stream-json'];
+    // kimi refuses a bare --session in prompt mode, so only pass it with an id.
+    if (input.resumeSessionId)
+        args.push('--session', input.resumeSessionId);
+    if (input.model)
+        args.push('--model', input.model);
+    // kimi has no --append-system-prompt; prepend with a separator the model can
+    // recognise as a system-like instruction block.
+    let promptText = input.prompt;
+    if (input.appendSystemPrompt && input.appendSystemPrompt.trim().length > 0) {
+        promptText = `[system]\n${input.appendSystemPrompt.trim()}\n[/system]\n\n${input.prompt}`;
+    }
+    // Last, and always: --prompt takes the prompt as its VALUE.
+    args.push('--prompt', promptText);
+    return args;
+}
 function spawnKimi(input) {
     const bin = (0, kimi_binary_1.findKimiBinary)();
     if (!bin) {
@@ -201,49 +332,20 @@ function spawnKimi(input) {
             done: Promise.resolve(127),
         };
     }
-    // Sandbox the kimi config dir. HOME override means kimi's default
-    // We pass --mcp-config-file explicitly, so kimi reads OUR servers,
-    // not the host's ~/.kimi/mcp.json. The mcp config path can live in a
-    // throwaway temp dir; we no longer need to override HOME.
-    //
-    // The OLD approach (HOME=<tempdir>) was destructive: kimi shells out
-    // to git, pip, etc., and those tools read ~/.gitconfig, ~/.npmrc,
-    // ~/.netrc from HOME. Pointing HOME at an empty dir blew away every
-    // user-level tool config, causing silent tool-call failures
-    // (git push without creds, pip install without index URL).
-    const { homeDir: kimiSandboxDir, mcpConfigPath } = writeKimiSandboxHome(input.mcpServers ?? []);
-    const args = [
-        '--print',
-        '--output-format', 'stream-json',
-        '--work-dir', input.workingDirectory,
-        '--mcp-config-file', mcpConfigPath,
-    ];
-    if (input.resumeSessionId) {
-        args.push('--session', input.resumeSessionId);
-    }
-    if (input.model) {
-        args.push('--model', input.model);
-    }
-    if (input.bypassPermissions) {
-        args.push('--yolo');
-    }
-    // Kimi doesn't have --append-system-prompt; prepend with a separator
-    // the model can recognise as a system-like instruction block.
-    let promptText = input.prompt;
-    if (input.appendSystemPrompt && input.appendSystemPrompt.trim().length > 0) {
-        promptText = `[system]\n${input.appendSystemPrompt.trim()}\n[/system]\n\n${input.prompt}`;
-    }
-    args.push('--prompt', promptText);
+    // MCP servers reach kimi through a file in the working directory, not a
+    // flag. Written before spawn and rewritten every run — see above.
+    writeKimiProjectMcpConfig(input.workingDirectory, input.mcpServers ?? []);
+    const args = buildKimiArgs(input);
     // No HOME override: the real $HOME flows through so kimi's own auth +
     // shelled-out tools (git/pip/node) can find their config files. The
     // explicit --mcp-config-file already prevents host mcp.json leakage.
     const childEnv = {
         ...process.env,
         TERM: 'dumb',
-        // Surface the requested reasoning effort without betting on a CLI flag
-        // that may not exist. A kimi config / wrapper can pick this up; if kimi
-        // ignores it, behaviour is unchanged (no spawn failure).
-        ...(input.effortLevel ? { KIMI_REASONING_EFFORT: input.effortLevel } : {}),
+        // kimi's own effort override. It bypasses the model's support_efforts
+        // list, and kimi migrates a stored 'max' to 'high' — so normalise here
+        // rather than send a level the provider may reject.
+        ...(input.effortLevel ? { KIMI_MODEL_THINKING_EFFORT: kimiEffort(input.effortLevel) } : {}),
     };
     const listeners = [];
     const emit = (e) => { for (const l of listeners)
@@ -273,10 +375,6 @@ function spawnKimi(input) {
     }
     catch (err) {
         const msg = err.message || String(err);
-        try {
-            fs.rmSync(kimiSandboxDir, { recursive: true, force: true });
-        }
-        catch { }
         const events = (0, events_1.bufferedEvents)([
             { type: 'error', code: 'kimi_spawn_failed', message: msg },
             { type: 'turn_complete', stopReason: 'failed' },
@@ -328,11 +426,6 @@ function spawnKimi(input) {
             // Release anything the splitter is still holding — a run that ends
             // mid-tag must not lose the tail of its answer.
             emitSplit.flush();
-            // Best-effort cleanup of sandbox tmp dir
-            try {
-                fs.rmSync(kimiSandboxDir, { recursive: true, force: true });
-            }
-            catch { }
             resolve(code ?? -1);
         });
     });

package/dist/session-runner.js

@@ -59,6 +59,7 @@ const events_1 = require("./events");
 const paths_1 = require("./paths");
 const projects_1 = require("./projects");
 const claude_print_1 = require("./claude-print");
+const subagent_usage_1 = require("./subagent-usage");
 const attachments_1 = require("./attachments");
 const codex_spawn_1 = require("./codex-spawn");
 const diskguard_1 = require("./diskguard");
@@ -808,6 +809,26 @@ function isOwnSessionDir(dir) {
     const resolved = path.resolve(dir);
     return resolved.startsWith(root + path.sep);
 }
+/**
+ * Report what this run's subagents cost, before the run goes terminal.
+ *
+ * Awaited rather than fired-and-forgotten: the server recomputes a run's
+ * rollup from its events the moment the status flips, so an event that lands
+ * a beat later would be counted only if something else came along to trigger
+ * a recompute. Failure here must never change the run's outcome — a missing
+ * figure is a worse report, not a worse run.
+ */
+async function emitSubagentUsage(requestId, cwd, startedAtMs) {
+    try {
+        const sub = await (0, subagent_usage_1.readSubagentUsage)(cwd, startedAtMs);
+        if (!sub)
+            return;
+        await emit(requestId, 'subagent_usage', { agents: sub.agents, usage: sub.usage });
+    }
+    catch (err) {
+        console.error(`[session-runner] subagent usage [reqId=${requestId}] failed: ${err.message}`);
+    }
+}
 function eventPayload(e) {
     const { type: _type, ...rest } = e;
     return rest;
@@ -1110,6 +1131,9 @@ async function runClaudeTui(req, cwd, installed) {
             await new Promise(r => setTimeout(r, 250));
         }
     }
+    // Floor for "which subagent transcripts belong to this attempt" — see
+    // subagent-usage.ts.
+    const startedAtMs = Date.now();
     let spawn;
     try {
         spawn = (0, claude_spawn_1.spawnClaudeForRuntime)({
@@ -1509,7 +1533,8 @@ async function runClaudeTui(req, cwd, installed) {
             // is still non-terminal, reopening the server-side reclaim double-spawn
             // window. Resolve only after the chain settles, like the print runners
             // which `await finalizeTerminal`.
-            const done = (0, supabase_client_1.rpc)('runtime_get_request_status', { p_token: token(), p_request_id: req.id })
+            const done = emitSubagentUsage(req.id, cwd, startedAtMs)
+                .then(() => (0, supabase_client_1.rpc)('runtime_get_request_status', { p_token: token(), p_request_id: req.id }))
                 .then(currentStatus => {
                 if (currentStatus === 'canceled')
                     return;
@@ -1547,6 +1572,10 @@ async function runClaudePrint(req, cwd, installed) {
         return;
     }
     const permissionMode = req.agent === 'claude-bypass' ? 'bypassPermissions' : (req.permission_mode ?? undefined);
+    // Floor for "which subagent transcripts belong to this attempt" — see
+    // subagent-usage.ts. Taken before the spawn so nothing this run writes
+    // can fall outside the window.
+    const startedAtMs = Date.now();
     let handle;
     try {
         handle = (0, claude_print_1.spawnClaudePrint)({
@@ -1621,6 +1650,8 @@ async function runClaudePrint(req, cwd, installed) {
     hang.stop();
     if (handle.sessionId)
         await setStatus(req.id, { spawnedSessionId: handle.sessionId });
+    // The agent has exited, so every subagent transcript it wrote is complete.
+    await emitSubagentUsage(req.id, cwd, startedAtMs);
     void emit(req.id, 'session_end', { reason: 'claude_exit', exitCode });
     const currentStatus = await (0, supabase_client_1.rpc)('runtime_get_request_status', { p_token: token(), p_request_id: req.id }).catch(() => null);
     if (currentStatus !== 'canceled') {

package/dist/subagent-usage.d.ts

@@ -0,0 +1,19 @@
+export interface SubagentUsage {
+    /** How many subagent transcripts contributed. */
+    agents: number;
+    /** Anthropic-shaped so the server normalizes it with every other usage
+     *  block instead of needing a special case. */
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+        cache_read_input_tokens: number;
+        cache_creation_input_tokens: number;
+    };
+}
+/**
+ * Everything this run's subagents burned, or null if it spawned none.
+ *
+ * Null rather than zeros on purpose: "no subagents" and "subagents that cost
+ * nothing" are different claims, and only the first one is ever true.
+ */
+export declare function readSubagentUsage(cwd: string | null | undefined, sinceMs: number): Promise<SubagentUsage | null>;

package/dist/subagent-usage.js

@@ -0,0 +1,173 @@
+"use strict";
+// What the subagents cost.
+//
+// Claude Code streams the MAIN agent loop to stdout and reports that turn's
+// usage on its `result` line — which is what the daemon forwards and what
+// Entity Studio has always displayed. A Task/Agent subagent is invisible to
+// that stream: it runs inside the parent process, and its transcript is
+// written to a SEPARATE `agent-*.jsonl` beside the session file. Its tokens
+// are never mentioned on stdout, and the tool_result the parent receives
+// carries the subagent's text and nothing else.
+//
+// Measured on a real run before this existed: main loop 3,658,620 tokens,
+// twenty subagents 5,479,638 more. The run was reported at 40% of what it
+// actually cost. This reads the other 60% off the disk the agent just wrote.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSubagentUsage = readSubagentUsage;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const paths_1 = require("./paths");
+const claude_binary_1 = require("./claude-binary");
+const isAgentTranscript = (name) => /^agent-.+\.jsonl$/i.test(name);
+/**
+ * Which subagent transcripts belong to this run.
+ *
+ * +Ai gives most runs their own scratch directory (~/.ainode/sessions/<id>),
+ * and Claude Code names the transcript folder after the working directory —
+ * so for those the whole folder is this run's and nothing else's. A run pinned
+ * to a project checkout shares its folder with every other run against that
+ * project, so there we fall back to "written since this attempt started",
+ * which is exact unless two runs are working the same checkout concurrently.
+ */
+function transcriptsFor(cwd, sinceMs) {
+    const dir = path.join(paths_1.CLAUDE_PROJECTS_DIR, (0, claude_binary_1.encodeProjectPath)(cwd));
+    let names;
+    try {
+        names = fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const exclusive = path.resolve(cwd).startsWith(path.resolve(paths_1.RUNTIME_SESSIONS_DIR) + path.sep);
+    const out = [];
+    for (const name of names) {
+        if (!isAgentTranscript(name))
+            continue;
+        const file = path.join(dir, name);
+        if (exclusive) {
+            out.push(file);
+            continue;
+        }
+        try {
+            if (fs.statSync(file).mtimeMs >= sinceMs)
+                out.push(file);
+        }
+        catch { /* vanished */ }
+    }
+    return out;
+}
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0);
+/**
+ * Sum one transcript's usage.
+ *
+ * Claude Code writes the same message id more than once — the text first, the
+ * tool_use block after — and both copies repeat the identical usage. Summing
+ * blind therefore roughly doubles the answer, so this dedupes by message id.
+ */
+async function sumTranscript(file, into) {
+    let sawAny = false;
+    const seen = new Set();
+    let stream;
+    try {
+        stream = fs.createReadStream(file);
+    }
+    catch {
+        return false;
+    }
+    try {
+        for await (const line of readline.createInterface({ input: stream, crlfDelay: Infinity })) {
+            if (!line.trim())
+                continue;
+            let o;
+            try {
+                o = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (o.type !== 'assistant')
+                continue;
+            const message = o.message;
+            const u = message?.usage;
+            if (!u)
+                continue;
+            const id = typeof message?.id === 'string' ? message.id : '';
+            if (id) {
+                if (seen.has(id))
+                    continue;
+                seen.add(id);
+            }
+            sawAny = true;
+            into.usage.input_tokens += num(u.input_tokens);
+            into.usage.output_tokens += num(u.output_tokens);
+            into.usage.cache_read_input_tokens += num(u.cache_read_input_tokens);
+            into.usage.cache_creation_input_tokens += num(u.cache_creation_input_tokens);
+        }
+    }
+    catch {
+        // A half-written or unreadable transcript costs us that subagent's
+        // tokens, not the run's terminal status.
+    }
+    return sawAny;
+}
+/**
+ * Everything this run's subagents burned, or null if it spawned none.
+ *
+ * Null rather than zeros on purpose: "no subagents" and "subagents that cost
+ * nothing" are different claims, and only the first one is ever true.
+ */
+async function readSubagentUsage(cwd, sinceMs) {
+    if (!cwd)
+        return null;
+    const files = transcriptsFor(cwd, sinceMs);
+    if (!files.length)
+        return null;
+    const total = {
+        agents: 0,
+        usage: {
+            input_tokens: 0, output_tokens: 0,
+            cache_read_input_tokens: 0, cache_creation_input_tokens: 0,
+        },
+    };
+    for (const file of files) {
+        if (await sumTranscript(file, total))
+            total.agents++;
+    }
+    if (!total.agents)
+        return null;
+    return total;
+}

package/dist/types.d.ts

@@ -25,6 +25,14 @@ export type RuntimeEvent = {
     type: 'turn_complete';
     usage?: Record<string, unknown>;
     stopReason?: string;
+}
+/** What this run's subagents cost, read off their own transcripts once the
+ *  agent has exited. Never reaches stdout, so it is never in turn_complete
+ *  — see subagent-usage.ts. Emitted at most once per attempt. */
+ | {
+    type: 'subagent_usage';
+    agents: number;
+    usage: Record<string, unknown>;
 } | {
     type: 'error';
     code: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@addai/node",
-  "version": "0.25.0",
+  "version": "0.27.0",
   "description": "Daemon that pairs a machine with your +Ai account and runs Claude / Codex / Kimi / Gemini agents on its behalf. Reachable via Supabase from Vault, Entity Studio, or any other +Ai surface.",
   "license": "MIT",
   "keywords": [