modelstat 0.0.45 → 0.0.47

package/dist/cli.mjs

@@ -50,9 +50,11 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // ../../packages/parsers/src/types.ts
+var PARSER_EVENT_CHUNK;
 var init_types = __esm({
   "../../packages/parsers/src/types.ts"() {
     "use strict";
+    PARSER_EVENT_CHUNK = 256;
   }
 });
 
@@ -76,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";
@@ -160,6 +162,13 @@ var init_enums = __esm({
       "tool_result",
       "summary"
     ];
+    TOOL_CALL_STATUSES = [
+      "success",
+      "error",
+      "denied",
+      "timeout",
+      "unknown"
+    ];
     COMPANION_PHASES = [
       "starting",
       "discovering",
@@ -4302,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";
@@ -4407,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
@@ -4414,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(),
@@ -4682,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 = "";
@@ -4720,8 +4976,56 @@ 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) => {
+    emitted += 1;
+    if (!ctx.onEvents) {
+      events.push(e);
+      return;
+    }
+    chunk.push(e);
+    if (chunk.length >= PARSER_EVENT_CHUNK) {
+      const full = chunk;
+      chunk = [];
+      await ctx.onEvents(full);
+    }
+  };
   let rawLines = 0;
   let skipped = 0;
   let bytePos = 0;
@@ -4809,7 +5113,33 @@ async function parseClaudeCodeJsonl(ctx) {
       }
       const slug = guessRepoSlugFromPath(cwd);
       const excerpt = extractExcerpt(a.message?.content);
-      events.push({
+      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,
         kind: "assistant_message",
@@ -4835,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,
@@ -4848,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;
@@ -4858,7 +5202,7 @@ async function parseClaudeCodeJsonl(ctx) {
         continue;
       }
       const excerpt = extractExcerpt(u.message?.content);
-      events.push({
+      await emit({
         source_event_id: eventId,
         ts: u.timestamp,
         kind: "user_message",
@@ -4879,13 +5223,39 @@ 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;
     }
   }
+  if (ctx.onEvents && chunk.length > 0) await ctx.onEvents(chunk);
   return {
     events,
-    stats: { rawLines, emittedEvents: events.length, skipped },
+    toolCalls,
+    stats: { rawLines, emittedEvents: emitted, skipped },
     sourceFile: ctx.sourceFile
   };
 }
@@ -4899,15 +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_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"
+    ]);
   }
 });
 
@@ -4920,8 +5301,105 @@ 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) => {
+    emitted += 1;
+    if (!ctx.onEvents) {
+      events.push(e);
+      return;
+    }
+    chunk.push(e);
+    if (chunk.length >= PARSER_EVENT_CHUNK) {
+      const full = chunk;
+      chunk = [];
+      await ctx.onEvents(full);
+    }
+  };
   let rawLines = 0;
   let skipped = 0;
   let bytePos = 0;
@@ -4935,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;
@@ -4951,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;
       }
@@ -4977,7 +5527,7 @@ async function parseCodexRollout(ctx) {
           continue;
         }
         const slug = guessRepoSlugFromPath(cwd);
