reasonix 0.5.13 → 0.5.21

package/dist/index.d.ts

@@ -69,6 +69,14 @@ interface ChatMessage {
     name?: string;
     tool_call_id?: string;
     tool_calls?: ToolCall[];
+    /**
+     * R1 `reasoning_content` captured from the assistant's thinking turn.
+     * DeepSeek's thinking mode 400s with "reasoning_content in the
+     * thinking mode must be passed back" when a tool-loop continuation
+     * omits it from the preceding assistant message. Round-tripped for
+     * deepseek-reasoner turns with tool_calls; absent for deepseek-chat.
+     */
+    reasoning_content?: string | null;
 }
 interface RawUsage {
     prompt_tokens?: number;
@@ -89,6 +97,21 @@ interface ChatRequestOptions {
     responseFormat?: {
         type: "json_object" | "text";
     };
+    /**
+     * Explicitly toggle V4 thinking mode. Serialized as
+     * `extra_body.thinking.type = enabled|disabled`. Omit to let the
+     * server default apply (thinking enabled). Mainly used so the loop
+     * can pin the mode per model: `deepseek-chat` → disabled (legacy
+     * non-thinking compat), everything else → enabled.
+     */
+    thinking?: "enabled" | "disabled";
+    /**
+     * Per-request reasoning-effort cap. Serialized as the top-level
+     * `reasoning_effort` field. DeepSeek accepts `high` (standard) or
+     * `max` (Agent-class, auto-applied to Claude-Code-style flows per
+     * the V4 docs). Reasonix pins `max` because every turn is agent-like.
+     */
+    reasoningEffort?: "high" | "max";
 }
 
 declare class Usage {
@@ -790,6 +813,19 @@ interface LoopEvent {
     toolArgs?: string;
     /** Cumulative arguments-string length for `role === "tool_call_delta"`. */
     toolCallArgsChars?: number;
+    /**
+     * Zero-based index of the tool call this delta belongs to. Surfaces
+     * multi-tool turns: on a response emitting 4 write_file calls the UI
+     * can show "building call 3/?" instead of a context-free spinner.
+     */
+    toolCallIndex?: number;
+    /**
+     * Count of prior tool calls (this turn) whose arguments have finished
+     * streaming into valid JSON. Not all ready calls have been dispatched
+     * yet — dispatch still happens post-stream — but the user gets "2
+     * ready" progress feedback while later calls keep streaming.
+     */
+    toolCallReadyCount?: number;
     stats?: TurnStats;
     planState?: TypedPlanState;
     repair?: RepairReport;
@@ -827,6 +863,11 @@ interface CacheFirstLoopOptions {
      * since the default selector scores samples by plan-state uncertainty.
      */
     branch?: number | BranchOptions;
+    /**
+     * Reasoning-effort cap. See {@link ReconfigurableOptions} — default
+     * `max` for Reasonix (agent-class use per DeepSeek V4 docs).
+     */
+    reasoningEffort?: "high" | "max";
     /**
      * Session name. When set, the loop pre-loads the session's prior messages
      * into its log on construction, and appends every new log entry to
@@ -863,6 +904,14 @@ interface ReconfigurableOptions {
     harvest?: boolean | HarvestOptions;
     branch?: number | BranchOptions;
     stream?: boolean;
+    /**
+     * Reasoning-effort cap sent per turn (V4 thinking mode only;
+     * deepseek-chat ignores it). Reasonix pins `max` by default because
+     * DeepSeek's V4 docs flag Claude-Code-style agent loops as the
+     * canonical `max` use case. `/effort high` lets a user step down
+     * mid-session for cheaper, faster turns on simple tasks.
+     */
+    reasoningEffort?: "high" | "max";
 }
 declare class CacheFirstLoop {
     readonly client: DeepSeekClient;
@@ -879,6 +928,8 @@ declare class CacheFirstLoop {
     harvestOptions: HarvestOptions;
     branchEnabled: boolean;
     branchOptions: BranchOptions;
+    /** See ReconfigurableOptions — mutable so `/effort` can flip mid-session. */
+    reasoningEffort: "high" | "max";
     sessionName: string | null;
     /**
      * Hook list, mutable so `/hooks reload` can swap it without
@@ -922,7 +973,7 @@ declare class CacheFirstLoop {
         tokensSaved: number;
         charsSaved: number;
     };
-    private appendAndPersist;
+    appendAndPersist(message: ChatMessage): void;
     /**
      * Start a fresh conversation WITHOUT exiting. Drops every message
      * in the in-memory log AND rewrites the session file to empty so
@@ -970,6 +1021,15 @@ declare class CacheFirstLoop {
     private forceSummaryAfterIterLimit;
     run(userInput: string, onEvent?: (ev: LoopEvent) => void): Promise<string>;
     private assistantMessage;
+    /**
+     * Build a synthetic assistant message we insert into the log without
+     * a real API round trip (abort notices, future system injections).
+     * Reasoner models reject follow-up requests whose assistant history
+     * is missing `reasoning_content`, so we stamp an empty-string
+     * placeholder on reasoner sessions to satisfy the validator. V3
+     * doesn't care — field stays absent there.
+     */
+    private syntheticAssistantMessage;
 }
 /**
  * R1 occasionally hallucinates tool-call markup as plain text when the
@@ -1550,6 +1610,10 @@ interface SubagentEvent {
     kind: "start" | "progress" | "end";
     /** First ~30 chars of the task prompt — used for the TUI status row. */
     task: string;
+    /** Skill that spawned this subagent, when applicable. Stamped on every event so the TUI/logger can attribute without extra plumbing. */
+    skillName?: string;
+    /** Model id the child loop ran on. Stamped alongside skillName. */
+    model?: string;
     /** Iteration count inside the child loop (number of tool results so far). */
     iter?: number;
     /** Wall-clock ms since the subagent started. */
@@ -1560,6 +1624,10 @@ interface SubagentEvent {
     error?: string;
     /** Total turns the subagent took. Set on `end`. */
     turns?: number;
+    /** Total USD spent inside the child loop. Set on `end`. */
+    costUsd?: number;
+    /** Aggregated child-loop Usage (sum across turns). Set on `end`. */
+    usage?: Usage;
 }
 /**
  * Mutable ref the registration writes through. The TUI sets `.current`
@@ -1582,7 +1650,7 @@ interface SubagentToolOptions {
     defaultSystem?: string;
     /** Project root for `applyProjectMemory` lookup. Omit in chat mode. */
     projectRoot?: string;
-    /** Default model. `deepseek-chat` (V3) by default. */
+    /** Default model. `deepseek-v4-pro` by default. */
     defaultModel?: string;
     /** Iteration ceiling. Lower than the parent (16 by default). */
     maxToolIters?: number;
@@ -3066,6 +3134,22 @@ interface UsageRecord {
     costUsd: number;
     /** What the same turn would have cost at Claude Sonnet 4.6 rates. */
     claudeEquivUsd: number;
+    /**
+     * Distinguishes ordinary parent-loop turns from subagent summary rows.
+     * Absent on pre-0.5.14 records — treat as "turn" when missing.
+     */
+    kind?: "turn" | "subagent";
+    /** Present when `kind === "subagent"`. Attribution metadata for the /stats roll-up. */
+    subagent?: {
+        /** Skill that spawned it, when the spawn came from a `runAs: subagent` skill. */
+        skillName?: string;
+        /** First ~60 chars of the task prompt — enough context to recognize a run, never the full text. */
+        taskPreview: string;
+        /** Tool calls the child loop dispatched before returning. */
+        toolIters: number;
+        /** Wall-clock ms. */
+        durationMs: number;
+    };
 }
 /** Where the log lives. Tests override via `opts.path`. */
 declare function defaultUsageLogPath(homeDirOverride?: string): string;
@@ -3077,6 +3161,9 @@ interface AppendUsageInput {
     now?: number;
     /** Override the log path (tests). */
     path?: string;
+    /** When appending a subagent summary row, set `kind: "subagent"` and populate `subagent`. */
+    kind?: "turn" | "subagent";
+    subagent?: UsageRecord["subagent"];
 }
 /**
  * Append one record and return it. Swallows disk errors — the TUI
@@ -3131,6 +3218,25 @@ interface UsageAggregate {
     firstSeen: number | null;
     /** Latest record's ts, or `null` when the log is empty. */
     lastSeen: number | null;
+    /**
+     * Subagent-specific rollup. Undefined when no subagent records exist
+     * in the log so consumers can cheaply skip the section. Counts reflect
+     * subagent SPAWNS (not internal child-loop turns) — one row per run.
+     */
+    subagents?: SubagentAggregate;
+}
+/** Rolled-up view of all `kind: "subagent"` records. */
+interface SubagentAggregate {
+    total: number;
+    costUsd: number;
+    totalDurationMs: number;
+    /** Per-skill breakdown. Records without `skillName` (raw spawn_subagent calls) group under `"(adhoc)"`. */
+    bySkill: Array<{
+        skillName: string;
+        count: number;
+        costUsd: number;
+        durationMs: number;
+    }>;
 }
 /**
  * Fold a flat record list into the dashboard shape — rolling windows

package/dist/index.js

@@ -131,6 +131,12 @@ var DeepSeekClient = class {
     if (opts.temperature !== void 0) payload.temperature = opts.temperature;
     if (opts.maxTokens !== void 0) payload.max_tokens = opts.maxTokens;
     if (opts.responseFormat) payload.response_format = opts.responseFormat;
+    if (opts.thinking) {
+      payload.extra_body = { thinking: { type: opts.thinking } };
+    }
+    if (opts.reasoningEffort) {
+      payload.reasoning_effort = opts.reasoningEffort;
+    }
     return payload;
   }
   /**
@@ -345,6 +351,13 @@ async function harvest(reasoningContent, client, options = {}, signal) {
       responseFormat: { type: "json_object" },
       temperature: 0,
       maxTokens: 600,
+      // Pin mode + effort so a future default-model swap (e.g. someone
+      // sets `options.model = "deepseek-v4-pro"`) can't accidentally
+      // turn this micro-extraction into a multi-thousand-reasoning-
+      // token call. DeepSeek ignores these on non-thinking models, so
+      // the request stays valid regardless of the chosen model.
+      thinking: "disabled",
+      reasoningEffort: "high",
       signal
     });
     return parsePlanState(resp.content, maxItems, maxItemLen);
@@ -1563,6 +1576,11 @@ function deleteSession(name) {
   const path = sessionPath(name);
   try {
     unlinkSync(path);
+    const sidecar = path.replace(/\.jsonl$/, ".pending.json");
+    try {
+      unlinkSync(sidecar);
+    } catch {
+    }
     return true;
   } catch {
     return false;
@@ -1590,13 +1608,18 @@ function countLines(path) {
 
 // src/telemetry.ts
 var DEEPSEEK_PRICING = {
-  "deepseek-chat": { inputCacheHit: 0.028, inputCacheMiss: 0.28, output: 0.42 },
-  "deepseek-reasoner": { inputCacheHit: 0.028, inputCacheMiss: 0.28, output: 0.42 }
+  "deepseek-v4-flash": { inputCacheHit: 0.028, inputCacheMiss: 0.139, output: 0.278 },
+  "deepseek-v4-pro": { inputCacheHit: 0.139, inputCacheMiss: 1.667, output: 3.333 },
+  // Compat aliases — priced as v4-flash per the deprecation notice.
+  "deepseek-chat": { inputCacheHit: 0.028, inputCacheMiss: 0.139, output: 0.278 },
+  "deepseek-reasoner": { inputCacheHit: 0.028, inputCacheMiss: 0.139, output: 0.278 }
 };
 var CLAUDE_SONNET_PRICING = { input: 3, output: 15 };
 var DEEPSEEK_CONTEXT_TOKENS = {
-  "deepseek-chat": 131072,
-  "deepseek-reasoner": 131072
+  "deepseek-v4-flash": 1e6,
+  "deepseek-v4-pro": 1e6,
+  "deepseek-chat": 1e6,
+  "deepseek-reasoner": 1e6
 };
 var DEFAULT_CONTEXT_TOKENS = 131072;
 function costUsd(model, usage) {
@@ -1694,6 +1717,8 @@ var CacheFirstLoop = class {
   harvestOptions;
   branchEnabled;
   branchOptions;
+  /** See ReconfigurableOptions — mutable so `/effort` can flip mid-session. */
+  reasoningEffort;
   sessionName;
   /**
    * Hook list, mutable so `/hooks reload` can swap it without
@@ -1719,7 +1744,8 @@ var CacheFirstLoop = class {
     this.client = opts.client;
     this.prefix = opts.prefix;
     this.tools = opts.tools ?? new ToolRegistry();
-    this.model = opts.model ?? "deepseek-chat";
+    this.model = opts.model ?? "deepseek-v4-pro";
+    this.reasoningEffort = opts.reasoningEffort ?? "max";
     this.maxToolIters = opts.maxToolIters ?? 64;
     this.hooks = opts.hooks ?? [];
     this.hookCwd = opts.hookCwd ?? process.cwd();
@@ -1835,6 +1861,7 @@ var CacheFirstLoop = class {
   configure(opts) {
     if (opts.model !== void 0) this.model = opts.model;
     if (opts.stream !== void 0) this._streamPreference = opts.stream;
+    if (opts.reasoningEffort !== void 0) this.reasoningEffort = opts.reasoningEffort;
     if (opts.branch !== void 0) {
       if (typeof opts.branch === "number") {
         this.branchOptions = { budget: opts.branch };
@@ -1924,7 +1951,7 @@ var CacheFirstLoop = class {
           content: `aborted at iter ${iter}/${this.maxToolIters} \u2014 stopped without producing a summary (press \u2191 + Enter or /retry to resume)`
         };
         const stoppedMsg = "[aborted by user (Esc) \u2014 no summary produced. Ask again or /retry when ready; prior tool output is still in the log.]";
-        this.appendAndPersist({ role: "assistant", content: stoppedMsg });
+        this.appendAndPersist(this.syntheticAssistantMessage(stoppedMsg));
         yield {
           turn: this._turn,
           role: "assistant_final",
@@ -2013,7 +2040,9 @@ var CacheFirstLoop = class {
               model: this.model,
               messages,
               tools: toolSpecs.length ? toolSpecs : void 0,
-              signal
+              signal,
+              thinking: thinkingModeForModel(this.model),
+              reasoningEffort: this.reasoningEffort
             },
             {
               ...this.branchOptions,
@@ -2060,11 +2089,14 @@ var CacheFirstLoop = class {
           };
         } else if (this.stream) {
           const callBuf = /* @__PURE__ */ new Map();
+          const readyIndices = /* @__PURE__ */ new Set();
           for await (const chunk of this.client.stream({
             model: this.model,
             messages,
             tools: toolSpecs.length ? toolSpecs : void 0,
-            signal
+            signal,
+            thinking: thinkingModeForModel(this.model),
+            reasoningEffort: this.reasoningEffort
           })) {
             if (chunk.contentDelta) {
               assistantContent += chunk.contentDelta;
@@ -2095,13 +2127,18 @@ var CacheFirstLoop = class {
               if (d.argumentsDelta)
                 cur.function.arguments = (cur.function.arguments ?? "") + d.argumentsDelta;
               callBuf.set(d.index, cur);
+              if (!readyIndices.has(d.index) && cur.function.name && looksLikeCompleteJson(cur.function.arguments ?? "")) {
+                readyIndices.add(d.index);
+              }
               if (cur.function.name) {
                 yield {
                   turn: this._turn,
                   role: "tool_call_delta",
                   content: "",
                   toolName: cur.function.name,
-                  toolCallArgsChars: (cur.function.arguments ?? "").length
+                  toolCallArgsChars: (cur.function.arguments ?? "").length,
+                  toolCallIndex: d.index,
+                  toolCallReadyCount: readyIndices.size
                 };
               }
             }
@@ -2113,7 +2150,9 @@ var CacheFirstLoop = class {
             model: this.model,
             messages,
             tools: toolSpecs.length ? toolSpecs : void 0,
-            signal
+            signal,
+            thinking: thinkingModeForModel(this.model),
+            reasoningEffort: this.reasoningEffort
           });
           assistantContent = resp.content;
           reasoningContent = resp.reasoningContent ?? "";
@@ -2152,7 +2191,9 @@ var CacheFirstLoop = class {
         reasoningContent || null,
         assistantContent || null
       );
-      this.appendAndPersist(this.assistantMessage(assistantContent, repairedCalls));
+      this.appendAndPersist(
+        this.assistantMessage(assistantContent, repairedCalls, reasoningContent)
+      );
       yield {
         turn: this._turn,
         role: "assistant_final",
@@ -2304,7 +2345,9 @@ ${reason}`;
         model: this.model,
         messages,
         // no tools → model is forced to answer in text
-        signal: this._turnAbort.signal
+        signal: this._turnAbort.signal,
+        thinking: thinkingModeForModel(this.model),
+        reasoningEffort: this.reasoningEffort
       });
       const rawContent = resp.content?.trim() ?? "";
       const cleaned = stripHallucinatedToolMarkup(rawContent);
@@ -2314,7 +2357,7 @@ ${reason}`;
 
 ${summary}`;
       const summaryStats = this.stats.record(this._turn, this.model, resp.usage ?? new Usage());
-      this.appendAndPersist({ role: "assistant", content: summary });
+      this.appendAndPersist(this.assistantMessage(summary, [], resp.reasoningContent ?? void 0));
       yield {
         turn: this._turn,
         role: "assistant_final",
@@ -2343,12 +2386,41 @@ ${summary}`;
     }
     return final;
   }
-  assistantMessage(content, toolCalls) {
+  assistantMessage(content, toolCalls, reasoningContent) {
     const msg = { role: "assistant", content };
     if (toolCalls.length > 0) msg.tool_calls = toolCalls;
+    if (reasoningContent && reasoningContent.length > 0) {
+      msg.reasoning_content = reasoningContent;
+    }
+    return msg;
+  }
+  /**
+   * Build a synthetic assistant message we insert into the log without
+   * a real API round trip (abort notices, future system injections).
+   * Reasoner models reject follow-up requests whose assistant history
+   * is missing `reasoning_content`, so we stamp an empty-string
+   * placeholder on reasoner sessions to satisfy the validator. V3
+   * doesn't care — field stays absent there.
+   */
+  syntheticAssistantMessage(content) {
+    const msg = { role: "assistant", content };
+    if (isThinkingModeModel(this.model)) {
+      msg.reasoning_content = "";
+    }
     return msg;
   }
 };
+function isThinkingModeModel(model) {
+  if (model.includes("reasoner")) return true;
+  if (model === "deepseek-v4-flash" || model === "deepseek-v4-pro") return true;
+  return false;
+}
+function thinkingModeForModel(model) {
+  if (model === "deepseek-chat") return "disabled";
+  if (model.includes("reasoner")) return "enabled";
+  if (model === "deepseek-v4-flash" || model === "deepseek-v4-pro") return "enabled";
+  return void 0;
+}
 function stripHallucinatedToolMarkup(s) {
   let out = s;
   out = out.replace(/<｜DSML｜function_calls>[\s\S]*?<\/?｜DSML｜function_calls>/g, "");
@@ -2364,6 +2436,15 @@ function safeParseToolArgs(raw) {
     return raw;
   }
 }
+function looksLikeCompleteJson(s) {
+  if (!s || !s.trim()) return false;
+  try {
+    JSON.parse(s);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function* hookWarnings(outcomes, turn) {
   for (const o of outcomes) {
     if (o.decision === "pass") continue;
@@ -3953,7 +4034,7 @@ Formatting rules (the parent renders your reply in a TUI with a real markdown re
 - For flow charts and diagrams: use a markdown bullet list with \`\u2192\` or \`\u2193\` between steps. Don't try to draw boxes-and-arrows in ASCII; it never survives word-wrap.`;
 var DEFAULT_MAX_RESULT_CHARS2 = 8e3;
 var DEFAULT_MAX_ITERS = 16;
-var DEFAULT_SUBAGENT_MODEL = "deepseek-chat";
+var DEFAULT_SUBAGENT_MODEL = "deepseek-v4-pro";
 var SUBAGENT_TOOL_NAME = "spawn_subagent";
 var NEVER_INHERITED_TOOLS = /* @__PURE__ */ new Set([SUBAGENT_TOOL_NAME, "submit_plan"]);
 async function spawnSubagent(opts) {
@@ -3961,11 +4042,14 @@ async function spawnSubagent(opts) {
   const maxToolIters = opts.maxToolIters ?? DEFAULT_MAX_ITERS;
   const maxResultChars = opts.maxResultChars ?? DEFAULT_MAX_RESULT_CHARS2;
   const sink = opts.sink;
+  const skillName = opts.skillName;
   const startedAt = Date.now();
   const taskPreview = opts.task.length > 30 ? `${opts.task.slice(0, 30)}\u2026` : opts.task;
   sink?.current?.({
     kind: "start",
     task: taskPreview,
+    skillName,
+    model,
     iter: 0,
     elapsedMs: 0
   });
@@ -3995,6 +4079,8 @@ async function spawnSubagent(opts) {
         sink?.current?.({
           kind: "progress",
           task: taskPreview,
+          skillName,
+          model,
           iter: toolIter,
           elapsedMs: Date.now() - startedAt
         });
@@ -4017,17 +4103,22 @@ async function spawnSubagent(opts) {
   const elapsedMs = Date.now() - startedAt;
   const turns = childLoop.stats.turns.length;
   const costUsd2 = childLoop.stats.totalCost;
+  const usage = aggregateChildUsage(childLoop);
   const truncated = final.length > maxResultChars ? `${final.slice(0, maxResultChars)}
 
 [\u2026truncated ${final.length - maxResultChars} chars; ask the subagent for a tighter summary if you need more.]` : final;
   sink?.current?.({
     kind: "end",
     task: taskPreview,
+    skillName,
+    model,
     iter: toolIter,
     elapsedMs,
     summary: errorMessage ? void 0 : truncated.slice(0, 120),
     error: errorMessage,
-    turns
+    turns,
+    costUsd: costUsd2,
+    usage
   });
   return {
     success: !errorMessage,
@@ -4036,9 +4127,23 @@ async function spawnSubagent(opts) {
     turns,
     toolIters: toolIter,
     elapsedMs,
-    costUsd: costUsd2
+    costUsd: costUsd2,
+    model,
+    skillName,
+    usage
   };
 }
+function aggregateChildUsage(loop) {
+  const agg = new Usage();
+  for (const t of loop.stats.turns) {
+    agg.promptTokens += t.usage.promptTokens;
+    agg.completionTokens += t.usage.completionTokens;
+    agg.totalTokens += t.usage.totalTokens;
+    agg.promptCacheHitTokens += t.usage.promptCacheHitTokens;
+    agg.promptCacheMissTokens += t.usage.promptCacheMissTokens;
+  }
+  return agg;
+}
 function formatSubagentResult(r) {
   if (!r.success) {
     return JSON.stringify({
@@ -4081,8 +4186,8 @@ function registerSubagentTool(parentRegistry, opts) {
         },
         model: {
           type: "string",
-          enum: ["deepseek-chat", "deepseek-reasoner"],
-          description: "Which DeepSeek model the subagent runs on. 'deepseek-chat' (V3) is the default \u2014 fast and cheap. Use 'deepseek-reasoner' (R1) only when the subtask genuinely needs planning or multi-step reasoning; it is roughly 5-10x more expensive."
+          enum: ["deepseek-v4-flash", "deepseek-v4-pro", "deepseek-chat", "deepseek-reasoner"],
+          description: "Which DeepSeek model the subagent runs on. Default is 'deepseek-v4-pro' \u2014 the strongest model, best for complex subtasks. Override to 'deepseek-v4-flash' (or the legacy 'deepseek-chat' / 'deepseek-reasoner' aliases, which route to flash non-thinking / thinking modes) when the subtask is simple enough that flash's quality suffices \u2014 flash is roughly 12\xD7 cheaper."
         }
       },
       required: ["task"]
@@ -6245,6 +6350,8 @@ function appendUsage(input) {
     costUsd: costUsd(input.model, input.usage),
     claudeEquivUsd: claudeEquivalentCost(input.usage)
   };
+  if (input.kind === "subagent") record.kind = "subagent";
+  if (input.subagent) record.subagent = input.subagent;
   const path = input.path ?? defaultUsageLogPath();
   try {
     mkdirSync6(dirname7(path), { recursive: true });
@@ -6318,6 +6425,10 @@ function aggregateUsage(records, opts = {}) {
   const sessionCounts = /* @__PURE__ */ new Map();
   let firstSeen = null;
   let lastSeen = null;
+  const skillCounts = /* @__PURE__ */ new Map();
+  let subagentTotal = 0;
+  let subagentCost = 0;
+  let subagentDuration = 0;
   for (const r of records) {
     addToBucket(all, r);
     if (r.ts >= today.since) addToBucket(today, r);
@@ -6328,15 +6439,34 @@ function aggregateUsage(records, opts = {}) {
     sessionCounts.set(sessKey, (sessionCounts.get(sessKey) ?? 0) + 1);
     if (firstSeen === null || r.ts < firstSeen) firstSeen = r.ts;
     if (lastSeen === null || r.ts > lastSeen) lastSeen = r.ts;
+    if (r.kind === "subagent") {
+      subagentTotal += 1;
+      subagentCost += r.costUsd;
+      const dur = r.subagent?.durationMs ?? 0;
+      subagentDuration += dur;
+      const key = r.subagent?.skillName?.trim() || "(adhoc)";
+      const prev = skillCounts.get(key) ?? { count: 0, costUsd: 0, durationMs: 0 };
+      prev.count += 1;
+      prev.costUsd += r.costUsd;
+      prev.durationMs += dur;
+      skillCounts.set(key, prev);
+    }
   }
   const byModel = Array.from(modelCounts.entries()).map(([model, turns]) => ({ model, turns })).sort((a, b) => b.turns - a.turns);
   const bySession = Array.from(sessionCounts.entries()).map(([session, turns]) => ({ session, turns })).sort((a, b) => b.turns - a.turns);
+  const subagents = subagentTotal > 0 ? {
+    total: subagentTotal,
+    costUsd: subagentCost,
+    totalDurationMs: subagentDuration,
+    bySkill: Array.from(skillCounts.entries()).map(([skillName, v]) => ({ skillName, ...v })).sort((a, b) => b.count - a.count)
+  } : void 0;
   return {
     buckets: [today, week, month, all],
     byModel,
     bySession,
     firstSeen,
-    lastSeen
+    lastSeen,
+    subagents
   };
 }
 function formatLogSize(path = defaultUsageLogPath()) {