modelstat 0.0.46 → 0.0.47

package/dist/cli.mjs

@@ -78,7 +78,7 @@ var init_git = __esm({
 });
 
 // ../../packages/core/src/enums.ts
-var TOOLS, PROVIDERS, IDENTITY_OWNER_SCOPES, INSTALL_METHODS, OS_FAMILIES, EVENT_KINDS, COMPANION_PHASES, CLASSIFICATION_CONFIDENCE;
+var TOOLS, PROVIDERS, IDENTITY_OWNER_SCOPES, INSTALL_METHODS, OS_FAMILIES, EVENT_KINDS, TOOL_CALL_STATUSES, COMPANION_PHASES, CLASSIFICATION_CONFIDENCE;
 var init_enums = __esm({
   "../../packages/core/src/enums.ts"() {
     "use strict";
@@ -162,6 +162,13 @@ var init_enums = __esm({
       "tool_result",
       "summary"
     ];
+    TOOL_CALL_STATUSES = [
+      "success",
+      "error",
+      "denied",
+      "timeout",
+      "unknown"
+    ];
     COMPANION_PHASES = [
       "starting",
       "discovering",
@@ -4304,7 +4311,7 @@ var init_zod = __esm({
 });
 
 // ../../packages/core/src/schemas.ts
-var TokenUsage, GitContext, RawEvent, RedactionReport, TaxonomyHintRooted, Segment, IngestBatch, HeartbeatPayload, DeviceEnrollment, DeviceSelfRegister, DeviceClaimRequest, ProcessingMetadata, RedactionPolicy, DetectedInstallation, DetectedIdentity, DiscoveryReport, ClassificationConfidenceEnum;
+var TokenUsage, GitContext, RawEvent, RedactionReport, TaxonomyHintRooted, Segment, ToolCallWire, IngestBatch, HeartbeatPayload, DeviceEnrollment, DeviceSelfRegister, DeviceClaimRequest, ProcessingMetadata, RedactionPolicy, DetectedInstallation, DetectedIdentity, DiscoveryReport, ClassificationConfidenceEnum;
 var init_schemas = __esm({
   "../../packages/core/src/schemas.ts"() {
     "use strict";
@@ -4409,6 +4416,49 @@ var init_schemas = __esm({
        * Reserved for server-side similarity / clustering. */
       abstract_embedding: external_exports.array(external_exports.number()).length(384).optional()
     });
+    ToolCallWire = external_exports.object({
+      /** tool_use block `id` / codex `call_id`; parsers fall back to a
+       * deterministic `tc_<djb2-base36>` of `${source_event_id}|${call_index}`
+       * when the source line carries no id. */
+      external_call_id: external_exports.string().max(120),
+      /** Tool-local session id — same id space as RawEvent.session_id. */
+      session_id: external_exports.string().max(120),
+      /** The RawEvent that contained the tool_use (dedupe/replay anchor). */
+      source_event_id: external_exports.string(),
+      /** Segment containing source_event_id — filled by the companion at
+       * batch-build time when known, else null. */
+      segment_id: external_exports.string().max(64).nullable().default(null),
+      /** The agent that made the call (TOOLS enum — "tool" in legacy naming). */
+      agent: external_exports.enum(TOOLS),
+      /** `builtin` or `mcp:<server>`. */
+      server: external_exports.string().max(120),
+      /** Bare tool name (`Bash`, `create_pr`) — normalised vendor identifier. */
+      name: external_exports.string().max(120),
+      turn_index: external_exports.number().int().nonnegative().nullable(),
+      /** Ordinal of the call within its source event (0-based). */
+      call_index: external_exports.number().int().nonnegative(),
+      /** ts of the line carrying the tool_use. */
+      started_at: external_exports.string().datetime({ offset: true }),
+      /** ts of the line carrying the matching tool_result; null if unmatched. */
+      ended_at: external_exports.string().datetime({ offset: true }).nullable(),
+      status: external_exports.enum(TOOL_CALL_STATUSES),
+      /** Hex sha256 of JSON.stringify(input); `""` when the call had no input. */
+      args_hash: external_exports.string().max(64),
+      /** Sha256 of the sorted top-level arg key names joined by `,`; the
+       * literal `none` when input is not a non-empty object. */
+      signature_hash: external_exports.string().max(64),
+      /** UTF-8 byte length of JSON.stringify(input); 0 if none. */
+      args_bytes: external_exports.number().int().nonnegative(),
+      /** UTF-8 byte length of JSON.stringify(tool_result content); 0 if
+       * unmatched/empty. */
+      result_bytes: external_exports.number().int().nonnegative(),
+      /** Model of the assistant message that issued the call. `<synthetic>`
+       * kept verbatim per the PR #12 attribution rules. */
+      model: external_exports.string().max(120).nullable(),
+      /** ONLY for shell-ish tools: command verbs from the fixed allowlist
+       * (@modelstat/parsers/shell-families). Never raw command text. */
+      command_families: external_exports.array(external_exports.string().max(40)).max(3).default([])
+    });
     IngestBatch = external_exports.object({
       batch_id: external_exports.string(),
       // ULID
@@ -4416,6 +4466,10 @@ var init_schemas = __esm({
       agent_version: external_exports.string().max(40),
       events: external_exports.array(RawEvent).max(1e4),
       segments: external_exports.array(Segment).max(2e3).default([]),
+      /** Per-call tool invocations (additive — old agents omit it, old
+       * servers ignore it). See ToolCallWire for the privacy contract:
+       * hashes / byte sizes / allowlisted verbs only, never payloads. */
+      tool_calls: external_exports.array(ToolCallWire).max(2e4).default([]),
       /** Optional per-session metadata hint: which installation produced them, etc. */
       session_installs: external_exports.record(
         external_exports.string(),
@@ -4684,22 +4738,222 @@ var init_src = __esm({
   }
 });
 
-// ../../packages/parsers/src/claude-code/index.ts
+// ../../packages/parsers/src/shell-families/index.ts
+function extractCommandFamilies(command) {
+  const families = [];
+  for (const part of splitCommandParts(command)) {
+    const verb = leadingVerb(part);
+    if (!verb || !ALLOWLIST.has(verb)) continue;
+    if (!families.includes(verb)) families.push(verb);
+    if (families.length >= MAX_COMMAND_FAMILIES) break;
+  }
+  return families;
+}
+function splitCommandParts(command) {
+  const parts = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < command.length; i++) {
+    const ch = command[i];
+    if (!inSingle && ch === "\\") {
+      current += ch + (command[i + 1] ?? "");
+      i++;
+      continue;
+    }
+    if (ch === "'" && !inDouble) {
+      inSingle = !inSingle;
+      current += ch;
+      continue;
+    }
+    if (ch === '"' && !inSingle) {
+      inDouble = !inDouble;
+      current += ch;
+      continue;
+    }
+    if (!inSingle && !inDouble) {
+      if (ch === ";" || ch === "|" || ch === "\n") {
+        parts.push(current);
+        current = "";
+        continue;
+      }
+      if (ch === "&" && command[i + 1] === "&") {
+        parts.push(current);
+        current = "";
+        i++;
+        continue;
+      }
+    }
+    current += ch;
+  }
+  parts.push(current);
+  return parts;
+}
+function leadingVerb(part) {
+  const tokens = part.trim().split(/\s+/);
+  let i = 0;
+  while (i < tokens.length) {
+    const tok = stripQuotes(tokens[i] ?? "");
+    if (tok === "") {
+      i++;
+      continue;
+    }
+    if (VAR_ASSIGNMENT.test(tok)) {
+      i++;
+      continue;
+    }
+    if (WRAPPERS.has(tok)) {
+      i++;
+      while (i < tokens.length && (tokens[i] ?? "").startsWith("-")) i++;
+      continue;
+    }
+    const base = tok.split("/").pop() ?? tok;
+    return base === "" ? null : base;
+  }
+  return null;
+}
+function stripQuotes(token) {
+  if (token.length >= 2) {
+    const first = token[0];
+    const last = token[token.length - 1];
+    if (first === "'" && last === "'" || first === '"' && last === '"') {
+      return token.slice(1, -1);
+    }
+  }
+  return token;
+}
+var SHELL_FAMILY_ALLOWLIST, MAX_COMMAND_FAMILIES, ALLOWLIST, WRAPPERS, VAR_ASSIGNMENT;
+var init_shell_families = __esm({
+  "../../packages/parsers/src/shell-families/index.ts"() {
+    "use strict";
+    SHELL_FAMILY_ALLOWLIST = [
+      "git",
+      "npm",
+      "pnpm",
+      "npx",
+      "yarn",
+      "node",
+      "python",
+      "python3",
+      "pytest",
+      "pip",
+      "pip3",
+      "cargo",
+      "rustc",
+      "go",
+      "make",
+      "cmake",
+      "docker",
+      "docker-compose",
+      "kubectl",
+      "helm",
+      "terraform",
+      "gh",
+      "aws",
+      "gcloud",
+      "az",
+      "curl",
+      "wget",
+      "rg",
+      "grep",
+      "find",
+      "sed",
+      "awk",
+      "jq",
+      "psql",
+      "mysql",
+      "redis-cli",
+      "brew",
+      "apt",
+      "tsx",
+      "vitest",
+      "jest",
+      "playwright",
+      "ruby",
+      "bundle",
+      "mvn",
+      "gradle",
+      "ls",
+      "cat"
+    ];
+    MAX_COMMAND_FAMILIES = 3;
+    ALLOWLIST = new Set(SHELL_FAMILY_ALLOWLIST);
+    WRAPPERS = /* @__PURE__ */ new Set(["sudo", "env", "time", "nice"]);
+    VAR_ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/;
+  }
+});
+
+// ../../packages/parsers/src/tool-hash/index.ts
 import { createHash } from "crypto";
+function hashArgs(input) {
+  if (input === void 0 || input === null) {
+    return { args_hash: "", signature_hash: SIGNATURE_NONE, args_bytes: 0 };
+  }
+  const json = JSON.stringify(input);
+  if (json === void 0) {
+    return { args_hash: "", signature_hash: SIGNATURE_NONE, args_bytes: 0 };
+  }
+  const argsHash = createHash("sha256").update(json).digest("hex");
+  let signatureHash = SIGNATURE_NONE;
+  if (typeof input === "object" && !Array.isArray(input)) {
+    const keys = Object.keys(input).sort();
+    if (keys.length > 0) {
+      signatureHash = createHash("sha256").update(keys.join(",")).digest("hex");
+    }
+  }
+  return {
+    args_hash: argsHash,
+    signature_hash: signatureHash,
+    args_bytes: Buffer.byteLength(json, "utf8")
+  };
+}
+function jsonBytes(value) {
+  if (value === void 0 || value === null || value === "") return 0;
+  const json = JSON.stringify(value);
+  return json === void 0 ? 0 : Buffer.byteLength(json, "utf8");
+}
+function normalizeToolName(raw) {
+  const cleaned = raw.normalize("NFC").trim().replace(UUID_RE, "<dyn>").replace(HEX_TAIL_RE, "<dyn>");
+  return cleaned.slice(0, 120);
+}
+function splitObservedToolName(observed) {
+  const m = /^mcp__([^_].*?)__(.+)$/.exec(observed.trim());
+  if (m?.[1] && m[2]) {
+    return {
+      server: `mcp:${normalizeToolName(m[1]).slice(0, 116)}`,
+      name: normalizeToolName(m[2])
+    };
+  }
+  return { server: "builtin", name: normalizeToolName(observed) };
+}
+function toolIdentity(server, name) {
+  return server === "builtin" ? name : `${server}/${name}`;
+}
+function fallbackCallId(sourceEventId2, callIndex) {
+  const s = `${sourceEventId2}|${callIndex}`;
+  let h = 5381n;
+  for (let i = 0; i < s.length; i++) {
+    h = h * 33n ^ BigInt(s.charCodeAt(i));
+    h &= 0xffffffffffffffffn;
+  }
+  return `tc_${h.toString(36)}`;
+}
+var SIGNATURE_NONE, UUID_RE, HEX_TAIL_RE;
+var init_tool_hash = __esm({
+  "../../packages/parsers/src/tool-hash/index.ts"() {
+    "use strict";
+    SIGNATURE_NONE = "none";
+    UUID_RE = /[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}/g;
+    HEX_TAIL_RE = /[0-9a-fA-F]{8,}(?=$|[^0-9a-zA-Z])/g;
+  }
+});
+
+// ../../packages/parsers/src/claude-code/index.ts
+import { createHash as createHash2 } from "crypto";
 import { createReadStream, existsSync as existsSync2, readdirSync } from "fs";
 import { stat } from "fs/promises";
 import { dirname as dirname2, join } from "path";
 import { createInterface } from "readline";
-function countToolCalls(content) {
-  const counts = {};
-  if (!Array.isArray(content)) return counts;
-  for (const block of content) {
-    if (block && block.type === "tool_use" && typeof block.name === "string" && block.name) {
-      counts[block.name] = (counts[block.name] ?? 0) + 1;
-    }
-  }
-  return counts;
-}
 function extractExcerpt(content) {
   if (!content) return void 0;
   let text = "";
@@ -4722,8 +4976,41 @@ function extractExcerpt(content) {
   const truncated = cleaned.slice(0, 320);
   return truncated.length > 0 ? truncated : void 0;
 }
+function commandFamiliesFor(server, name, input) {
+  if (server !== "builtin" || !SHELL_TOOL_NAMES.has(name)) return [];
+  if (typeof input !== "object" || input === null) return [];
+  const command = input.command;
+  return typeof command === "string" ? extractCommandFamilies(command) : [];
+}
+function buildToolCallDraft(opts) {
+  const { server, name } = splitObservedToolName(opts.observedName);
+  const hashes = hashArgs(opts.input);
+  return {
+    external_call_id: typeof opts.rawCallId === "string" && opts.rawCallId.trim() !== "" ? opts.rawCallId.trim().slice(0, 120) : fallbackCallId(opts.sourceEventId, opts.callIndex),
+    session_id: opts.sessionId,
+    source_event_id: opts.sourceEventId,
+    agent: "claude_code",
+    server,
+    name,
+    // This parser never derives a turn index (events above carry
+    // turn_index: null too), so per-call records can't either.
+    turn_index: null,
+    call_index: opts.callIndex,
+    started_at: opts.startedAt,
+    ended_at: null,
+    status: "unknown",
+    args_hash: hashes.args_hash,
+    signature_hash: hashes.signature_hash,
+    args_bytes: hashes.args_bytes,
+    result_bytes: 0,
+    model: opts.model,
+    command_families: commandFamiliesFor(server, name, opts.input)
+  };
+}
 async function parseClaudeCodeJsonl(ctx) {
   const events = [];
+  const toolCalls = [];
+  const pendingByCallId = /* @__PURE__ */ new Map();
   let chunk = [];
   let emitted = 0;
   const emit = async (e) => {
@@ -4826,6 +5113,32 @@ async function parseClaudeCodeJsonl(ctx) {
       }
       const slug = guessRepoSlugFromPath(cwd);
       const excerpt = extractExcerpt(a.message?.content);
+      const aggregate = {};
+      const blocks = Array.isArray(a.message?.content) ? a.message.content : [];
+      let callIndex = 0;
+      for (const block of blocks) {
+        if (!block || block.type !== "tool_use") continue;
+        const index = callIndex;
+        callIndex += 1;
+        const observed = typeof block.name === "string" ? block.name.trim() : "";
+        if (!observed) continue;
+        const draft = buildToolCallDraft({
+          observedName: observed,
+          rawCallId: block.id,
+          input: block.input,
+          sessionId,
+          sourceEventId: eventId,
+          callIndex: index,
+          startedAt: a.timestamp,
+          // Model verbatim from the issuing assistant message —
+          // including "<synthetic>" (same rule as the event below).
+          model: a.message?.model ?? null
+        });
+        const identity = toolIdentity(draft.server, draft.name);
+        aggregate[identity] = (aggregate[identity] ?? 0) + 1;
+        toolCalls.push(draft);
+        if (typeof block.id === "string" && block.id) pendingByCallId.set(block.id, draft);
+      }
       await emit({
         source_event_id: eventId,
         ts: a.timestamp,
@@ -4852,7 +5165,7 @@ async function parseClaudeCodeJsonl(ctx) {
           reasoning: 0
         },
         duration_ms: null,
-        tool_calls: countToolCalls(a.message?.content),
+        tool_calls: aggregate,
         files_touched: [],
         ...excerpt ? { content_excerpt: excerpt } : {},
         source_file: ctx.sourceFile,
@@ -4865,6 +5178,20 @@ async function parseClaudeCodeJsonl(ctx) {
       });
     } else if (obj.type === "user") {
       const u = obj;
+      const uContent = u.message?.content;
+      if (Array.isArray(uContent)) {
+        for (const block of uContent) {
+          if (!block || block.type !== "tool_result") continue;
+          const ref = block.tool_use_id;
+          if (typeof ref !== "string") continue;
+          const draft = pendingByCallId.get(ref);
+          if (!draft) continue;
+          pendingByCallId.delete(ref);
+          draft.ended_at = u.timestamp;
+          draft.status = block.is_error === true ? "error" : "success";
+          draft.result_bytes = jsonBytes(block.content);
+        }
+      }
       if (!u.uuid || !sessionId) {
         skipped += 1;
         continue;
@@ -4896,6 +5223,30 @@ async function parseClaudeCodeJsonl(ctx) {
         source_byte_offset: offsetAtLineStart,
         billing: "subscription"
       });
+    } else if (obj.type === "tool_use") {
+      const t = obj;
+      const observed = typeof t.name === "string" ? t.name.trim() : "";
+      const ts = typeof t.timestamp === "string" ? t.timestamp : null;
+      const sid = (typeof t.sessionId === "string" ? t.sessionId : null) ?? sessionId;
+      if (!observed || !ts || !sid) {
+        skipped += 1;
+        continue;
+      }
+      const draft = buildToolCallDraft({
+        observedName: observed,
+        rawCallId: t.id,
+        input: t.input,
+        sessionId: sid,
+        sourceEventId: sourceEventId(ctx.deviceId, ctx.sourceFile, offsetAtLineStart),
+        callIndex: 0,
+        startedAt: ts,
+        // No issuing assistant message on this line — attribute to the
+        // session's last real model, same as user_message attribution
+        // (lastModel never holds "<synthetic>", per the rule above).
+        model: lastModel
+      });
+      toolCalls.push(draft);
+      if (typeof t.id === "string" && t.id) pendingByCallId.set(t.id, draft);
     } else {
       skipped += 1;
     }
@@ -4903,6 +5254,7 @@ async function parseClaudeCodeJsonl(ctx) {
   if (ctx.onEvents && chunk.length > 0) await ctx.onEvents(chunk);
   return {
     events,
+    toolCalls,
     stats: { rawLines, emittedEvents: emitted, skipped },
     sourceFile: ctx.sourceFile
   };
@@ -4917,16 +5269,26 @@ async function quickChecksum(path5) {
     start: Math.max(0, st.size - 4096),
     encoding: "utf8"
   });
-  const h = createHash("sha1");
+  const h = createHash2("sha1");
   for await (const chunk of stream) h.update(chunk);
   return { size: st.size, mtime: st.mtimeMs, tailHash: h.digest("hex").slice(0, 16) };
 }
+var SHELL_TOOL_NAMES;
 var init_claude_code = __esm({
   "../../packages/parsers/src/claude-code/index.ts"() {
     "use strict";
     init_src();
-    init_types();
     init_git();
+    init_shell_families();
+    init_tool_hash();
+    init_types();
+    SHELL_TOOL_NAMES = /* @__PURE__ */ new Set([
+      "Bash",
+      "shell",
+      "local_shell_call",
+      "exec_command",
+      "run_terminal_cmd"
+    ]);
   }
 });
 
@@ -4939,8 +5301,90 @@ function deriveSessionIdFromRolloutPath(path5) {
   );
   return m ? m[1] ?? null : null;
 }
+function commandFieldToString(cmd) {
+  if (typeof cmd === "string") return cmd || null;
+  if (Array.isArray(cmd)) {
+    const parts = cmd.filter((p) => typeof p === "string");
+    if (parts.length === 0) return null;
+    const head = (parts[0] ?? "").split("/").pop() ?? "";
+    const flag = parts[1] ?? "";
+    if (parts.length >= 3 && SHELL_WRAPPER_BINARIES.has(head) && /^-[a-z]*c[a-z]*$/i.test(flag)) {
+      return parts.slice(2).join("\n");
+    }
+    return parts.join(" ");
+  }
+  return null;
+}
+function firstString(...values) {
+  for (const v of values) {
+    if (typeof v === "string" && v) return v;
+  }
+  return null;
+}
+function extractToolCallPayload(pt, p) {
+  const callId = firstString(p.call_id, p.id);
+  const failed = p.status === "failed";
+  if (pt === "local_shell_call") {
+    const action = p.action && typeof p.action === "object" ? p.action : null;
+    const command = commandFieldToString(action?.command);
+    return {
+      callId,
+      server: "builtin",
+      name: "shell",
+      input: action,
+      commandFamilies: command ? extractCommandFamilies(command) : [],
+      failed
+    };
+  }
+  const observed = firstString(p.name, p.tool);
+  if (!observed) return null;
+  let input = pt === "custom_tool_call" ? p.input : p.arguments ?? p.input;
+  if (typeof input === "string" && !input.trim()) input = void 0;
+  if (pt !== "custom_tool_call" && typeof input === "string") {
+    try {
+      input = JSON.parse(input);
+    } catch {
+    }
+  }
+  if (SHELL_TOOL_NAMES2.has(observed)) {
+    const rec = input && typeof input === "object" && !Array.isArray(input) ? input : null;
+    const command = commandFieldToString(
+      rec?.command ?? rec?.cmd ?? (typeof input === "string" ? input : null)
+    );
+    return {
+      callId,
+      server: "builtin",
+      name: "shell",
+      input,
+      commandFamilies: command ? extractCommandFamilies(command) : [],
+      failed
+    };
+  }
+  if (pt === "mcp_tool_call" && typeof p.server === "string" && p.server) {
+    return {
+      callId,
+      // Mirror splitObservedToolName's cap: 116 + the `mcp:` prefix ≤ 120.
+      server: `mcp:${normalizeToolName(p.server).slice(0, 116)}`,
+      name: normalizeToolName(observed),
+      input,
+      commandFamilies: [],
+      failed
+    };
+  }
+  const { server, name } = splitObservedToolName(observed);
+  return { callId, server, name, input, commandFamilies: [], failed };
+}
+function outputIndicatesError(p) {
+  const out = p.output ?? p.result;
+  if (out && typeof out === "object" && !Array.isArray(out)) {
+    const o = out;
+    if (o.success === false || o.is_error === true) return true;
+  }
+  return false;
+}
 async function parseCodexRollout(ctx) {
   const events = [];
+  const toolCalls = [];
   let chunk = [];
   let emitted = 0;
   const emit = async (e) => {
@@ -4969,6 +5413,9 @@ async function parseCodexRollout(ctx) {
   let cwd = null;
   let model = null;
   let turnIndex = 0;
+  let lastTs = null;
+  const openCalls = /* @__PURE__ */ new Map();
+  let pendingToolAggregate = {};
   for await (const line of rl) {
     const byteLen = Buffer.byteLength(line, "utf8") + 1;
     const offsetAtLineStart = startOffset + bytePos;
@@ -4985,22 +5432,91 @@ async function parseCodexRollout(ctx) {
       skipped += 1;
       continue;
     }
+    const lineTs = obj.timestamp;
+    if (typeof lineTs === "string" && lineTs) lastTs = lineTs;
     if (obj.type === "session_meta") {
       const m = obj;
-      sessionId = m.id ?? sessionId;
+      const id = m.id ?? m.payload?.id ?? null;
+      if (id && id !== sessionId) {
+        sessionId = id;
+        pendingToolAggregate = {};
+        openCalls.clear();
+      }
       continue;
     }
     if (obj.type === "turn_context") {
       const t = obj;
-      cwd = t.cwd ?? cwd;
-      model = t.model ?? model;
+      cwd = t.cwd ?? t.payload?.cwd ?? cwd;
+      model = t.model ?? t.payload?.model ?? model;
+      continue;
+    }
+    if (obj.type === "response_item") {
+      const r = obj;
+      const payload = r.payload;
+      const pt = payload && typeof payload.type === "string" ? payload.type : null;
+      if (pt && TOOL_CALL_PAYLOAD_TYPES.has(pt) && sessionId) {
+        const extracted = extractToolCallPayload(pt, payload);
+        if (!extracted) {
+          skipped += 1;
+          continue;
+        }
+        const ts = r.timestamp ?? lastTs;
+        if (!ts) {
+          skipped += 1;
+          continue;
+        }
+        const srcId = sourceEventId(ctx.deviceId, ctx.sourceFile, offsetAtLineStart);
+        const { args_hash, signature_hash, args_bytes } = hashArgs(extracted.input);
+        const draft = {
+          external_call_id: (extracted.callId ?? fallbackCallId(srcId, 0)).slice(0, 120),
+          session_id: sessionId,
+          source_event_id: srcId,
+          agent: "codex_cli",
+          server: extracted.server,
+          name: extracted.name,
+          turn_index: turnIndex,
+          // Each response_item line carries exactly one call.
+          call_index: 0,
+          started_at: ts,
+          ended_at: null,
+          status: extracted.failed ? "error" : "unknown",
+          args_hash,
+          signature_hash,
+          args_bytes,
+          result_bytes: 0,
+          model,
+          command_families: extracted.commandFamilies
+        };
+        toolCalls.push(draft);
+        if (extracted.callId) openCalls.set(extracted.callId, draft);
+        const identity = toolIdentity(extracted.server, extracted.name);
+        pendingToolAggregate[identity] = (pendingToolAggregate[identity] ?? 0) + 1;
+        continue;
+      }
+      if (pt && TOOL_CALL_OUTPUT_PAYLOAD_TYPES.has(pt)) {
+        const p = payload;
+        const callId = firstString(p.call_id, p.id);
+        const open2 = callId ? openCalls.get(callId) : void 0;
+        if (!callId || !open2) {
+          skipped += 1;
+          continue;
+        }
+        openCalls.delete(callId);
+        open2.ended_at = r.timestamp ?? lastTs ?? open2.started_at;
+        open2.result_bytes = jsonBytes(p.output ?? p.result);
+        if (open2.status === "unknown") {
+          open2.status = outputIndicatesError(p) ? "error" : "success";
+        }
+        continue;
+      }
+      skipped += 1;
       continue;
     }
     if (obj.type === "event_msg") {
       const m = obj;
       const ts = m.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
       const payload = m.payload;
-      if (!payload || !payload.type) {
+      if (!payload?.type) {
         skipped += 1;
         continue;
       }
@@ -5037,11 +5553,12 @@ async function parseCodexRollout(ctx) {
             reasoning: tk.reasoning_output_tokens ?? 0
           },
           duration_ms: null,
-          tool_calls: {},
+          tool_calls: pendingToolAggregate,
           files_touched: [],
           source_file: ctx.sourceFile,
           source_byte_offset: offsetAtLineStart
         });
+        pendingToolAggregate = {};
         turnIndex += 1;
         continue;
       }
@@ -5079,16 +5596,39 @@ async function parseCodexRollout(ctx) {
   if (ctx.onEvents && chunk.length > 0) await ctx.onEvents(chunk);
   return {
     events,
+    toolCalls,
     stats: { rawLines, emittedEvents: emitted, skipped },
     sourceFile: ctx.sourceFile
   };
 }
+var TOOL_CALL_PAYLOAD_TYPES, TOOL_CALL_OUTPUT_PAYLOAD_TYPES, SHELL_TOOL_NAMES2, SHELL_WRAPPER_BINARIES;
 var init_codex = __esm({
   "../../packages/parsers/src/codex/index.ts"() {
     "use strict";
     init_src();
-    init_types();
     init_git();
+    init_shell_families();
+    init_tool_hash();
+    init_types();
+    TOOL_CALL_PAYLOAD_TYPES = /* @__PURE__ */ new Set([
+      "function_call",
+      "local_shell_call",
+      "custom_tool_call",
+      "mcp_tool_call"
+    ]);
+    TOOL_CALL_OUTPUT_PAYLOAD_TYPES = /* @__PURE__ */ new Set([
+      "function_call_output",
+      "local_shell_call_output",
+      "custom_tool_call_output",
+      "mcp_tool_call_output"
+    ]);
+    SHELL_TOOL_NAMES2 = /* @__PURE__ */ new Set([
+      "shell",
+      "local_shell_call",
+      "exec_command",
+      "run_terminal_cmd"
+    ]);
+    SHELL_WRAPPER_BINARIES = /* @__PURE__ */ new Set(["bash", "sh", "zsh", "dash", "fish"]);
   }
 });
 
@@ -44392,6 +44932,16 @@ var init_ids2 = __esm({
 });
 
 // ../../packages/companion-core/src/queue/index.ts
+function attachSegmentIds(calls, segments) {
+  const segmentByEvent = /* @__PURE__ */ new Map();
+  for (const seg of segments) {
+    for (const id of seg.source_event_ids) segmentByEvent.set(id, seg.segment_id);
+  }
+  return calls.map((c) => ({
+    ...c,
+    segment_id: segmentByEvent.get(c.source_event_id) ?? null
+  }));
+}
 var init_queue = __esm({
   "../../packages/companion-core/src/queue/index.ts"() {
     "use strict";
@@ -44400,21 +44950,6 @@ var init_queue = __esm({
   }
 });
 
-// ../../packages/companion-core/src/pipeline/prompts.ts
-var OLLAMA_CHAT_MODEL, OLLAMA_EMBED_MODEL, SUMMARISER_SYSTEM_PROMPT, SUMMARISER_MAX_TOKENS, SUMMARISER_TEMPERATURE, QWEN_CHARS_PER_TOKEN, ABSTRACT_OUTPUT_MAX_CHARS;
-var init_prompts = __esm({
-  "../../packages/companion-core/src/pipeline/prompts.ts"() {
-    "use strict";
-    OLLAMA_CHAT_MODEL = "qwen3:4b";
-    OLLAMA_EMBED_MODEL = "bge-small-en-v1.5";
-    SUMMARISER_SYSTEM_PROMPT = "You summarise an AI coding session in ONE sentence, \u2264 240 characters. If the user message includes sampled conversation excerpts, base your summary on what the developer was actually working on (the substance \u2014 what was being built, debugged, refactored, or designed). If only metadata is given, paraphrase the metadata. Never quote the excerpts verbatim. No PII, no code literals, no file paths, no API keys. Reply with only the sentence.";
-    SUMMARISER_MAX_TOKENS = 120;
-    SUMMARISER_TEMPERATURE = 0.2;
-    QWEN_CHARS_PER_TOKEN = 3.3;
-    ABSTRACT_OUTPUT_MAX_CHARS = 240;
-  }
-});
-
 // ../../packages/companion-core/src/pipeline/cognition.ts
 function buildCognitionUserPrompt(abstract) {
   return `Summary: "${abstract.replace(/\s+/g, " ").trim().slice(0, 480)}"
@@ -44497,6 +45032,21 @@ var init_cognition = __esm({
   }
 });
 
+// ../../packages/companion-core/src/pipeline/prompts.ts
+var OLLAMA_CHAT_MODEL, OLLAMA_EMBED_MODEL, SUMMARISER_SYSTEM_PROMPT, SUMMARISER_MAX_TOKENS, SUMMARISER_TEMPERATURE, QWEN_CHARS_PER_TOKEN, ABSTRACT_OUTPUT_MAX_CHARS;
+var init_prompts = __esm({
+  "../../packages/companion-core/src/pipeline/prompts.ts"() {
+    "use strict";
+    OLLAMA_CHAT_MODEL = "qwen3:4b";
+    OLLAMA_EMBED_MODEL = "bge-small-en-v1.5";
+    SUMMARISER_SYSTEM_PROMPT = "You summarise an AI coding session in ONE sentence, \u2264 240 characters. If the user message includes sampled conversation excerpts, base your summary on what the developer was actually working on (the substance \u2014 what was being built, debugged, refactored, or designed). If only metadata is given, paraphrase the metadata. Never quote the excerpts verbatim. No PII, no code literals, no file paths, no API keys. Reply with only the sentence.";
+    SUMMARISER_MAX_TOKENS = 120;
+    SUMMARISER_TEMPERATURE = 0.2;
+    QWEN_CHARS_PER_TOKEN = 3.3;
+    ABSTRACT_OUTPUT_MAX_CHARS = 240;
+  }
+});
+
 // ../../packages/companion-core/src/pipeline/title.ts
 function buildTitleUserPrompt(input) {
   const lines = input.abstracts.map(
@@ -44674,9 +45224,7 @@ async function buildForOneSession(sessionId, events, adapters2, onSlice) {
     } catch (err) {
       failed += 1;
       lastError = err instanceof Error ? err.message : String(err);
-      console.warn(
-        `[modelstat] slice failed in session ${sessionId}: ${lastError}`
-      );
+      console.warn(`[modelstat] slice failed in session ${sessionId}: ${lastError}`);
     }
   }
   if (failed > 0) {
@@ -44781,6 +45329,24 @@ Write the SHORTEST keyword-dense paragraph (1-3 sentences, \u2264${ABSTRACT_OUTP
   for (const c of [...components].slice(0, 8)) {
     tags.push({ root_key: "components", name: c, confidence: 0.6 });
   }
+  const toolCallCounts = /* @__PURE__ */ new Map();
+  let toolCallTotal = 0;
+  for (const ev of slice) {
+    for (const [identity, n] of Object.entries(ev.tool_calls ?? {})) {
+      if (!(n > 0)) continue;
+      toolCallCounts.set(identity, (toolCallCounts.get(identity) ?? 0) + n);
+      toolCallTotal += n;
+    }
+  }
+  const topToolCalls = [...toolCallCounts.entries()].filter(([identity]) => identity.length <= 120).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 8);
+  for (const [identity, count] of topToolCalls) {
+    const share = Math.round(count / toolCallTotal * 100) / 100;
+    tags.push({
+      root_key: "tool_calls",
+      name: identity,
+      confidence: Math.min(1, Math.max(0.05, share))
+    });
+  }
   let segmentEmbedding;
   try {
     const embedded = await adapters2.embed(redacted.text.slice(0, ABSTRACT_MAX_CHARS));
@@ -44868,13 +45434,13 @@ var SEGMENT_TIME_GAP_MS, SEGMENT_TOPIC_THRESHOLD, SEGMENT_MAX_TURNS, SEGMENT_MAX
 var init_pipeline = __esm({
   "../../packages/companion-core/src/pipeline/index.ts"() {
     "use strict";
-    init_redact();
     init_ids();
-    init_prompts();
-    init_cognition();
     init_redact();
+    init_cognition();
     init_prompts();
+    init_redact();
     init_cognition();
+    init_prompts();
     init_title();
     SEGMENT_TIME_GAP_MS = 15 * 6e4;
     SEGMENT_TOPIC_THRESHOLD = 0.35;
@@ -45698,7 +46264,8 @@ async function scanAll(cb = {}) {
         jobs.push({
           path: full,
           parse: async (sink2) => {
-            await parseClaudeCodeJsonl({ deviceId, sourceFile: full, onEvents: sink2 });
+            const r = await parseClaudeCodeJsonl({ deviceId, sourceFile: full, onEvents: sink2 });
+            return { toolCalls: r.toolCalls ?? [] };
           }
         });
       }
@@ -45721,7 +46288,8 @@ async function scanAll(cb = {}) {
             jobs.push({
               path: full,
               parse: async (sink2) => {
-                await parseCodexRollout({ deviceId, sourceFile: full, onEvents: sink2 });
+                const r = await parseCodexRollout({ deviceId, sourceFile: full, onEvents: sink2 });
+                return { toolCalls: r.toolCalls ?? [] };
               }
             });
           }
@@ -45737,10 +46305,11 @@ async function scanAll(cb = {}) {
   let eventsUploaded = 0;
   let segmentsUploaded = 0;
   let buffer = [];
+  let toolCallBuffer = [];
   let pendingCursors = [];
   const runSegmentsBySession = /* @__PURE__ */ new Map();
   async function flushBatch() {
-    if (!buffer.length) return;
+    if (!buffer.length && !toolCallBuffer.length) return;
     const events = buffer.map(withNonNullTokens);
     const segments = await buildSegments(events, cb.onProgress);
     for (const seg of segments) {
@@ -45764,6 +46333,10 @@ async function scanAll(cb = {}) {
       agent_version: AGENT_VERSION,
       events,
       segments,
+      // Per-call tool invocations: now that segments exist, attribute
+      // each call to the segment covering its source event (null when
+      // no segment covers it — e.g. codex response_item anchors).
+      tool_calls: attachSegmentIds(toolCallBuffer, segments),
       ...Object.keys(sessionTitles).length ? { session_titles: sessionTitles } : {}
     };
     cb.onUpload?.({ events: events.length, segments: segments.length });
@@ -45774,6 +46347,7 @@ async function scanAll(cb = {}) {
     for (const pc of pendingCursors) state.setCursor(pc.path, pc.cs);
     pendingCursors = [];
     buffer = [];
+    toolCallBuffer = [];
     cb.onUploaded?.({ events: res.accepted, segments: segments.length });
   }
   const sink = async (events) => {
@@ -45787,6 +46361,12 @@ async function scanAll(cb = {}) {
       );
     }
   };
+  const bufferToolCalls = async (calls) => {
+    for (const c of calls) {
+      if (toolCallBuffer.length >= BATCH_MAX_TOOL_CALLS) await flushBatch();
+      toolCallBuffer.push(c);
+    }
+  };
   for (let i = 0; i < jobs.length; i++) {
     const job = jobs[i];
     cb.onFile?.(job.path, i, jobs.length);
@@ -45798,7 +46378,8 @@ async function scanAll(cb = {}) {
     }
     filesScanned += 1;
     try {
-      await job.parse(sink);
+      const r = await job.parse(sink);
+      await bufferToolCalls(r.toolCalls);
       if (cs) pendingCursors.push({ path: job.path, cs });
     } catch (e) {
       console.warn(`  ! parse failed for ${job.path}:`, e.message);
@@ -45807,17 +46388,19 @@ async function scanAll(cb = {}) {
   await flushBatch();
   return { filesScanned, filesUnchanged, batchesUploaded, eventsUploaded, segmentsUploaded };
 }
-var AGENT_VERSION, BATCH_MAX_EVENTS, BATCH_BUFFER_HARD_CAP, ZERO_TOKENS;
+var AGENT_VERSION, BATCH_MAX_EVENTS, BATCH_MAX_TOOL_CALLS, BATCH_BUFFER_HARD_CAP, ZERO_TOKENS;
 var init_scan = __esm({
   "src/scan.ts"() {
     "use strict";
-    init_src2();
     init_src3();
-    init_pipeline2();
-    init_config2();
+    init_queue();
+    init_src2();
     init_api();
-    AGENT_VERSION = true ? "agent-0.0.46" : "agent-dev";
+    init_config2();
+    init_pipeline2();
+    AGENT_VERSION = true ? "agent-0.0.47" : "agent-dev";
     BATCH_MAX_EVENTS = 2e3;
+    BATCH_MAX_TOOL_CALLS = 2e4;
     BATCH_BUFFER_HARD_CAP = BATCH_MAX_EVENTS * 2;
     ZERO_TOKENS = {
       input: 0,
@@ -46028,7 +46611,7 @@ var PROCESSING_VERSION;
 var init_processing_version = __esm({
   "src/processing-version.ts"() {
     "use strict";
-    PROCESSING_VERSION = 4;
+    PROCESSING_VERSION = 5;
   }
 });
 
@@ -48075,7 +48658,7 @@ var init_daemon = __esm({
     init_lock();
     init_scan();
     init_single_flight();
-    AGENT_VERSION2 = true ? "agent-0.0.46" : "agent-dev";
+    AGENT_VERSION2 = true ? "agent-0.0.47" : "agent-dev";
     HEARTBEAT_INTERVAL_MS = 1e4;
     SCAN_INTERVAL_MS = 5 * 60 * 1e3;
     DISCOVERY_INTERVAL_MS = 6e4;
@@ -48640,7 +49223,7 @@ function tryOpenBrowser(url) {
     return false;
   }
 }
-var AGENT_VERSION3 = true ? "agent-0.0.46" : "agent-dev";
+var AGENT_VERSION3 = true ? "agent-0.0.47" : "agent-dev";
 function osFamily() {
   const p = platform4();
   if (p === "darwin") return "macos";