-        events.push({
+        await emit({
           source_event_id: sourceEventId(ctx.deviceId, ctx.sourceFile, offsetAtLineStart),
           ts,
           kind: "assistant_message",
@@ -5003,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;
       }
@@ -5016,7 +5567,7 @@ async function parseCodexRollout(ctx) {
           skipped += 1;
           continue;
         }
-        events.push({
+        await emit({
           source_event_id: sourceEventId(ctx.deviceId, ctx.sourceFile, offsetAtLineStart),
           ts,
           kind: "user_message",
@@ -5042,17 +5593,42 @@ async function parseCodexRollout(ctx) {
     }
     skipped += 1;
   }
+  if (ctx.onEvents && chunk.length > 0) await ctx.onEvents(chunk);
   return {
     events,
-    stats: { rawLines, emittedEvents: events.length, skipped },
+    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_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"]);
   }
 });
 
@@ -7622,107 +8198,6 @@ var init_src2 = __esm({
   }
 });
 
-// src/identity.ts
-import {
-  chmodSync,
-  mkdirSync,
-  readFileSync as readFileSync2,
-  renameSync,
-  writeFileSync,
-  existsSync as existsSync4
-} from "fs";
-import { homedir as homedir2, hostname as osHostname } from "os";
-import { join as join3 } from "path";
-function ensureRoot() {
-  mkdirSync(ROOT, { recursive: true, mode: 448 });
-}
-function writeAtomic(meta) {
-  ensureRoot();
-  const tmp = `${IDENTITY_FILE}.${process.pid}.tmp`;
-  writeFileSync(tmp, JSON.stringify(meta, null, 2), { mode: 384 });
-  renameSync(tmp, IDENTITY_FILE);
-  try {
-    chmodSync(IDENTITY_FILE, 384);
-  } catch {
-  }
-}
-function identityPath() {
-  return IDENTITY_FILE;
-}
-function hasIdentityFile() {
-  return existsSync4(IDENTITY_FILE);
-}
-function parseFile() {
-  try {
-    const raw = readFileSync2(IDENTITY_FILE, "utf8");
-    const obj = JSON.parse(raw);
-    if (!obj.deviceUuid || !obj.deviceId || !obj.bearerToken) {
-      return null;
-    }
-    return {
-      deviceUuid: obj.deviceUuid,
-      deviceId: obj.deviceId,
-      bearerToken: obj.bearerToken,
-      claimCode: obj.claimCode ?? null,
-      claimUrl: obj.claimUrl ?? null,
-      hostname: obj.hostname ?? osHostname(),
-      createdAt: obj.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-      userEmail: obj.userEmail ?? null,
-      defaultOrgId: obj.defaultOrgId ?? null
-    };
-  } catch {
-    return null;
-  }
-}
-function loadIdentity(migrateFromConf2) {
-  const fromFile = parseFile();
-  if (fromFile) return fromFile;
-  if (!migrateFromConf2) return null;
-  const legacy = migrateFromConf2();
-  if (!legacy) return null;
-  if (!legacy.deviceUuid || !legacy.deviceId || !legacy.bearerToken) {
-    return null;
-  }
-  const migrated = {
-    deviceUuid: legacy.deviceUuid,
-    deviceId: legacy.deviceId,
-    bearerToken: legacy.bearerToken,
-    claimCode: legacy.claimCode ?? null,
-    claimUrl: legacy.claimUrl ?? null,
-    hostname: osHostname(),
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    userEmail: legacy.userEmail ?? null,
-    defaultOrgId: legacy.defaultOrgId ?? null
-  };
-  writeAtomic(migrated);
-  return migrated;
-}
-function saveIdentity(meta) {
-  writeAtomic(meta);
-}
-function backupIdentity() {
-  if (!existsSync4(IDENTITY_FILE)) return null;
-  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const dest = `${IDENTITY_FILE}.bak-${stamp}`;
-  renameSync(IDENTITY_FILE, dest);
-  return dest;
-}
-function updateIdentity(patch) {
-  const current = parseFile();
-  if (!current) return null;
-  const merged = { ...current, ...patch };
-  writeAtomic(merged);
-  return merged;
-}
-var ROOT, IDENTITY_FILE;
-var init_identity = __esm({
-  "src/identity.ts"() {
-    "use strict";
-    ROOT = join3(homedir2(), ".modelstat");
-    IDENTITY_FILE = join3(ROOT, "identity.json");
-  }
-});
-
 // ../../node_modules/.pnpm/undici@7.25.0/node_modules/undici/lib/core/symbols.js
 var require_symbols = __commonJS({
   "../../node_modules/.pnpm/undici@7.25.0/node_modules/undici/lib/core/symbols.js"(exports, module) {
@@ -32614,6 +33089,9 @@ function classifyStatus(status2, attempt) {
   }
   return { type: "drop", reason: `http_${status2}` };
 }
+function wellFormedStringify(value) {
+  return JSON.stringify(value, (_key, v) => typeof v === "string" ? v.toWellFormed() : v);
+}
 function sleep(ms) {
   return new Promise((r) => {
     setTimeout(r, ms);
@@ -32652,7 +33130,10 @@ var init_http = __esm({
                 "content-type": "application/json",
                 authorization: `Bearer ${token}`
               },
-              body: JSON.stringify(batch)
+              // wellFormedStringify, not JSON.stringify: a truncated-emoji
+              // lone surrogate in any excerpt 400s the whole batch on the
+              // serde_json side. See the helper's doc comment.
+              body: wellFormedStringify(batch)
             });
           } catch (err) {
             const detail = describeErrorWithCause(err);
@@ -33301,15 +33782,15 @@ function envPaths(name, { suffix = "nodejs" } = {}) {
   }
   return linux(name);
 }
-var homedir3, tmpdir, env, macos, windows, linux;
+var homedir2, tmpdir, env, macos, windows, linux;
 var init_env_paths = __esm({
   "../../node_modules/.pnpm/env-paths@3.0.0/node_modules/env-paths/index.js"() {
     "use strict";
-    homedir3 = os.homedir();
+    homedir2 = os.homedir();
     tmpdir = os.tmpdir();
     ({ env } = process2);
     macos = (name) => {
-      const library = path.join(homedir3, "Library");
+      const library = path.join(homedir2, "Library");
       return {
         data: path.join(library, "Application Support", name),
         config: path.join(library, "Preferences", name),
@@ -33319,8 +33800,8 @@ var init_env_paths = __esm({
       };
     };
     windows = (name) => {
-      const appData = env.APPDATA || path.join(homedir3, "AppData", "Roaming");
-      const localAppData = env.LOCALAPPDATA || path.join(homedir3, "AppData", "Local");
+      const appData = env.APPDATA || path.join(homedir2, "AppData", "Roaming");
+      const localAppData = env.LOCALAPPDATA || path.join(homedir2, "AppData", "Local");
       return {
         // Data/config/cache/log are invented by me as Windows isn't opinionated about this
         data: path.join(localAppData, name, "Data"),
@@ -33331,13 +33812,13 @@ var init_env_paths = __esm({
       };
     };
     linux = (name) => {
-      const username = path.basename(homedir3);
+      const username = path.basename(homedir2);
       return {
-        data: path.join(env.XDG_DATA_HOME || path.join(homedir3, ".local", "share"), name),
-        config: path.join(env.XDG_CONFIG_HOME || path.join(homedir3, ".config"), name),
-        cache: path.join(env.XDG_CACHE_HOME || path.join(homedir3, ".cache"), name),
+        data: path.join(env.XDG_DATA_HOME || path.join(homedir2, ".local", "share"), name),
+        config: path.join(env.XDG_CONFIG_HOME || path.join(homedir2, ".config"), name),
+        cache: path.join(env.XDG_CACHE_HOME || path.join(homedir2, ".cache"), name),
         // https://wiki.debian.org/XDGBaseDirectorySpecification#state
-        log: path.join(env.XDG_STATE_HOME || path.join(homedir3, ".local", "state"), name),
+        log: path.join(env.XDG_STATE_HOME || path.join(homedir2, ".local", "state"), name),
         temp: path.join(tmpdir, username, name)
       };
     };
@@ -33778,9 +34259,9 @@ import { once } from "events";
 import { createWriteStream } from "fs";
 import path3 from "path";
 import { Readable } from "stream";
-function writeFileSync2(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
+function writeFileSync(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
   if (isString(options))
-    return writeFileSync2(filePath, data, { encoding: options });
+    return writeFileSync(filePath, data, { encoding: options });
   const timeout = options.timeout ?? DEFAULT_TIMEOUT_SYNC;
   const retryOptions = { timeout };
   let tempDisposer = null;
@@ -43903,7 +44384,7 @@ var init_source = __esm({
           fs2.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
         } else {
           try {
-            writeFileSync2(this.path, data, { mode: this.#options.configFileMode });
+            writeFileSync(this.path, data, { mode: this.#options.configFileMode });
           } catch (error) {
             if (error?.code === "EXDEV") {
               fs2.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
@@ -44004,6 +44485,107 @@ var init_source = __esm({
   }
 });
 
+// src/identity.ts
+import {
+  chmodSync,
+  mkdirSync,
+  readFileSync as readFileSync2,
+  renameSync,
+  writeFileSync as writeFileSync2,
+  existsSync as existsSync4
+} from "fs";
+import { homedir as homedir3, hostname as osHostname } from "os";
+import { join as join3 } from "path";
+function ensureRoot() {
+  mkdirSync(ROOT, { recursive: true, mode: 448 });
+}
+function writeAtomic(meta) {
+  ensureRoot();
+  const tmp = `${IDENTITY_FILE}.${process.pid}.tmp`;
+  writeFileSync2(tmp, JSON.stringify(meta, null, 2), { mode: 384 });
+  renameSync(tmp, IDENTITY_FILE);
+  try {
+    chmodSync(IDENTITY_FILE, 384);
+  } catch {
+  }
+}
+function identityPath() {
+  return IDENTITY_FILE;
+}
+function hasIdentityFile() {
+  return existsSync4(IDENTITY_FILE);
+}
+function parseFile() {
+  try {
+    const raw = readFileSync2(IDENTITY_FILE, "utf8");
+    const obj = JSON.parse(raw);
+    if (!obj.deviceUuid || !obj.deviceId || !obj.bearerToken) {
+      return null;
+    }
+    return {
+      deviceUuid: obj.deviceUuid,
+      deviceId: obj.deviceId,
+      bearerToken: obj.bearerToken,
+      claimCode: obj.claimCode ?? null,
+      claimUrl: obj.claimUrl ?? null,
+      hostname: obj.hostname ?? osHostname(),
+      createdAt: obj.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      userEmail: obj.userEmail ?? null,
+      defaultOrgId: obj.defaultOrgId ?? null
+    };
+  } catch {
+    return null;
+  }
+}
+function loadIdentity(migrateFromConf2) {
+  const fromFile = parseFile();
+  if (fromFile) return fromFile;
+  if (!migrateFromConf2) return null;
+  const legacy = migrateFromConf2();
+  if (!legacy) return null;
+  if (!legacy.deviceUuid || !legacy.deviceId || !legacy.bearerToken) {
+    return null;
+  }
+  const migrated = {
+    deviceUuid: legacy.deviceUuid,
+    deviceId: legacy.deviceId,
+    bearerToken: legacy.bearerToken,
+    claimCode: legacy.claimCode ?? null,
+    claimUrl: legacy.claimUrl ?? null,
+    hostname: osHostname(),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    userEmail: legacy.userEmail ?? null,
+    defaultOrgId: legacy.defaultOrgId ?? null
+  };
+  writeAtomic(migrated);
+  return migrated;
+}
+function saveIdentity(meta) {
+  writeAtomic(meta);
+}
+function backupIdentity() {
+  if (!existsSync4(IDENTITY_FILE)) return null;
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const dest = `${IDENTITY_FILE}.bak-${stamp}`;
+  renameSync(IDENTITY_FILE, dest);
+  return dest;
+}
+function updateIdentity(patch) {
+  const current = parseFile();
+  if (!current) return null;
+  const merged = { ...current, ...patch };
+  writeAtomic(merged);
+  return merged;
+}
+var ROOT, IDENTITY_FILE;
+var init_identity = __esm({
+  "src/identity.ts"() {
+    "use strict";
+    ROOT = join3(homedir3(), ".modelstat");
+    IDENTITY_FILE = join3(ROOT, "identity.json");
+  }
+});
+
 // src/config.ts
 import { existsSync as existsSync5 } from "fs";
 import { hostname } from "os";
@@ -44350,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";
@@ -44358,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)}"
@@ -44455,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(
@@ -44632,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) {
@@ -44739,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));
@@ -44826,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;
@@ -45322,6 +45930,21 @@ var init_llama = __esm({
   }
 });
 
+// ../../packages/companion-core/src/optional-module.ts
+function isMissingOptionalModuleError(err) {
+  const code = err?.code;
+  if (code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") return true;
+  const msg = err instanceof Error ? err.message : String(err);
+  return /cannot find (package|module)|cannot resolve|failed to resolve/i.test(msg);
+}
+var OPTIONAL_MODULE_MAX_LOAD_ATTEMPTS;
+var init_optional_module = __esm({
+  "../../packages/companion-core/src/optional-module.ts"() {
+    "use strict";
+    OPTIONAL_MODULE_MAX_LOAD_ATTEMPTS = 3;
+  }
+});
+
 // ../../packages/companion-core/src/node/transformersjs-embed.ts
 async function loadPipeline(model) {
   if (cached) return cached;
@@ -45329,11 +45952,7 @@ async function loadPipeline(model) {
   if (!loadPromise2) {
     loadPromise2 = (async () => {
       try {
-        const moduleId = "@huggingface/transformers";
-        const tjs = await import(
-          /* @vite-ignore */
-          moduleId
-        );
+        const tjs = await importModule("@huggingface/transformers");
         const p = await tjs.pipeline("feature-extraction", model, {
           device: "cpu",
           dtype: "fp32"
@@ -45342,12 +45961,16 @@ async function loadPipeline(model) {
         return p;
       } catch (err) {
         const msg = err.message;
-        if (/unsupported|architecture|not supported|onnx|cannot resolve/i.test(msg)) {
+        loadAttempts += 1;
+        if (isMissingOptionalModuleError(err) || /unsupported|architecture|not supported|onnx/i.test(msg) || loadAttempts >= OPTIONAL_MODULE_MAX_LOAD_ATTEMPTS) {
           loadFailedPermanently = true;
         }
-        console.warn(
-          `[modelstat] transformers.js embedder unavailable (segments will be re-embedded server-side): ${msg}`
-        );
+        if (!warnedUnavailable) {
+          warnedUnavailable = true;
+          console.warn(
+            `[modelstat] transformers.js embedder unavailable (segments will be re-embedded server-side; further attempts ${loadFailedPermanently ? "disabled" : `limited to ${OPTIONAL_MODULE_MAX_LOAD_ATTEMPTS}`}, warning once): ${msg}`
+          );
+        }
         loadPromise2 = null;
         return null;
       }
@@ -45364,21 +45987,32 @@ function createTransformersJsEmbedder(model = DEFAULT_MODEL) {
       const out = await pipe(text, { pooling: "mean", normalize: true });
       return Array.from(out.data);
     } catch (err) {
-      console.warn(
-        `[modelstat] embed error (returning empty vector, server will re-embed): ${err.message}`
-      );
+      if (!warnedInferenceError) {
+        warnedInferenceError = true;
+        console.warn(
+          `[modelstat] embed error (returning empty vectors, server will re-embed; warning once): ${err.message}`
+        );
+      }
       return [];
     }
   };
 }
-var cached, loadPromise2, loadFailedPermanently, DEFAULT_MODEL;
+var cached, loadPromise2, loadFailedPermanently, loadAttempts, warnedUnavailable, warnedInferenceError, DEFAULT_MODEL, importModule;
 var init_transformersjs_embed = __esm({
   "../../packages/companion-core/src/node/transformersjs-embed.ts"() {
     "use strict";
+    init_optional_module();
     cached = null;
     loadPromise2 = null;
     loadFailedPermanently = false;
+    loadAttempts = 0;
+    warnedUnavailable = false;
+    warnedInferenceError = false;
     DEFAULT_MODEL = "Xenova/bge-small-en-v1.5";
+    importModule = (id) => import(
+      /* @vite-ignore */
+      id
+    );
   }
 });
 
@@ -45417,18 +46051,23 @@ async function createPrivacyFilterRedactor(opts = {}) {
   const device = opts.device ?? (isBrowser ? "webgpu" : "cpu");
   const dtype = opts.dtype ?? "q4";
   const modelId = opts.model ?? "openai/privacy-filter";
+  const importModule2 = opts.importModule ?? ((id) => import(
+    /* @vite-ignore */
+    id
+  ));
   let cached2 = null;
   let loadPromise3 = null;
+  let loadFailedPermanently2 = false;
+  let loadAttempts2 = 0;
+  let warnedUnavailable2 = false;
+  let warnedInferenceError2 = false;
   async function loadPipeline2() {
     if (cached2) return cached2;
+    if (loadFailedPermanently2) return null;
     if (!loadPromise3) {
       loadPromise3 = (async () => {
         try {
-          const moduleId = "@huggingface/transformers";
-          const tjs = await import(
-            /* @vite-ignore */
-            moduleId
-          );
+          const tjs = await importModule2("@huggingface/transformers");
           const p = await tjs.pipeline("token-classification", modelId, {
             device,
             dtype,
@@ -45438,10 +46077,17 @@ async function createPrivacyFilterRedactor(opts = {}) {
           return p;
         } catch (err) {
           loadPromise3 = null;
-          console.warn(
-            "[privacy-filter] adapter unavailable \u2014 install @huggingface/transformers in the consuming package to enable model-based redaction. Falling back to pass-through.",
-            err.message
-          );
+          loadAttempts2 += 1;
+          if (isMissingOptionalModuleError(err) || loadAttempts2 >= OPTIONAL_MODULE_MAX_LOAD_ATTEMPTS) {
+            loadFailedPermanently2 = true;
+          }
+          if (!warnedUnavailable2) {
+            warnedUnavailable2 = true;
+            console.warn(
+              "[privacy-filter] adapter unavailable \u2014 install @huggingface/transformers in the consuming package to enable model-based redaction. Falling back to pass-through (warning once).",
+              err.message
+            );
+          }
           return null;
         }
       })();
@@ -45464,10 +46110,13 @@ async function createPrivacyFilterRedactor(opts = {}) {
     try {
       tokens = await classify(text);
     } catch (err) {
-      console.warn(
-        "[privacy-filter] inference failed, returning input unchanged:",
-        err.message
-      );
+      if (!warnedInferenceError2) {
+        warnedInferenceError2 = true;
+        console.warn(
+          "[privacy-filter] inference failed, returning input unchanged (warning once):",
+          err.message
+        );
+      }
       return empty;
     }
     const spans = [];
@@ -45504,6 +46153,7 @@ async function createPrivacyFilterRedactor(opts = {}) {
 var init_privacy_filter = __esm({
   "../../packages/companion-core/src/redact/privacy-filter.ts"() {
     "use strict";
+    init_optional_module();
   }
 });
 
@@ -45613,9 +46263,9 @@ async function scanAll(cb = {}) {
         const full = join5(dir, f);
         jobs.push({
           path: full,
-          parse: async () => {
-            const r = await parseClaudeCodeJsonl({ deviceId, sourceFile: full });
-            return { events: r.events, path: full };
+          parse: async (sink2) => {
+            const r = await parseClaudeCodeJsonl({ deviceId, sourceFile: full, onEvents: sink2 });
+            return { toolCalls: r.toolCalls ?? [] };
           }
         });
       }
@@ -45637,9 +46287,9 @@ async function scanAll(cb = {}) {
             const full = join5(base, y, m, d, f);
             jobs.push({
               path: full,
-              parse: async () => {
-                const r = await parseCodexRollout({ deviceId, sourceFile: full });
-                return { events: r.events, path: full };
+              parse: async (sink2) => {
+                const r = await parseCodexRollout({ deviceId, sourceFile: full, onEvents: sink2 });
+                return { toolCalls: r.toolCalls ?? [] };
               }
             });
           }
@@ -45655,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) {
@@ -45682,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 });
@@ -45692,8 +46347,26 @@ 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) => {
+    for (const e of events) {
+      buffer.push(e);
+      if (buffer.length >= BATCH_MAX_EVENTS) await flushBatch();
+    }
+    if (buffer.length > BATCH_BUFFER_HARD_CAP) {
+      throw new Error(
+        `scan event buffer exceeded ${BATCH_BUFFER_HARD_CAP} events \u2014 incremental batch flushing has regressed (see BATCH_BUFFER_HARD_CAP)`
+      );
+    }
+  };
+  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);
@@ -45705,13 +46378,8 @@ async function scanAll(cb = {}) {
     }
     filesScanned += 1;
     try {
-      const r = await job.parse();
-      if (r.events.length) {
-        for (const e of r.events) {
-          buffer.push(e);
-          if (buffer.length >= BATCH_MAX_EVENTS) await flushBatch();
-        }
-      }
+      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);
@@ -45720,17 +46388,20 @@ async function scanAll(cb = {}) {
   await flushBatch();
   return { filesScanned, filesUnchanged, batchesUploaded, eventsUploaded, segmentsUploaded };
 }
-var AGENT_VERSION, BATCH_MAX_EVENTS, 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.45" : "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,
       output: 0,
@@ -45766,9 +46437,9 @@ function isProcessAlive(pid) {
     return false;
   }
 }
-function readLock() {
+function readDaemonLock(lockFile = LOCK_FILE) {
   try {
-    const raw = readFileSync4(LOCK_FILE, "utf8");
+    const raw = readFileSync4(lockFile, "utf8");
     const obj = JSON.parse(raw);
     if (typeof obj.pid !== "number") return null;
     return {
@@ -45793,7 +46464,7 @@ function writeLockAtomic(meta) {
   renameSync2(tmp, LOCK_FILE);
 }
 function removeLockIfOwned(ownerPid) {
-  const lock = readLock();
+  const lock = readDaemonLock();
   if (!lock) return;
   if (lock.pid !== ownerPid) return;
   try {
@@ -45802,7 +46473,7 @@ function removeLockIfOwned(ownerPid) {
   }
 }
 function acquireDaemonLock(opts) {
-  const existing = readLock();
+  const existing = readDaemonLock();
   if (existing && isProcessAlive(existing.pid)) {
     if (!opts.force) {
       const ageSec = ageInSeconds(existing.startedAt);
@@ -45820,6 +46491,20 @@ function acquireDaemonLock(opts) {
     apiUrl: opts.apiUrl
   };
   writeLockAtomic(meta);
+  const recheck = setTimeout(() => {
+    const current = readDaemonLock();
+    if (checkLockOwnership(process.pid, current) !== "lost") return;
+    const winner = current;
+    if (opts.onLockLost) {
+      opts.onLockLost(winner);
+      return;
+    }
+    console.log(
+      `[modelstat] another daemon (pid ${winner.pid}, started ${winner.startedAt}) won the lock race \u2014 this instance is standing down.`
+    );
+    process.exit(0);
+  }, LOCK_RECHECK_MS);
+  recheck.unref();
   const cleanup = () => removeLockIfOwned(process.pid);
   process.once("beforeExit", cleanup);
   process.once("SIGINT", () => {
@@ -45837,6 +46522,11 @@ function acquireDaemonLock(opts) {
   });
   return { kind: "acquired" };
 }
+function checkLockOwnership(myPid, current, pidAlive = isProcessAlive) {
+  if (!current || current.pid === myPid) return "owned";
+  if (!pidAlive(current.pid)) return "winner_dead";
+  return "lost";
+}
 function ageInSeconds(iso) {
   const t = Date.parse(iso);
   if (Number.isNaN(t)) return -1;
@@ -45851,12 +46541,13 @@ function formatAge(seconds) {
   const h = Math.floor(m / 60);
   return `${h}h ${m % 60}m`;
 }
-var LOCK_DIR, LOCK_FILE;
+var LOCK_DIR, LOCK_FILE, LOCK_RECHECK_MS;
 var init_lock = __esm({
   "src/lock.ts"() {
     "use strict";
     LOCK_DIR = join7(homedir7(), ".modelstat");
     LOCK_FILE = join7(LOCK_DIR, "daemon.lock");
+    LOCK_RECHECK_MS = 5e3;
   }
 });
 
@@ -45920,7 +46611,7 @@ var PROCESSING_VERSION;
 var init_processing_version = __esm({
   "src/processing-version.ts"() {
     "use strict";
-    PROCESSING_VERSION = 4;
+    PROCESSING_VERSION = 5;
   }
 });
 
@@ -47730,17 +48421,44 @@ async function sendHeartbeat() {
   }
   writeLocalStatus(body).catch(() => void 0);
 }
+async function rotateRunawayLogs() {
+  const { homedir: homedir10 } = await import("os");
+  const { join: join12 } = await import("path");
+  const { open: open2, stat: stat6, truncate, writeFile } = await import("fs/promises");
+  const dir = join12(homedir10(), ".modelstat", "logs");
+  for (const name of ["out.log", "err.log"]) {
+    const p = join12(dir, name);
+    try {
+      const st = await stat6(p);
+      if (st.size <= LOG_MAX_BYTES) continue;
+      const keep = Math.min(LOG_TAIL_KEEP_BYTES, st.size);
+      const fh = await open2(p, "r");
+      try {
+        const buf = Buffer.alloc(keep);
+        await fh.read(buf, 0, keep, st.size - keep);
+        await writeFile(p.replace(/\.log$/, ".old.log"), buf);
+      } finally {
+        await fh.close();
+      }
+      await truncate(p, 0);
+      console.log(
+        `[modelstat] rotated ${name}: was ${(st.size / 1024 / 1024).toFixed(0)} MB (> ${LOG_MAX_BYTES / 1024 / 1024} MB cap), tail kept in ${name.replace(/\.log$/, ".old.log")}`
+      );
+    } catch {
+    }
+  }
+}
 async function writeLocalStatus(snapshot) {
-  const { homedir: homedir9 } = await import("os");
-  const { join: join11 } = await import("path");
+  const { homedir: homedir10 } = await import("os");
+  const { join: join12 } = await import("path");
   const { writeFile, mkdir: mkdir2, rename } = await import("fs/promises");
   if (!lastStatusPath) {
-    const dir = join11(homedir9(), ".modelstat");
+    const dir = join12(homedir10(), ".modelstat");
     try {
       await mkdir2(dir, { recursive: true });
     } catch {
     }
-    lastStatusPath = join11(dir, "last-status.json");
+    lastStatusPath = join12(dir, "last-status.json");
   }
   const tmp = `${lastStatusPath}.tmp`;
   try {
@@ -47822,7 +48540,17 @@ async function runDaemon(opts = {}) {
   const lock = acquireDaemonLock({
     agentVersion: AGENT_VERSION2,
     apiUrl: state.apiUrl,
-    force: opts.force === true
+    force: opts.force === true,
+    // If a racing daemon out-renamed us for the lock (see lock.ts
+    // recheck), stand down with exit 0: our supervisor's next health
+    // check sees the winner and adopts it instead of respawning us.
+    onLockLost: (winner) => {
+      setPhase("offline", `another daemon (pid ${winner.pid}) owns the lock \u2014 standing down`);
+      console.log(
+        `[modelstat] another daemon (pid ${winner.pid}, started ${winner.startedAt}) won the lock race \u2014 this instance is standing down.`
+      );
+      process.exit(0);
+    }
   });
   if (lock.kind === "already_running") {
     console.log(
@@ -47839,6 +48567,7 @@ async function runDaemon(opts = {}) {
     return;
   }
   setPhase("starting", "Booting");
+  await rotateRunawayLogs();
   setStat("segments_sent", state.segmentsSent);
   const hb = setInterval(() => void sendHeartbeat(), HEARTBEAT_INTERVAL_MS);
   hb.unref();
@@ -47862,19 +48591,19 @@ async function runDaemon(opts = {}) {
   await runDiscovery();
   await requestScan("startup");
   const chokidar = (await Promise.resolve().then(() => (init_esm2(), esm_exports))).default;
-  const { homedir: homedir9, platform: platform5 } = await import("os");
-  const { join: join11 } = await import("path");
-  const home2 = homedir9();
+  const { homedir: homedir10, platform: platform5 } = await import("os");
+  const { join: join12 } = await import("path");
+  const home2 = homedir10();
   const dirs = [
-    join11(home2, ".claude/projects"),
-    join11(home2, ".codex/sessions"),
-    join11(home2, ".cursor/ai-tracking"),
-    join11(home2, ".gemini"),
+    join12(home2, ".claude/projects"),
+    join12(home2, ".codex/sessions"),
+    join12(home2, ".cursor/ai-tracking"),
+    join12(home2, ".gemini"),
     ...platform5() === "darwin" ? [
-      join11(home2, "Library/Application Support/Cursor/User/workspaceStorage"),
-      join11(home2, "Library/Application Support/Claude")
+      join12(home2, "Library/Application Support/Cursor/User/workspaceStorage"),
+      join12(home2, "Library/Application Support/Claude")
     ] : [
-      join11(home2, ".config/Cursor/User/workspaceStorage")
+      join12(home2, ".config/Cursor/User/workspaceStorage")
     ]
   ].filter((p) => existsSync9(p) && statSync2(p).isDirectory());
   setPhase("watching", `Watching ${dirs.length} directories`);
@@ -47917,7 +48646,7 @@ async function runDaemon(opts = {}) {
   await new Promise(() => {
   });
 }
-var import_undici2, AGENT_VERSION2, HEARTBEAT_INTERVAL_MS, SCAN_INTERVAL_MS, DISCOVERY_INTERVAL_MS, status, LOCAL_FLUSH_THROTTLE_MS, localFlushTimer, localFlushPending, lastStatusPath, scanRunner;
+var import_undici2, AGENT_VERSION2, HEARTBEAT_INTERVAL_MS, SCAN_INTERVAL_MS, DISCOVERY_INTERVAL_MS, status, LOCAL_FLUSH_THROTTLE_MS, localFlushTimer, localFlushPending, LOG_MAX_BYTES, LOG_TAIL_KEEP_BYTES, lastStatusPath, scanRunner;
 var init_daemon = __esm({
   "src/daemon.ts"() {
     "use strict";
@@ -47929,7 +48658,7 @@ var init_daemon = __esm({
     init_lock();
     init_scan();
     init_single_flight();
-    AGENT_VERSION2 = true ? "agent-0.0.45" : "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;
@@ -47945,6 +48674,8 @@ var init_daemon = __esm({
     LOCAL_FLUSH_THROTTLE_MS = 400;
     localFlushTimer = null;
     localFlushPending = false;
+    LOG_MAX_BYTES = 64 * 1024 * 1024;
+    LOG_TAIL_KEEP_BYTES = 4 * 1024 * 1024;
     lastStatusPath = null;
     scanRunner = createCoalescingRunner(runScanCycle);
   }
@@ -47956,33 +48687,33 @@ __export(watch_exports, {
   watchForever: () => watchForever
 });
 import { existsSync as existsSync10 } from "fs";
-import { homedir as homedir8, platform as platform3 } from "os";
-import { join as join10 } from "path";
+import { homedir as homedir9, platform as platform3 } from "os";
+import { join as join11 } from "path";
 function resolveWatchDirs() {
-  const home2 = homedir8();
-  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join10(home2, ".config");
-  const xdgData = process.env.XDG_DATA_HOME ?? join10(home2, ".local/share");
+  const home2 = homedir9();
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join11(home2, ".config");
+  const xdgData = process.env.XDG_DATA_HOME ?? join11(home2, ".local/share");
   const candidates = [
     // universal (default HOME-rooted CLI data dirs)
-    join10(home2, ".claude/projects"),
-    join10(home2, ".codex/sessions"),
-    join10(home2, ".cursor/ai-tracking"),
-    join10(home2, ".gemini"),
-    join10(home2, ".aider"),
+    join11(home2, ".claude/projects"),
+    join11(home2, ".codex/sessions"),
+    join11(home2, ".cursor/ai-tracking"),
+    join11(home2, ".gemini"),
+    join11(home2, ".aider"),
     // XDG / Linux
-    join10(xdgConfig, "claude/projects"),
-    join10(xdgConfig, "codex/sessions"),
-    join10(xdgConfig, "Cursor/User/workspaceStorage"),
-    join10(xdgConfig, "Code/User/workspaceStorage"),
-    join10(xdgConfig, "Code - Insiders/User/workspaceStorage"),
-    join10(xdgData, "claude/projects"),
+    join11(xdgConfig, "claude/projects"),
+    join11(xdgConfig, "codex/sessions"),
+    join11(xdgConfig, "Cursor/User/workspaceStorage"),
+    join11(xdgConfig, "Code/User/workspaceStorage"),
+    join11(xdgConfig, "Code - Insiders/User/workspaceStorage"),
+    join11(xdgData, "claude/projects"),
     // macOS
     ...platform3() === "darwin" ? [
-      join10(home2, "Library/Application Support/Cursor/User/workspaceStorage"),
-      join10(home2, "Library/Application Support/Claude"),
-      join10(home2, "Library/Application Support/Code/User/workspaceStorage"),
-      join10(home2, "Library/Application Support/Windsurf/User/workspaceStorage"),
-      join10(home2, "Library/Application Support/Zed")
+      join11(home2, "Library/Application Support/Cursor/User/workspaceStorage"),
+      join11(home2, "Library/Application Support/Claude"),
+      join11(home2, "Library/Application Support/Code/User/workspaceStorage"),
+      join11(home2, "Library/Application Support/Windsurf/User/workspaceStorage"),
+      join11(home2, "Library/Application Support/Zed")
     ] : []
   ];
   return Array.from(new Set(candidates)).filter((p) => existsSync10(p));
@@ -48047,13 +48778,13 @@ var init_watch = __esm({
 
 // src/cli.ts
 init_src2();
-init_identity();
 init_api();
 init_config2();
+init_identity();
 init_scan();
 import { spawn } from "child_process";
 import { randomBytes } from "crypto";
-import { platform as platform4, release, arch as cpuArch, hostname as hostname2 } from "os";
+import { arch as cpuArch, hostname as hostname2, platform as platform4, release } from "os";
 import { createInterface as createInterface3 } from "readline";
 
 // src/service.ts
@@ -48409,6 +49140,59 @@ function trayStatus() {
   return exe ? { installed: true, path: exe.replace(/\/Contents\/MacOS\/modelstat-tray$/, "") } : { installed: false, path: null };
 }
 
+// src/supervise.ts
+init_lock();
+import { readFileSync as readFileSync5 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join8 } from "path";
+var STATUS_FRESH_MS = 12e4;
+var BOOT_GRACE_MS = 9e4;
+function decideSupervision(input) {
+  const fresh = input.statusFreshMs ?? STATUS_FRESH_MS;
+  const grace = input.bootGraceMs ?? BOOT_GRACE_MS;
+  if (!input.lock || !input.ownerAlive) return "spawn";
+  if (input.myAgentVersion && input.lock.agentVersion !== "unknown" && input.lock.agentVersion !== input.myAgentVersion) {
+    return "replace";
+  }
+  if (input.statusAgeMs !== null && input.statusAgeMs <= fresh) return "adopt";
+  if (input.lockAgeMs !== null && input.lockAgeMs <= grace) return "adopt";
+  return "replace";
+}
+function daemonHealth(opts = {}) {
+  const now = opts.now ?? Date.now();
+  const pidAlive = opts.pidAlive ?? isProcessAlive;
+  const statusPath = opts.statusPath ?? join8(homedir8(), ".modelstat", "last-status.json");
+  const lock = opts.lockPath === void 0 ? readDaemonLock() : readDaemonLock(opts.lockPath);
+  const ownerAlive = lock !== null && pidAlive(lock.pid);
+  const lockAgeMs = lock ? ageMs(lock.startedAt, now) : null;
+  let statusAgeMs = null;
+  try {
+    const raw = readFileSync5(statusPath, "utf8");
+    const writtenAt = JSON.parse(raw).written_at;
+    statusAgeMs = writtenAt ? ageMs(writtenAt, now) : null;
+  } catch {
+    statusAgeMs = null;
+  }
+  return {
+    decision: decideSupervision({
+      lock,
+      ownerAlive,
+      lockAgeMs,
+      statusAgeMs,
+      myAgentVersion: opts.myAgentVersion
+    }),
+    lock,
+    ownerAlive,
+    lockAgeMs,
+    statusAgeMs
+  };
+}
+function ageMs(iso, now) {
+  const t = Date.parse(iso);
+  if (Number.isNaN(t)) return null;
+  return Math.max(0, now - t);
+}
+
 // src/cli.ts
 async function confirmPrompt(question, defaultYes) {
   if (process.stdin.isTTY !== true) return defaultYes;
@@ -48439,7 +49223,7 @@ function tryOpenBrowser(url) {
     return false;
   }
 }
-var AGENT_VERSION3 = true ? "agent-0.0.45" : "agent-dev";
+var AGENT_VERSION3 = true ? "agent-0.0.47" : "agent-dev";
 function osFamily() {
   const p = platform4();
   if (p === "darwin") return "macos";
@@ -48482,10 +49266,8 @@ async function cmdSelfRegister() {
     process.stdout.write(`  \x1B[2mgenerated UUIDv7 ${deviceUuid.slice(0, 8)}\u2026\x1B[0m
 `);
   }
-  process.stdout.write(
-    `  \x1B[2m\u2192 POST ${state.apiUrl}/v1/devices/self-register\x1B[0m
-`
-  );
+  process.stdout.write(`  \x1B[2m\u2192 POST ${state.apiUrl}/v1/devices/self-register\x1B[0m
+`);
   const res = await selfRegister({
     device_uuid: deviceUuid,
     fingerprint
@@ -48499,8 +49281,10 @@ async function cmdSelfRegister() {
   });
   process.stdout.write(`  \x1B[32m\u2713\x1B[0m registered  device_id=${res.device_id}
 `);
-  process.stdout.write(`  \x1B[32m\u2713\x1B[0m secret      ${res.secret_prefix}\u2026  (hashed on server, never re-sent)
-`);
+  process.stdout.write(
+    `  \x1B[32m\u2713\x1B[0m secret      ${res.secret_prefix}\u2026  (hashed on server, never re-sent)
+`
+  );
   process.stdout.write(`  \x1B[32m\u2713\x1B[0m claim code  ${res.claim_code}
 `);
 }
@@ -48533,10 +49317,8 @@ async function cmdAwaitClaim() {
 }
 function emitEvent(opts, event, fields = {}) {
   if (!opts.json) return;
-  process.stdout.write(
-    `${JSON.stringify({ v: 1, ts: Date.now(), event, ...fields })}
-`
-  );
+  process.stdout.write(`${JSON.stringify({ v: 1, ts: Date.now(), event, ...fields })}
+`);
 }
 async function cmdConnect(opts) {
   const step = (msg) => {
@@ -48639,9 +49421,7 @@ async function cmdConnect(opts) {
       error: e.message
     });
     warn(`couldn't prepare summariser model: ${e.message}`);
-    warn(
-      "the background service will retry the download on its first scan"
-    );
+    warn("the background service will retry the download on its first scan");
   }
   step("Installing/refreshing background service so the agent survives reboots");
   let serviceOk = false;
@@ -48657,9 +49437,7 @@ async function cmdConnect(opts) {
   } catch (e) {
     emitEvent(opts, "service_install_failed", { error: e.message });
     warn(`couldn't install service: ${e.message}`);
-    warn(
-      "the agent will not run in the background \u2014 re-run after fixing the issue"
-    );
+    warn("the agent will not run in the background \u2014 re-run after fixing the issue");
   }
   step("Detecting installed AI tools and signed-in accounts");
   let discovered = null;
@@ -48677,9 +49455,7 @@ async function cmdConnect(opts) {
         identities: d.identities.length
       };
       emitEvent(opts, "discovered", discovered);
-      ok(
-        `${discovered.installations} installs \xB7 ${discovered.identities} accounts`
-      );
+      ok(`${discovered.installations} installs \xB7 ${discovered.identities} accounts`);
     } catch (e) {
       emitEvent(opts, "discovery_failed", { error: e.message });
       warn(`couldn't detect accounts: ${e.message}`);
@@ -48775,9 +49551,7 @@ async function cmdRescan() {
   console.log(
     `[modelstat] cursors wiped \u2014 next \`modelstat scan\` (or daemon scan cycle) will re-read every JSONL from the start and re-summarise every session at processing version v${PROCESSING_VERSION2}.`
   );
-  console.log(
-    "  If the daemon is running, kick it with: modelstat stop && modelstat start"
-  );
+  console.log("  If the daemon is running, kick it with: modelstat stop && modelstat start");
 }
 async function cmdWatch() {
   const { watchForever: watchForever2 } = await Promise.resolve().then(() => (init_watch(), watch_exports));
@@ -48833,10 +49607,10 @@ function fmtTokens(v) {
 }
 async function readLocalStatus() {
   try {
-    const { homedir: homedir9 } = await import("os");
-    const { join: join11 } = await import("path");
+    const { homedir: homedir10 } = await import("os");
+    const { join: join12 } = await import("path");
     const { readFile } = await import("fs/promises");
-    const p = join11(homedir9(), ".modelstat", "last-status.json");
+    const p = join12(homedir10(), ".modelstat", "last-status.json");
     const txt = await readFile(p, "utf8");
     return JSON.parse(txt);
   } catch {
@@ -48879,7 +49653,9 @@ async function cmdStats(args) {
       console.log("device is claimed \u2014 live stats available at:");
       console.log(`  ${dashboard}`);
       if (local) {
-        console.log(`local agent: ${local.status ?? "?"}${local.message ? ` \xB7 ${local.message}` : ""}`);
+        console.log(
+          `local agent: ${local.status ?? "?"}${local.message ? ` \xB7 ${local.message}` : ""}`
+        );
         const stats = local.stats ?? {};
         for (const [k, v] of Object.entries(stats)) console.log(`  ${k}: ${v}`);
       }
@@ -48897,7 +49673,9 @@ async function cmdStats(args) {
   console.log(
     `status:   ${view.device.agent_status ?? "(unknown)"}${view.device.last_seen_at ? ` \xB7 last seen ${view.device.last_seen_at}` : ""}`
   );
-  console.log(`claim:    ${view.status}${view.status === "unclaimed" ? ` (at ${view.claim_url})` : ""}`);
+  console.log(
+    `claim:    ${view.status}${view.status === "unclaimed" ? ` (at ${view.claim_url})` : ""}`
+  );
   console.log(`sessions: ${fmtInt(view.analyzed.count)}`);
   console.log(`tokens:   ${fmtTokens(view.analyzed.totalTokens)}`);
   console.log(`cost:     ${fmtCost(view.analyzed.totalCostUsd)}`);
@@ -48922,10 +49700,8 @@ async function cmdJobs(args) {
   if (!jobs && !ledger) {
     const dashboard = `${state.apiUrl.replace(/\/$/, "")}/dashboard/jobs`;
     if (asJson) {
-      process.stdout.write(
-        `${JSON.stringify({ paired: true, claimed: true, dashboard })}
-`
-      );
+      process.stdout.write(`${JSON.stringify({ paired: true, claimed: true, dashboard })}
+`);
     } else {
       console.log("device is claimed \u2014 job queue at:");
       console.log(`  ${dashboard}`);
@@ -49015,6 +49791,14 @@ async function main() {
       console.log(`\u2713 runtime staged at ${dest}`);
       return;
     }
+    case "_daemon-health": {
+      try {
+        console.log(JSON.stringify(daemonHealth({ myAgentVersion: AGENT_VERSION3 })));
+      } catch (e) {
+        console.log(JSON.stringify({ decision: "spawn", error: e.message }));
+      }
+      return;
+    }
     // ── Diagnostics / dev one-shots ────────────────────────────
     case "status":
       return cmdStatus();
@@ -49042,10 +49826,18 @@ async function main() {
       return cmdAwaitClaim();
     default:
       console.log("usage:");
-      console.log("  npx modelstat@latest                \u2014 install or upgrade. Registers the device, installs the background service, exits.");
-      console.log("                                        flags: --json (NDJSON events on stdout), --no-browser, --fresh, -y");
-      console.log("  npx modelstat@latest remove         \u2014 stop and uninstall the background service. Keeps your identity.");
-      console.log("  npx modelstat@latest reinstall      \u2014 alias for the default. Useful when you want to be explicit.");
+      console.log(
+        "  npx modelstat@latest                \u2014 install or upgrade. Registers the device, installs the background service, exits."
+      );
+      console.log(
+        "                                        flags: --json (NDJSON events on stdout), --no-browser, --fresh, -y"
+      );
+      console.log(
+        "  npx modelstat@latest remove         \u2014 stop and uninstall the background service. Keeps your identity."
+      );
+      console.log(
+        "  npx modelstat@latest reinstall      \u2014 alias for the default. Useful when you want to be explicit."
+      );
       console.log();
       console.log("Diagnostics:");
       console.log("  npx modelstat@latest status         \u2014 show pairing + service state");
@@ -49056,11 +49848,17 @@ async function main() {
       console.log();
       console.log("Dev / one-shots:");
       console.log("  npx modelstat@latest scan           \u2014 one-shot parse + upload of local JSONL");
-      console.log("  npx modelstat@latest rescan         \u2014 wipe file cursors so the next scan re-reads & re-summarises everything");
-      console.log("  npx modelstat@latest watch          \u2014 continuous (chokidar) with periodic backstop");
+      console.log(
+        "  npx modelstat@latest rescan         \u2014 wipe file cursors so the next scan re-reads & re-summarises everything"
+      );
+      console.log(
+        "  npx modelstat@latest watch          \u2014 continuous (chokidar) with periodic backstop"
+      );
       console.log("  npx modelstat@latest discover       \u2014 one-shot report of installs/identities");
       console.log();
-      console.log("Internal (called by launchd/systemd, not by humans): _daemon, start, self-register, await-claim");
+      console.log(
+        "Internal (called by launchd/systemd, not by humans): _daemon, start, self-register, await-claim"
+      );
       process.exit(1);
   }
 }