@curdx/flow 7.1.5 → 7.1.7

package/dist/analyze-FX2PCSL6.mjs

@@ -0,0 +1,1956 @@
+#!/usr/bin/env node
+
+// src/analyze/index.ts
+import { existsSync, mkdirSync, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync3, writeFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import path4 from "path";
+
+// src/analyze/pricing.ts
+var PRICING = {
+  "claude-opus-4-7": {
+    inputPerMTok: 5,
+    outputPerMTok: 25,
+    cacheReadMul: 0.1,
+    cache5mWriteMul: 1.25,
+    cache1hWriteMul: 2
+  },
+  "claude-sonnet-4-6": {
+    inputPerMTok: 3,
+    outputPerMTok: 15,
+    cacheReadMul: 0.1,
+    cache5mWriteMul: 1.25,
+    cache1hWriteMul: 2
+  },
+  "claude-haiku-4-5-20251001": {
+    inputPerMTok: 1,
+    outputPerMTok: 5,
+    cacheReadMul: 0.1,
+    cache5mWriteMul: 1.25,
+    cache1hWriteMul: 2
+  }
+};
+var MODEL_ALIASES = {
+  "claude-haiku-4-5": "claude-haiku-4-5-20251001"
+};
+function resolveModelId(modelStr) {
+  if (!modelStr) return void 0;
+  const aliased = MODEL_ALIASES[modelStr];
+  if (aliased && aliased in PRICING) return aliased;
+  if (modelStr in PRICING) return modelStr;
+  return void 0;
+}
+
+// src/analyze/cost.ts
+function round4(usd) {
+  return Math.round(usd * 1e4) / 1e4;
+}
+function computeCost(row) {
+  const canonical = resolveModelId(row.model);
+  if (!canonical) return 0;
+  const price = PRICING[canonical];
+  if (!price) return 0;
+  const input = row.inputTokens ?? 0;
+  const output = row.outputTokens ?? 0;
+  const cacheRead = row.cacheReadTokens ?? 0;
+  const cache5m = row.cacheCreate5mTokens ?? 0;
+  const cache1h = row.cacheCreate1hTokens ?? 0;
+  const usd = (input * price.inputPerMTok + cache5m * price.cache5mWriteMul * price.inputPerMTok + cache1h * price.cache1hWriteMul * price.inputPerMTok + cacheRead * price.cacheReadMul * price.inputPerMTok + output * price.outputPerMTok) / 1e6;
+  return round4(usd);
+}
+function readNumber(obj, dottedPath) {
+  if (!obj) return 0;
+  const parts = dottedPath.split(".");
+  let cur = obj;
+  for (const p of parts) {
+    if (cur && typeof cur === "object" && p in cur) {
+      cur = cur[p];
+    } else {
+      return 0;
+    }
+  }
+  return typeof cur === "number" && Number.isFinite(cur) ? cur : 0;
+}
+function readString(obj, dottedPath) {
+  if (!obj) return void 0;
+  const parts = dottedPath.split(".");
+  let cur = obj;
+  for (const p of parts) {
+    if (cur && typeof cur === "object" && p in cur) {
+      cur = cur[p];
+    } else {
+      return void 0;
+    }
+  }
+  return typeof cur === "string" ? cur : void 0;
+}
+var TRAILER_RE = /<usage>[\s\S]*?total_tokens:\s*(\d+)[\s\S]*?tool_uses:\s*(\d+)[\s\S]*?duration_ms:\s*(\d+)[\s\S]*?<\/usage>/g;
+function extractTrailerUsage(text, parent) {
+  try {
+    if (typeof text !== "string" || text.length === 0) return [];
+    const rows = [];
+    TRAILER_RE.lastIndex = 0;
+    let m;
+    while ((m = TRAILER_RE.exec(text)) !== null) {
+      const totalTokens = parseInt(m[1] ?? "0", 10);
+      const durationMs = parseInt(m[3] ?? "0", 10);
+      rows.push({
+        ts: parent.ts,
+        requestId: parent.requestId,
+        correlationId: parent.correlationId,
+        model: "unknown",
+        inputTokens: 0,
+        outputTokens: Number.isFinite(totalTokens) ? totalTokens : 0,
+        cacheReadTokens: 0,
+        cacheCreate5mTokens: 0,
+        cacheCreate1hTokens: 0,
+        durationMs: Number.isFinite(durationMs) ? durationMs : 0,
+        source: "subagent_trailer"
+      });
+    }
+    return rows;
+  } catch {
+    return [];
+  }
+}
+function extractUsageRowsFromEvents(events, errorEntries) {
+  const rows = [];
+  if (!Array.isArray(events)) return rows;
+  for (const ev of events) {
+    try {
+      if (!ev) continue;
+      try {
+        const payloadAny = ev.payload;
+        const message = payloadAny?.["message"];
+        const outerContent = message?.["content"];
+        if (Array.isArray(outerContent)) {
+          for (const item of outerContent) {
+            const inner = item?.["content"];
+            if (!Array.isArray(inner)) continue;
+            for (const seg of inner) {
+              const text = seg?.["text"];
+              if (typeof text !== "string" || text.length === 0) continue;
+              const trailerRows = extractTrailerUsage(text, {
+                ts: ev.ts,
+                requestId: ev.requestId ?? "",
+                correlationId: readString(payloadAny, "correlationId")
+              });
+              if (trailerRows.length > 0) rows.push(...trailerRows);
+            }
+          }
+        }
+      } catch {
+      }
+      if (ev.kind !== "assistant_turn") continue;
+      const payload = ev.payload;
+      const model = readString(payload, "message.model");
+      const canonical = resolveModelId(model);
+      if (!canonical) continue;
+      const usage = payload?.["message"]?.["usage"];
+      const inputTokens = readNumber(usage, "input_tokens");
+      const outputTokens = readNumber(usage, "output_tokens");
+      const cacheReadTokens = readNumber(usage, "cache_read_input_tokens");
+      let cacheCreate5mTokens = readNumber(usage, "cache_creation.ephemeral_5m_input_tokens");
+      let cacheCreate1hTokens = readNumber(usage, "cache_creation.ephemeral_1h_input_tokens");
+      if (cacheCreate5mTokens === 0 && cacheCreate1hTokens === 0) {
+        const legacy = readNumber(usage, "cache_creation_input_tokens");
+        if (legacy > 0) cacheCreate5mTokens = legacy;
+      }
+      const requestId = ev.requestId ?? readString(payload, "message.id") ?? readString(payload, "requestId") ?? "";
+      const correlationId = readString(payload, "correlationId");
+      const isSidechain = payload?.["isSidechain"] ?? void 0;
+      rows.push({
+        ts: ev.ts,
+        requestId,
+        uuid: ev.uuid,
+        model: canonical,
+        inputTokens,
+        outputTokens,
+        cacheReadTokens,
+        cacheCreate5mTokens,
+        cacheCreate1hTokens,
+        correlationId,
+        isSidechain,
+        source: "assistant"
+      });
+    } catch {
+      continue;
+    }
+  }
+  return rows;
+}
+function parseCorrelationId(cid) {
+  if (typeof cid !== "string" || cid.length === 0) return {};
+  const parts = cid.split(":");
+  if (parts.length !== 3) return {};
+  const [sid, task, iter] = parts;
+  if (!sid || !task || !iter) return {};
+  return { sid, task, iter };
+}
+function aggregateBy(rows, level, ctx) {
+  try {
+    if (!Array.isArray(rows) || rows.length === 0) return [];
+    const specPhaseMap = ctx?.specPhaseMap ?? {};
+    const buckets = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      if (!row) continue;
+      const parsed = parseCorrelationId(row.correlationId);
+      let key;
+      let specHint;
+      let phaseHint;
+      if (level === "spec") {
+        key = parsed.sid ?? "unknown";
+        specHint = parsed.sid;
+      } else if (level === "phase") {
+        key = (parsed.sid && specPhaseMap[parsed.sid]) ?? "unknown";
+        specHint = parsed.sid;
+        phaseHint = parsed.sid ? specPhaseMap[parsed.sid] : void 0;
+      } else {
+        key = row.correlationId ?? "unknown";
+        specHint = parsed.sid;
+        phaseHint = parsed.sid ? specPhaseMap[parsed.sid] : void 0;
+      }
+      let bucket = buckets.get(key);
+      if (!bucket) {
+        bucket = {
+          level,
+          key,
+          totalUSD: 0,
+          inputTokens: 0,
+          outputTokens: 0,
+          cacheReadTokens: 0,
+          cacheCreate5mTokens: 0,
+          cacheCreate1hTokens: 0,
+          rowCount: 0,
+          trailerCount: 0,
+          durationMs: 0,
+          modelMix: {},
+          spec: specHint,
+          phase: phaseHint
+        };
+        buckets.set(key, bucket);
+      }
+      const usd = computeCost(row);
+      bucket.totalUSD += usd;
+      bucket.inputTokens += row.inputTokens ?? 0;
+      bucket.outputTokens += row.outputTokens ?? 0;
+      bucket.cacheReadTokens += row.cacheReadTokens ?? 0;
+      bucket.cacheCreate5mTokens += row.cacheCreate5mTokens ?? 0;
+      bucket.cacheCreate1hTokens += row.cacheCreate1hTokens ?? 0;
+      bucket.rowCount += 1;
+      if (row.source === "subagent_trailer") bucket.trailerCount += 1;
+      bucket.durationMs += row.durationMs ?? 0;
+      const modelKey = row.model || "unknown";
+      const mix = bucket.modelMix[modelKey] ?? { tokens: 0, usd: 0 };
+      mix.tokens += (row.inputTokens ?? 0) + (row.outputTokens ?? 0);
+      mix.usd += usd;
+      bucket.modelMix[modelKey] = mix;
+    }
+    const out = Array.from(buckets.values()).map((b) => ({
+      ...b,
+      totalUSD: Math.round(b.totalUSD * 1e4) / 1e4
+    }));
+    out.sort((a, b) => b.totalUSD - a.totalUSD);
+    return out;
+  } catch {
+    return [];
+  }
+}
+
+// src/analyze/filter.ts
+function parseSince(since) {
+  if (!since) return void 0;
+  const m = /^(\d+)d$/.exec(since);
+  if (m) {
+    const days = Number(m[1]);
+    return new Date(Date.now() - days * 24 * 60 * 60 * 1e3);
+  }
+  const d = new Date(since);
+  if (!Number.isNaN(d.getTime())) return d;
+  return void 0;
+}
+function filterEvents(events, opts) {
+  const sinceDate = parseSince(opts.since);
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const ev of events) {
+    if (sinceDate && ev.ts) {
+      const evDate = new Date(ev.ts);
+      if (!Number.isNaN(evDate.getTime()) && evDate < sinceDate) continue;
+    }
+    const dedupeKey = computeDedupeKey(ev);
+    if (dedupeKey !== void 0) {
+      if (seen.has(dedupeKey)) continue;
+      seen.add(dedupeKey);
+    }
+    void opts.project;
+    out.push(ev);
+  }
+  out.sort((a, b) => a.ts < b.ts ? 1 : a.ts > b.ts ? -1 : 0);
+  if (typeof opts.limit === "number" && opts.limit > 0) {
+    return out.slice(0, opts.limit);
+  }
+  return out;
+}
+function computeDedupeKey(ev) {
+  if (ev.uuid && ev.requestId) return `${ev.uuid}|${ev.requestId}`;
+  if (ev.uuid) return ev.uuid;
+  return void 0;
+}
+
+// src/analyze/parser.ts
+import { createReadStream, readFileSync, statSync } from "fs";
+import readline from "readline";
+import path from "path";
+import { fileURLToPath } from "url";
+var BUILTIN_KIND_MAP = {
+  hook_success: "hook_invocation",
+  attachment: "hook_invocation",
+  // overridden by attachment.type when present
+  tool_use: "tool_call",
+  assistant: "assistant_turn",
+  user: "user_turn"
+};
+var BUILTIN_SCHEMA_MAP = {
+  hook_success: {
+    action: "hook_invocation",
+    fields: ["hookName", "hookEvent", "exitCode", "durationMs", "stderr"],
+    stderrMaxBytes: 500
+  },
+  tool_use: {
+    action: "tool_call",
+    fields: ["name", "input.subagent_type"],
+    filter: { name: ["Agent", "Task"] }
+  },
+  assistant: {
+    action: "assistant_turn",
+    fields: ["attributionPlugin", "attributionSkill"]
+  },
+  user: {
+    action: "user_turn",
+    fields: ["content"],
+    extractCommandName: true
+  }
+};
+function loadSchemaMap(schemaPath) {
+  const candidates = [];
+  if (schemaPath) candidates.push(schemaPath);
+  try {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    candidates.push(
+      path.resolve(here, "..", "..", "plugins", "curdx-flow", "schemas", "transcript-events.json"),
+      path.resolve(here, "..", "plugins", "curdx-flow", "schemas", "transcript-events.json")
+    );
+  } catch {
+  }
+  candidates.push(
+    path.resolve(process.cwd(), "plugins", "curdx-flow", "schemas", "transcript-events.json")
+  );
+  for (const candidate of candidates) {
+    try {
+      const raw = readFileSync(candidate, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object" && parsed.events && typeof parsed.events === "object") {
+        const out = {};
+        for (const [type, def] of Object.entries(parsed.events)) {
+          if (!def || typeof def !== "object") continue;
+          const d = def;
+          if (typeof d.action !== "string") continue;
+          out[type] = {
+            action: d.action,
+            fields: Array.isArray(d.fields) ? d.fields.filter((f) => typeof f === "string") : [],
+            ...d.filter && typeof d.filter === "object" ? { filter: d.filter } : {},
+            ...typeof d.extractCommandName === "boolean" ? { extractCommandName: d.extractCommandName } : {},
+            ...typeof d.stderrMaxBytes === "number" ? { stderrMaxBytes: d.stderrMaxBytes } : {}
+          };
+        }
+        if (Object.keys(out).length > 0) return out;
+      }
+      process.stderr.write(`[analyze] schema map at ${candidate} malformed, trying next probe
+`);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT") continue;
+      process.stderr.write(`[analyze] schema map probe failed at ${candidate}: ${err.message}
+`);
+    }
+  }
+  process.stderr.write("[analyze] schema map not found, using builtin fallback\n");
+  return BUILTIN_SCHEMA_MAP;
+}
+var ACTION_TO_KIND = {
+  hook_invocation: "hook_invocation",
+  tool_call: "tool_call",
+  assistant_turn: "assistant_turn",
+  user_turn: "user_turn"
+};
+function classify(raw, schemaMap) {
+  const top = typeof raw.type === "string" ? raw.type : void 0;
+  if (!top) return void 0;
+  let effectiveType = top;
+  if (top === "attachment" && raw.attachment && typeof raw.attachment === "object") {
+    const att = raw.attachment;
+    if (typeof att.type === "string") effectiveType = att.type;
+  }
+  if (schemaMap && schemaMap[effectiveType]) {
+    const action = schemaMap[effectiveType]?.action;
+    if (action) {
+      const kind = ACTION_TO_KIND[action];
+      return kind ?? "unknown";
+    }
+  }
+  return BUILTIN_KIND_MAP[effectiveType];
+}
+function pickString(raw, key) {
+  const v = raw[key];
+  return typeof v === "string" ? v : void 0;
+}
+async function* parseTranscript(path5, startOffset, schemaMap, counters) {
+  const localCounters = counters ?? { unknown_type: 0, parse_error: 0, processed: 0 };
+  const stream = createReadStream(path5, { encoding: "utf8", start: startOffset });
+  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+  for await (const line of rl) {
+    if (!line) continue;
+    let raw;
+    try {
+      raw = JSON.parse(line);
+    } catch {
+      localCounters.parse_error += 1;
+      continue;
+    }
+    const kind = classify(raw, schemaMap);
+    if (!kind) {
+      localCounters.unknown_type += 1;
+      continue;
+    }
+    localCounters.processed += 1;
+    const ts = pickString(raw, "timestamp") ?? pickString(raw, "ts") ?? "";
+    const uuid = pickString(raw, "uuid");
+    const requestId = pickString(raw, "requestId");
+    const cwd = pickString(raw, "cwd");
+    yield {
+      kind,
+      ts,
+      ...uuid !== void 0 ? { uuid } : {},
+      ...requestId !== void 0 ? { requestId } : {},
+      ...cwd !== void 0 ? { cwd } : {},
+      payload: raw
+    };
+  }
+}
+function getStateForPath(path5) {
+  const st = statSync(path5);
+  return {
+    byteOffset: st.size,
+    lastModifiedMs: st.mtimeMs,
+    sizeBytes: st.size
+  };
+}
+function shouldRotate(prev, current) {
+  if (!prev) return false;
+  if (current.sizeBytes < prev.sizeBytes) return true;
+  if (current.lastModifiedMs < prev.lastModifiedMs) return true;
+  return false;
+}
+
+// src/analyze/recommend.ts
+var REC_THRESHOLDS = {
+  cacheHitWarn: 0.6,
+  cacheHitSev: 0.3,
+  outputTokWarn: 8e3,
+  outputTokSev: 16e3,
+  hitCapWarn: 0.1,
+  hitCapSev: 0.2,
+  opusMixWarn: 0.3,
+  opusMixSev: 0.5,
+  madZ: 3.5,
+  wallClockWarn: 1.5,
+  wallClockSev: 2,
+  cacheChurnWarn: 1,
+  cacheChurnSev: 3,
+  retryWarn: 3,
+  retrySev: 5,
+  madMinN: 10
+};
+var CRITICAL_PHASES = [
+  "critical",
+  "debug-hard",
+  "security"
+];
+var MIN_N = 10;
+var Z_THRESHOLD = 3.5;
+var SCALE = 0.6745;
+function median(sorted) {
+  const n = sorted.length;
+  const m = n >> 1;
+  if (n === 0) return 0;
+  return n % 2 ? sorted[m] : (sorted[m - 1] + sorted[m]) / 2;
+}
+function modifiedZScore(values) {
+  if (values.length < MIN_N) return values.map(() => 0);
+  const sorted = [...values].sort((a, b) => a - b);
+  const med = median(sorted);
+  const devs = values.map((v) => Math.abs(v - med));
+  const mad = median([...devs].sort((a, b) => a - b));
+  if (mad === 0) return values.map(() => 0);
+  return values.map((v) => SCALE * (v - med) / mad);
+}
+function findOutliers(values) {
+  const z = modifiedZScore(values);
+  const out = [];
+  for (let i = 0; i < z.length; i++) {
+    const zi = z[i];
+    if (zi !== void 0 && Math.abs(zi) > Z_THRESHOLD) out.push(i);
+  }
+  return out;
+}
+function bucketScope(b) {
+  if (b.level === "spec") return { spec: b.key };
+  if (b.level === "phase") {
+    const out2 = {};
+    if (b.spec !== void 0) out2.spec = b.spec;
+    out2.phase = b.phase ?? b.key;
+    return out2;
+  }
+  const out = { task: b.key };
+  if (b.spec !== void 0) out.spec = b.spec;
+  if (b.phase !== void 0) out.phase = b.phase;
+  return out;
+}
+function pct(n) {
+  return `${(n * 100).toFixed(1)}%`;
+}
+function isOpusModel(modelId) {
+  return modelId.toLowerCase().includes("opus");
+}
+function ruleCacheHitLow(buckets) {
+  const out = [];
+  for (const b of buckets) {
+    try {
+      const denom = b.cacheReadTokens + b.cacheCreate5mTokens + b.cacheCreate1hTokens + b.inputTokens;
+      if (denom <= 0) {
+        out.push({
+          rule: "cache-hit-low",
+          severity: "insufficient_data",
+          scope: bucketScope(b),
+          message: `cache-hit-low: n=0 input-side tokens; \u6570\u636E\u4E0D\u8DB3\u4EE5\u5224\u65AD`,
+          evidence: { cacheRead: 0, cacheCreate5m: 0, cacheCreate1h: 0, inputTokens: 0 }
+        });
+        continue;
+      }
+      const hit = b.cacheReadTokens / denom;
+      let severity = null;
+      if (hit < REC_THRESHOLDS.cacheHitSev) severity = "sev";
+      else if (hit < REC_THRESHOLDS.cacheHitWarn) severity = "warn";
+      else severity = "info";
+      if (severity === "info" && hit < REC_THRESHOLDS.cacheHitWarn) continue;
+      out.push({
+        rule: "cache-hit-low",
+        severity,
+        scope: bucketScope(b),
+        message: severity === "info" ? `cache-hit-low: ${pct(hit)} \u2265 ${pct(REC_THRESHOLDS.cacheHitWarn)} (healthy); cache discipline is paying off` : `cache-hit-low: ${pct(hit)} < ${pct(severity === "sev" ? REC_THRESHOLDS.cacheHitSev : REC_THRESHOLDS.cacheHitWarn)} threshold; suggest extracting constants/prompts to system prompt to widen cache surface`,
+        evidence: {
+          cacheRead: b.cacheReadTokens,
+          cacheCreate5m: b.cacheCreate5mTokens,
+          cacheCreate1h: b.cacheCreate1hTokens,
+          inputTokens: b.inputTokens,
+          hitRate: hit
+        }
+      });
+    } catch {
+    }
+  }
+  return out;
+}
+function ruleOutputTokHigh(buckets) {
+  const out = [];
+  for (const b of buckets) {
+    if (b.level !== "task") continue;
+    try {
+      if (b.rowCount <= 0) {
+        out.push({
+          rule: "output-tok-high",
+          severity: "insufficient_data",
+          scope: bucketScope(b),
+          message: `output-tok-high: rowCount=0; \u6570\u636E\u4E0D\u8DB3\u4EE5\u5224\u65AD`,
+          evidence: { outputTokens: b.outputTokens, rowCount: 0 }
+        });
+        continue;
+      }
+      const avg = b.outputTokens / b.rowCount;
+      let severity = null;
+      if (avg > REC_THRESHOLDS.outputTokSev) severity = "sev";
+      else if (avg > REC_THRESHOLDS.outputTokWarn) severity = "warn";
+      if (!severity) continue;
+      out.push({
+        rule: "output-tok-high",
+        severity,
+        scope: bucketScope(b),
+        message: `output-tok-high: avg ${Math.round(avg)} output tok/turn > ${severity === "sev" ? REC_THRESHOLDS.outputTokSev : REC_THRESHOLDS.outputTokWarn} threshold; suggest splitting task or capping max_tokens`,
+        evidence: {
+          avgOutputTokens: avg,
+          totalOutputTokens: b.outputTokens,
+          rowCount: b.rowCount
+        }
+      });
+    } catch {
+    }
+  }
+  return out;
+}
+function ruleHitCapRate(buckets, errorEntries) {
+  const out = [];
+  if (!errorEntries || errorEntries.length === 0) {
+    return [
+      {
+        rule: "hit-cap-rate",
+        severity: "insufficient_data",
+        scope: {},
+        message: `hit-cap-rate: errors.jsonl \u4E2D\u65E0 ratelimit_429 / \u603B\u4E8B\u4EF6\u4FE1\u53F7\uFF1B\u6570\u636E\u4E0D\u8DB3\u4EE5\u5224\u65AD`,
+        evidence: { errorEntries: 0 }
+      }
+    ];
+  }
+  for (const b of buckets) {
+    if (b.level !== "spec") continue;
+    try {
+      const sid = b.key;
+      const scoped = errorEntries.filter((e) => {
+        const cid = e.correlationId;
+        return typeof cid === "string" && cid.startsWith(`${sid}:`);
+      });
+      if (scoped.length === 0) continue;
+      const cap = scoped.filter((e) => e.kind === "ratelimit_429").length;
+      const ratio = cap / scoped.length;
+      let severity = null;
+      if (ratio > REC_THRESHOLDS.hitCapSev) severity = "sev";
+      else if (ratio > REC_THRESHOLDS.hitCapWarn) severity = "warn";
+      if (!severity) continue;
+      out.push({
+        rule: "hit-cap-rate",
+        severity,
+        scope: bucketScope(b),
+        message: `hit-cap-rate: ${pct(ratio)} of events were 429 rate-limit hits > ${pct(
+          severity === "sev" ? REC_THRESHOLDS.hitCapSev : REC_THRESHOLDS.hitCapWarn
+        )} threshold; suggest backing off concurrency or upgrading tier`,
+        evidence: { rateLimitedCount: cap, totalEvents: scoped.length, ratio }
+      });
+    } catch {
+    }
+  }
+  return out;
+}
+function ruleOpusMixHigh(buckets, ctx) {
+  const out = [];
+  const skipList = ctx.criticalPhases ?? CRITICAL_PHASES;
+  for (const b of buckets) {
+    if (b.level !== "phase") continue;
+    try {
+      const phase = b.phase ?? ctx.phase;
+      if (phase === void 0) {
+        out.push({
+          rule: "opus-mix-high",
+          severity: "insufficient_data",
+          scope: bucketScope(b),
+          message: `opus-mix-high: phase tag \u7F3A\u5931; \u6570\u636E\u4E0D\u8DB3\u4EE5\u5224\u65AD`,
+          evidence: { reason: "no-phase-tag" }
+        });
+        continue;
+      }
+      if (skipList.includes(phase)) continue;
+      const mix = b.modelMix;
+      let totalTok = 0;
+      let opusTok = 0;
+      for (const [model, m] of Object.entries(mix)) {
+        totalTok += m.tokens;
+        if (isOpusModel(model)) opusTok += m.tokens;
+      }
+      if (totalTok <= 0) {
+        out.push({
+          rule: "opus-mix-high",
+          severity: "insufficient_data",
+          scope: bucketScope(b),
+          message: `opus-mix-high: modelMix tokens=0; \u6570\u636E\u4E0D\u8DB3\u4EE5\u5224\u65AD`,
+          evidence: { totalTokens: 0 }
+        });
+        continue;
+      }
+      const share = opusTok / totalTok;
+      let severity;
+      if (share > REC_THRESHOLDS.opusMixSev) severity = "sev";
+      else if (share > REC_THRESHOLDS.opusMixWarn) severity = "warn";
+      else severity = "info";
+      out.push({
+        rule: "opus-mix-high",
+        severity,
+        scope: bucketScope(b),
+        message: severity === "info" ? `opus-mix-high: Opus share ${pct(share)} \u2264 ${pct(REC_THRESHOLDS.opusMixWarn)} (healthy mix)` : `opus-mix-high: Opus share ${pct(share)} > ${pct(
+          severity === "sev" ? REC_THRESHOLDS.opusMixSev : REC_THRESHOLDS.opusMixWarn
+        )} threshold; suggest routing routine work to Sonnet/Haiku`,
+        evidence: { opusTokens: opusTok, totalTokens: totalTok, share, phase }
+      });
+    } catch {
+    }
+  }
+  return out;
+}
+function ruleCostPerTaskSpike(buckets) {
+  const out = [];
+  try {
+    const taskBuckets = buckets.filter((b) => b.level === "task");
+    if (taskBuckets.length < REC_THRESHOLDS.madMinN) {
+      return [
+        {
+          rule: "cost-per-task-spike",
+          severity: "insufficient_data",
+          scope: {},
+          message: `cost-per-task-spike: n=${taskBuckets.length} < ${REC_THRESHOLDS.madMinN}; \u6570\u636E\u4E0D\u8DB3\u4EE5\u5224\u65AD (MAD \u9700 \u2265 ${REC_THRESHOLDS.madMinN} \u4E2A task bucket)`,
+          evidence: { n: taskBuckets.length, madMinN: REC_THRESHOLDS.madMinN }
+        }
+      ];
+    }
+    const values = taskBuckets.map((b) => b.totalUSD);
+    const z = modifiedZScore(values);
+    const allZero = z.every((v) => v === 0);
+    if (allZero) {
+      return [
+        {
+          rule: "cost-per-task-spike",
+          severity: "insufficient_data",
+          scope: {},
+          message: `cost-per-task-spike: MAD=0 (\u226550% identical task costs); \u6570\u636E\u4E0D\u8DB3\u4EE5\u5224\u65AD`,
+          evidence: { n: values.length, mad: 0 }
+        }
+      ];
+    }
+    const outlierIndices = findOutliers(values);
+    for (const idx of outlierIndices) {
+      const b = taskBuckets[idx];
+      const zi = z[idx];
+      if (!b || zi === void 0) continue;
+      out.push({
+        rule: "cost-per-task-spike",
+        severity: "sev",
+        scope: bucketScope(b),
+        message: `cost-per-task-spike: $${b.totalUSD.toFixed(4)} USD with |z|=${Math.abs(zi).toFixed(2)} > ${REC_THRESHOLDS.madZ} (MAD outlier); inspect task for runaway loop or oversized prompt`,
+        evidence: { totalUSD: b.totalUSD, modifiedZ: zi, n: values.length }
+      });
+    }
+  } catch {
+  }
+  return out;
+}
+function ruleWallClockP95(buckets) {
+  const out = [];
+  try {
+    const taskBuckets = buckets.filter((b) => b.level === "task" && b.rowCount > 0);
+    if (taskBuckets.length < 5) {
+      return [
+        {
+          rule: "wall-clock-p95",
+          severity: "insufficient_data",
+          scope: {},
+          message: `wall-clock-p95: n=${taskBuckets.length} < 5 task buckets; \u6570\u636E\u4E0D\u8DB3\u4EE5\u5224\u65AD`,
+          evidence: { n: taskBuckets.length }
+        }
+      ];
+    }
+    const perRowDur = taskBuckets.map((b) => b.durationMs / Math.max(b.rowCount, 1));
+    const sorted = [...perRowDur].sort((a, b) => a - b);
+    const baseline = median(sorted);
+    if (baseline <= 0) {
+      return [
+        {
+          rule: "wall-clock-p95",
+          severity: "insufficient_data",
+          scope: {},
+          message: `wall-clock-p95: baseline duration=0; \u6570\u636E\u4E0D\u8DB3\u4EE5\u5224\u65AD`,
+          evidence: { n: taskBuckets.length, baseline: 0 }
+        }
+      ];
+    }
+    const warnLine = REC_THRESHOLDS.wallClockWarn * baseline;
+    const sevLine = REC_THRESHOLDS.wallClockSev * baseline;
+    for (let i = 0; i < taskBuckets.length; i++) {
+      const b = taskBuckets[i];
+      const dur = perRowDur[i];
+      if (!b || dur === void 0) continue;
+      let severity = null;
+      if (dur > sevLine) severity = "sev";
+      else if (dur > warnLine) severity = "warn";
+      if (!severity) continue;
+      out.push({
+        rule: "wall-clock-p95",
+        severity,
+        scope: bucketScope(b),
+        message: `wall-clock-p95: ${Math.round(dur)}ms/turn > ${severity === "sev" ? REC_THRESHOLDS.wallClockSev : REC_THRESHOLDS.wallClockWarn}\xD7 baseline (${Math.round(baseline)}ms); inspect for tool-call thrash or slow MCP server`,
+        evidence: {
+          durationPerRowMs: dur,
+          baselineMs: baseline,
+          ratio: dur / baseline,
+          rowCount: b.rowCount
+        }
+      });
+    }
+  } catch {
+  }
+  return out;
+}
+function ruleCacheChurn(buckets) {
+  const out = [];
+  for (const b of buckets) {
+    if (b.level !== "spec" && b.level !== "phase") continue;
+    try {
+      if (b.cacheReadTokens <= 0) continue;
+      const writeTotal = b.cacheCreate5mTokens + b.cacheCreate1hTokens;
+      if (writeTotal <= 0) {
+        out.push({
+          rule: "cache-churn",
+          severity: "info",
+          scope: bucketScope(b),
+          message: `cache-churn: zero new cache writes against ${b.cacheReadTokens} cached reads (pure reuse, healthy)`,
+          evidence: { cacheRead: b.cacheReadTokens, cacheCreate5m: 0, cacheCreate1h: 0, ratio: 0 }
+        });
+        continue;
+      }
+      const ratio = writeTotal / b.cacheReadTokens;
+      let severity = null;
+      if (ratio > REC_THRESHOLDS.cacheChurnSev) severity = "sev";
+      else if (ratio > REC_THRESHOLDS.cacheChurnWarn) severity = "warn";
+      else severity = "info";
+      if (severity === "info") {
+        if (ratio > REC_THRESHOLDS.cacheChurnWarn) continue;
+      }
+      out.push({
+        rule: "cache-churn",
+        severity,
+        scope: bucketScope(b),
+        message: severity === "info" ? `cache-churn: write/read ratio ${ratio.toFixed(2)} \u2264 ${REC_THRESHOLDS.cacheChurnWarn} (healthy reuse)` : `cache-churn: write/read ratio ${ratio.toFixed(2)} > ${severity === "sev" ? REC_THRESHOLDS.cacheChurnSev : REC_THRESHOLDS.cacheChurnWarn} threshold; cache is being rebuilt faster than reused \u2014 check for prompt instability or session churn`,
+        evidence: {
+          cacheRead: b.cacheReadTokens,
+          cacheCreate5m: b.cacheCreate5mTokens,
+          cacheCreate1h: b.cacheCreate1hTokens,
+          ratio
+        }
+      });
+    } catch {
+    }
+  }
+  return out;
+}
+function ruleRetryLoop(buckets, errorEntries) {
+  const out = [];
+  if (!errorEntries || errorEntries.length === 0) {
+    return [
+      {
+        rule: "retry-loop",
+        severity: "insufficient_data",
+        scope: {},
+        message: `retry-loop: errors.jsonl \u65E0 retry \u8BB0\u5F55; \u6570\u636E\u4E0D\u8DB3\u4EE5\u5224\u65AD`,
+        evidence: { errorEntries: 0 }
+      }
+    ];
+  }
+  try {
+    const retryByCorrId = /* @__PURE__ */ new Map();
+    for (const e of errorEntries) {
+      if (e.kind !== "retry") continue;
+      const cid = e.correlationId;
+      if (typeof cid !== "string" || cid.length === 0) continue;
+      retryByCorrId.set(cid, (retryByCorrId.get(cid) ?? 0) + 1);
+    }
+    if (retryByCorrId.size === 0) {
+      return [];
+    }
+    const taskBuckets = buckets.filter((b) => b.level === "task");
+    for (const b of taskBuckets) {
+      const count = retryByCorrId.get(b.key) ?? 0;
+      let severity = null;
+      if (count >= REC_THRESHOLDS.retrySev) severity = "sev";
+      else if (count >= REC_THRESHOLDS.retryWarn) severity = "warn";
+      if (!severity) continue;
+      out.push({
+        rule: "retry-loop",
+        severity,
+        scope: bucketScope(b),
+        message: `retry-loop: ${count} retries on this task \u2265 ${severity === "sev" ? REC_THRESHOLDS.retrySev : REC_THRESHOLDS.retryWarn} threshold; inspect for stuck loop / failing precondition`,
+        evidence: { retries: count, correlationId: b.key }
+      });
+    }
+  } catch {
+  }
+  return out;
+}
+function recommend(buckets, ctx = {}) {
+  const out = [];
+  const safe = (fn) => {
+    try {
+      return fn();
+    } catch {
+      return [];
+    }
+  };
+  out.push(...safe(() => ruleCacheHitLow(buckets)));
+  out.push(...safe(() => ruleOutputTokHigh(buckets)));
+  out.push(...safe(() => ruleHitCapRate(buckets, ctx.errorEntries)));
+  out.push(...safe(() => ruleOpusMixHigh(buckets, ctx)));
+  out.push(...safe(() => ruleCostPerTaskSpike(buckets)));
+  out.push(...safe(() => ruleWallClockP95(buckets)));
+  out.push(...safe(() => ruleCacheChurn(buckets)));
+  out.push(...safe(() => ruleRetryLoop(buckets, ctx.errorEntries)));
+  return out;
+}
+
+// src/analyze/redact.ts
+import { createHash } from "crypto";
+import path2 from "path";
+var PATH_FIELDS = /* @__PURE__ */ new Set(["cwd", "path", "file", "transcript_path", "projectPath"]);
+var COMMAND_NAME_RE = /<command-name>([^<]+)<\/command-name>/g;
+function hashProject(absPath) {
+  return createHash("sha256").update(absPath).digest("hex").slice(0, 8);
+}
+function redactPath(p) {
+  if (!p) return p;
+  const base = path2.basename(p) || p;
+  return `${base}@${hashProject(p)}`;
+}
+function extractCommandHints(text) {
+  const hints = [];
+  let m;
+  COMMAND_NAME_RE.lastIndex = 0;
+  while (m = COMMAND_NAME_RE.exec(text)) {
+    if (m[1]) hints.push(m[1].trim());
+  }
+  return hints;
+}
+function redactEvent(ev, opts = {}) {
+  const topType = ev.payload.type;
+  if (topType === "file-history-snapshot") return null;
+  const att = ev.payload.attachment;
+  if (att && typeof att === "object" && att.type === "file-history-snapshot") {
+    return null;
+  }
+  if (opts.includePrompts) return ev;
+  const next = { ...ev, payload: { ...ev.payload } };
+  if (typeof next.cwd === "string") next.cwd = redactPath(next.cwd);
+  for (const key of PATH_FIELDS) {
+    const v = next.payload[key];
+    if (typeof v === "string") next.payload[key] = redactPath(v);
+  }
+  if (next.kind === "user_turn") {
+    let totalLength = 0;
+    const hints = [];
+    const message = next.payload.message;
+    if (message && typeof message === "object") {
+      const content = message.content;
+      if (typeof content === "string") {
+        totalLength += Buffer.byteLength(content, "utf8");
+        hints.push(...extractCommandHints(content));
+      } else if (Array.isArray(content)) {
+        for (const part of content) {
+          if (part && typeof part === "object") {
+            const t = part.text;
+            if (typeof t === "string") {
+              totalLength += Buffer.byteLength(t, "utf8");
+              hints.push(...extractCommandHints(t));
+            }
+          }
+        }
+      }
+      const synthesized = hints.map((h) => ({ type: "text", text: `<command-name>${h}</command-name>` }));
+      next.payload.message = { ...message, content: synthesized };
+    }
+    if (typeof next.payload.content === "string") {
+      totalLength += Buffer.byteLength(next.payload.content, "utf8");
+      hints.push(...extractCommandHints(next.payload.content));
+      delete next.payload.content;
+    }
+    next.payload.redacted = {
+      length: totalLength,
+      commandHints: Array.from(new Set(hints))
+    };
+  }
+  return next;
+}
+function redactReportFields(report, opts = {}) {
+  if (opts.includePrompts) return report;
+  return walk(report);
+}
+function walk(value) {
+  if (Array.isArray(value)) return value.map(walk);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (typeof v === "string" && PATH_FIELDS.has(k)) {
+        out[k] = redactPath(v);
+      } else {
+        out[k] = walk(v);
+      }
+    }
+    return out;
+  }
+  return value;
+}
+
+// src/analyze/report.ts
+var DEFAULT_LIMIT = 10;
+var STDERR_TRUNC = 200;
+var FUZZY_TS_WINDOW_MS = 2e3;
+var MIN_SAMPLES_FOR_PCT = 5;
+var COMMAND_NAME_RE2 = /<command-name>([^<]+)<\/command-name>/;
+function escapeCell(s) {
+  return s.replace(/\|/g, "\\|").replace(/\r?\n/g, " ");
+}
+function truncate(s, max = STDERR_TRUNC) {
+  if (!s) return "";
+  return s.length <= max ? s : s.slice(0, max);
+}
+function rollupHookFailures(events, errors, limit) {
+  const buckets = [];
+  for (const ev of events) {
+    if (ev.kind !== "hook_invocation") continue;
+    const att = ev.payload.attachment;
+    if (!att || typeof att !== "object") continue;
+    const a = att;
+    if (a.type !== "hook_success") continue;
+    const hookName = typeof a.hookName === "string" ? a.hookName : void 0;
+    const exitCode = typeof a.exitCode === "number" ? a.exitCode : void 0;
+    if (!hookName || exitCode === void 0 || exitCode === 0) continue;
+    const stderr = truncate(typeof a.stderr === "string" ? a.stderr : "");
+    const tsMs = ev.ts ? Date.parse(ev.ts) : NaN;
+    buckets.push({
+      hook: hookName,
+      ts: Number.isFinite(tsMs) ? tsMs : 0,
+      ...ev.cwd ? { cwd: ev.cwd } : {},
+      stderr,
+      source: "jsonl"
+    });
+  }
+  for (const e of errors) {
+    if (!e.hook) continue;
+    const tsMs = e.ts ? Date.parse(e.ts) : NaN;
+    const cwd = e.cwd;
+    const tsResolved = Number.isFinite(tsMs) ? tsMs : 0;
+    const dup = buckets.find(
+      (b) => b.hook === e.hook && Math.abs(b.ts - tsResolved) <= FUZZY_TS_WINDOW_MS && (b.cwd ?? "") === (cwd ?? "")
+    );
+    if (dup) {
+      dup.source = "merged";
+      continue;
+    }
+    buckets.push({
+      hook: e.hook,
+      ts: tsResolved,
+      ...cwd ? { cwd } : {},
+      stderr: truncate(e.msg ?? ""),
+      source: "errors.jsonl"
+    });
+  }
+  const counts = /* @__PURE__ */ new Map();
+  for (const b of buckets) {
+    const prev = counts.get(b.hook);
+    if (prev) {
+      prev.count += 1;
+      if (b.stderr) prev.lastStderr = b.stderr;
+      if (prev.source !== b.source) prev.source = "merged";
+    } else {
+      counts.set(b.hook, { count: 1, lastStderr: b.stderr, source: b.source });
+    }
+  }
+  const rows = Array.from(counts.entries()).map(([hook, v]) => ({ hook, count: v.count, lastStderr: v.lastStderr, source: v.source })).sort((a, b) => b.count - a.count);
+  return rows.slice(0, limit);
+}
+function renderHookFailures(rows, limit) {
+  const lines = [];
+  lines.push(`## Hook Failures Top-${limit}`);
+  lines.push("");
+  if (rows.length === 0) {
+    lines.push("_No hook failures recorded._");
+    lines.push("");
+    return lines.join("\n");
+  }
+  lines.push("| Hook | Count | Last stderr | Source |");
+  lines.push("| --- | --- | --- | --- |");
+  for (const r of rows) {
+    lines.push(`| ${escapeCell(r.hook)} | ${r.count} | ${escapeCell(r.lastStderr)} | ${r.source} |`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function rollupSlashCommands(events, limit) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const ev of events) {
+    if (ev.kind === "assistant_turn") {
+      const skill = ev.payload.attributionSkill;
+      if (typeof skill === "string" && skill.length > 0) {
+        counts.set(skill, (counts.get(skill) ?? 0) + 1);
+      }
+      continue;
+    }
+    if (ev.kind === "user_turn") {
+      const message = ev.payload.message;
+      if (!message || typeof message !== "object") continue;
+      const content = message.content;
+      const texts = [];
+      if (Array.isArray(content)) {
+        for (const part of content) {
+          if (part && typeof part === "object") {
+            const t = part.text;
+            if (typeof t === "string") texts.push(t);
+          }
+        }
+      } else if (typeof content === "string") {
+        texts.push(content);
+      }
+      for (const t of texts) {
+        const m = COMMAND_NAME_RE2.exec(t);
+        if (m && m[1]) {
+          const cmd = m[1].trim();
+          if (cmd) counts.set(cmd, (counts.get(cmd) ?? 0) + 1);
+        }
+      }
+    }
+  }
+  const rows = Array.from(counts.entries()).map(([command, count]) => ({ command, count })).sort((a, b) => b.count - a.count);
+  return rows.slice(0, limit);
+}
+function renderSlashCommands(rows, limit) {
+  const lines = [];
+  lines.push(`## Slash Commands Top-${limit}`);
+  lines.push("");
+  if (rows.length === 0) {
+    lines.push("_No slash command activity recorded._");
+    lines.push("");
+    return lines.join("\n");
+  }
+  lines.push("| Command | Count |");
+  lines.push("| --- | --- |");
+  for (const r of rows) {
+    lines.push(`| ${escapeCell(r.command)} | ${r.count} |`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function rollupSubagents(events, limit) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const ev of events) {
+    if (ev.kind !== "tool_call" && ev.kind !== "assistant_turn") continue;
+    const message = ev.payload.message;
+    if (message && typeof message === "object") {
+      const content = message.content;
+      if (Array.isArray(content)) {
+        for (const part of content) {
+          if (!part || typeof part !== "object") continue;
+          const p = part;
+          if (p.type !== "tool_use") continue;
+          if (p.name !== "Agent" && p.name !== "Task") continue;
+          const input = p.input;
+          const sub = input && typeof input.subagent_type === "string" ? input.subagent_type : void 0;
+          if (sub) counts.set(sub, (counts.get(sub) ?? 0) + 1);
+        }
+      }
+    }
+    const direct = ev.payload;
+    if (direct.name === "Agent" || direct.name === "Task") {
+      const input = direct.input;
+      const sub = input && typeof input.subagent_type === "string" ? input.subagent_type : void 0;
+      if (sub) counts.set(sub, (counts.get(sub) ?? 0) + 1);
+    }
+  }
+  const rows = Array.from(counts.entries()).map(([subagent, count]) => ({ subagent, count })).sort((a, b) => b.count - a.count);
+  return rows.slice(0, limit);
+}
+function renderSubagents(rows, limit) {
+  const lines = [];
+  lines.push(`## Subagents Top-${limit}`);
+  lines.push("");
+  if (rows.length === 0) {
+    lines.push("_No subagent dispatches recorded._");
+    lines.push("");
+    return lines.join("\n");
+  }
+  lines.push("| Subagent | Count |");
+  lines.push("| --- | --- |");
+  for (const r of rows) {
+    lines.push(`| ${escapeCell(r.subagent)} | ${r.count} |`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+var PHASE_ORDER = ["research", "requirements", "design", "tasks", "execution", "done"];
+function rollupSpecFunnel(specStates) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const s of specStates) {
+    counts.set(s.phase, (counts.get(s.phase) ?? 0) + 1);
+  }
+  const rows = [];
+  for (const p of PHASE_ORDER) {
+    rows.push({ phase: p, count: counts.get(p) ?? 0 });
+    counts.delete(p);
+  }
+  for (const [phase, count] of Array.from(counts.entries()).sort()) {
+    rows.push({ phase, count });
+  }
+  return rows;
+}
+function renderSpecFunnel(rows) {
+  const lines = [];
+  lines.push("## Spec Funnel");
+  lines.push("");
+  lines.push("| Phase | Count |");
+  lines.push("| --- | --- |");
+  for (const r of rows) {
+    lines.push(`| ${escapeCell(r.phase)} | ${r.count} |`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function percentile(sortedAsc, p) {
+  if (sortedAsc.length === 0) return null;
+  const n = sortedAsc.length;
+  const idx = Math.min(Math.max(Math.ceil(p * n) - 1, 0), n - 1);
+  return sortedAsc[idx] ?? null;
+}
+function rollupHookDuration(events) {
+  const samples = /* @__PURE__ */ new Map();
+  for (const ev of events) {
+    if (ev.kind !== "hook_invocation") continue;
+    const att = ev.payload.attachment;
+    if (!att || typeof att !== "object") continue;
+    const a = att;
+    if (a.type !== "hook_success") continue;
+    const hookName = typeof a.hookName === "string" ? a.hookName : void 0;
+    const dur = typeof a.durationMs === "number" ? a.durationMs : void 0;
+    if (!hookName || dur === void 0) continue;
+    if (!samples.has(hookName)) samples.set(hookName, []);
+    samples.get(hookName).push(dur);
+  }
+  const rows = [];
+  for (const [hook, arr] of samples.entries()) {
+    arr.sort((a, b) => a - b);
+    rows.push({
+      hook,
+      samples: arr.length,
+      p50: percentile(arr, 0.5),
+      p95: percentile(arr, 0.95),
+      p99: percentile(arr, 0.99)
+    });
+  }
+  rows.sort((a, b) => b.samples - a.samples);
+  return rows;
+}
+function renderHookDuration(rows) {
+  const lines = [];
+  lines.push("## Hook Duration");
+  lines.push("");
+  if (rows.length === 0) {
+    lines.push("_No hook duration samples recorded._");
+    lines.push("");
+    return lines.join("\n");
+  }
+  lines.push("| Hook | Samples | P50 (ms) | P95 (ms) | P99 (ms) |");
+  lines.push("| --- | --- | --- | --- | --- |");
+  for (const r of rows) {
+    if (r.samples < MIN_SAMPLES_FOR_PCT) {
+      lines.push(`| ${escapeCell(r.hook)} | ${r.samples} | (\u6837\u672C\u4E0D\u8DB3: ${r.samples}) | (\u6837\u672C\u4E0D\u8DB3: ${r.samples}) | (\u6837\u672C\u4E0D\u8DB3: ${r.samples}) |`);
+    } else {
+      lines.push(`| ${escapeCell(r.hook)} | ${r.samples} | ${r.p50 ?? "-"} | ${r.p95 ?? "-"} | ${r.p99 ?? "-"} |`);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function renderSchemaDrift(input) {
+  const lines = [];
+  lines.push("## Schema Drift");
+  lines.push("");
+  lines.push("| Metric | Value |");
+  lines.push("| --- | --- |");
+  lines.push(`| unknown_type_count | ${input.unknownTypeCount} |`);
+  lines.push(`| parse_error_count | ${input.parseErrorCount} |`);
+  lines.push("");
+  if (input.unknownTypeCount > 0 || input.parseErrorCount > 0) {
+    lines.push("_Hint: \u5982\u957F\u671F > 0 \u8868\u660E Claude Code \u5347\u7EA7\u4E86 schema\uFF0C\u8BF7\u68C0\u67E5 plugins/curdx-flow/schemas/transcript-events.json_");
+  } else {
+    lines.push("_no drift detected_");
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function rollupParentChain(events) {
+  const uuids = /* @__PURE__ */ new Set();
+  for (const ev of events) {
+    if (ev.uuid) uuids.add(ev.uuid);
+  }
+  let withParent = 0;
+  let broken = 0;
+  for (const ev of events) {
+    const p = ev.payload.parentUuid;
+    if (typeof p === "string" && p.length > 0) {
+      withParent += 1;
+      if (!uuids.has(p)) broken += 1;
+    }
+  }
+  return {
+    totalEvents: events.length,
+    withParent,
+    brokenLinks: broken,
+    brokenRatio: withParent === 0 ? 0 : broken / withParent,
+    hasData: withParent > 0
+  };
+}
+function renderParentChain(s) {
+  const lines = [];
+  lines.push("## Parent Chain");
+  lines.push("");
+  if (!s.hasData) {
+    lines.push("_(no parent chain data)_");
+    lines.push("");
+    return lines.join("\n");
+  }
+  lines.push("| Metric | Value |");
+  lines.push("| --- | --- |");
+  lines.push(`| total_events | ${s.totalEvents} |`);
+  lines.push(`| events_with_parent | ${s.withParent} |`);
+  lines.push(`| broken_links | ${s.brokenLinks} |`);
+  lines.push(`| parentUuid_broken_ratio | ${s.brokenRatio.toFixed(4)} |`);
+  lines.push("");
+  return lines.join("\n");
+}
+function fmtUsd(n) {
+  return Number.isFinite(n) ? `$${(Math.round(n * 1e4) / 1e4).toFixed(4)}` : "$0.0000";
+}
+function fmtPct(n) {
+  return Number.isFinite(n) ? `${(n * 100).toFixed(2)}%` : "0.00%";
+}
+function renderR1PerSpec(buckets) {
+  const lines = [];
+  lines.push("### R1 \u2014 Cost per Spec");
+  lines.push("");
+  if (buckets.length === 0) {
+    lines.push("_no data_");
+    lines.push("");
+    return lines.join("\n");
+  }
+  const sorted = [...buckets].sort((a, b) => b.totalUSD - a.totalUSD);
+  lines.push("| Spec | Total USD | Rows | Trailers | Duration (ms) |");
+  lines.push("| --- | --- | --- | --- | --- |");
+  for (const b of sorted) {
+    lines.push(
+      `| ${escapeCell(b.key)} | ${fmtUsd(b.totalUSD)} | ${b.rowCount} | ${b.trailerCount} | ${b.durationMs ?? 0} |`
+    );
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function renderR2PerPhase(buckets) {
+  const lines = [];
+  lines.push("### R2 \u2014 Cost per Phase");
+  lines.push("");
+  if (buckets.length === 0) {
+    lines.push("_no data_");
+    lines.push("");
+    return lines.join("\n");
+  }
+  const order = new Map(PHASE_ORDER.map((p, i) => [p, i]));
+  const sorted = [...buckets].sort((a, b) => {
+    const ai = order.get(a.key) ?? PHASE_ORDER.length;
+    const bi = order.get(b.key) ?? PHASE_ORDER.length;
+    if (ai !== bi) return ai - bi;
+    return b.totalUSD - a.totalUSD;
+  });
+  lines.push("| Phase | Total USD | Rows | Trailers | Duration (ms) |");
+  lines.push("| --- | --- | --- | --- | --- |");
+  for (const b of sorted) {
+    lines.push(
+      `| ${escapeCell(b.key)} | ${fmtUsd(b.totalUSD)} | ${b.rowCount} | ${b.trailerCount} | ${b.durationMs ?? 0} |`
+    );
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function renderR3PerTask(buckets) {
+  const lines = [];
+  lines.push("### R3 \u2014 Cost per Task");
+  lines.push("");
+  if (buckets.length === 0) {
+    lines.push("_no data_");
+    lines.push("");
+    return lines.join("\n");
+  }
+  const sorted = [...buckets].sort((a, b) => b.totalUSD - a.totalUSD);
+  lines.push("| Task | Total USD | Rows | Trailers | trailerHit | Duration (ms) |");
+  lines.push("| --- | --- | --- | --- | --- | --- |");
+  for (const b of sorted) {
+    const trailerHit = b.trailerCount > 0 ? "yes" : "no";
+    lines.push(
+      `| ${escapeCell(b.key)} | ${fmtUsd(b.totalUSD)} | ${b.rowCount} | ${b.trailerCount} | ${trailerHit} | ${b.durationMs ?? 0} |`
+    );
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function renderR4CacheHit(buckets) {
+  const lines = [];
+  lines.push("### R4 \u2014 Cache Hit Rate");
+  lines.push("");
+  lines.push("_Formula: hitRate = cacheRead / (cacheRead + 5m + 1h)_");
+  lines.push("");
+  if (buckets.length === 0) {
+    lines.push("_no data_");
+    lines.push("");
+    return lines.join("\n");
+  }
+  const rows = buckets.map((b) => {
+    const denom = (b.cacheReadTokens ?? 0) + (b.cacheCreate5mTokens ?? 0) + (b.cacheCreate1hTokens ?? 0);
+    const hitRate = denom > 0 ? (b.cacheReadTokens ?? 0) / denom : 0;
+    return { key: b.key, hitRate, read: b.cacheReadTokens ?? 0, w5m: b.cacheCreate5mTokens ?? 0, w1h: b.cacheCreate1hTokens ?? 0 };
+  });
+  rows.sort((a, b) => a.hitRate - b.hitRate);
+  lines.push("| Scope | Hit Rate | cacheRead | 5m write | 1h write |");
+  lines.push("| --- | --- | --- | --- | --- |");
+  for (const r of rows) {
+    lines.push(`| ${escapeCell(r.key)} | ${fmtPct(r.hitRate)} | ${r.read} | ${r.w5m} | ${r.w1h} |`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function renderR5WallClock(buckets) {
+  const lines = [];
+  lines.push("### R5 \u2014 Wall-Clock P95");
+  lines.push("");
+  if (buckets.length === 0) {
+    lines.push("_no data_");
+    lines.push("");
+    return lines.join("\n");
+  }
+  const sorted = [...buckets].sort((a, b) => (b.durationMs ?? 0) - (a.durationMs ?? 0));
+  const n = sorted.length;
+  const p95Idx = Math.min(Math.max(Math.ceil(0.95 * n) - 1, 0), n - 1);
+  const p95 = sorted[p95Idx]?.durationMs ?? 0;
+  lines.push(`_P95 wall-clock across ${n} bucket(s): ${p95} ms_`);
+  lines.push("");
+  lines.push("| Scope | Duration (ms) |");
+  lines.push("| --- | --- |");
+  for (const b of sorted) {
+    lines.push(`| ${escapeCell(b.key)} | ${b.durationMs ?? 0} |`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function renderR6ModelMix(buckets) {
+  const lines = [];
+  lines.push("### R6 \u2014 Model Mix");
+  lines.push("");
+  const mix = /* @__PURE__ */ new Map();
+  for (const b of buckets) {
+    if (!b.modelMix) continue;
+    for (const [model, m] of Object.entries(b.modelMix)) {
+      const prev = mix.get(model) ?? { tokens: 0, usd: 0 };
+      prev.tokens += m.tokens ?? 0;
+      prev.usd += m.usd ?? 0;
+      mix.set(model, prev);
+    }
+  }
+  if (mix.size === 0) {
+    lines.push("_no data_");
+    lines.push("");
+    lines.push("_Note: Opus 4.7 tokenizer counts ~35% more tokens than older models \u2014 token totals are not directly comparable across model cohorts. (FR-REPORT-4 / AC8)_");
+    lines.push("");
+    return lines.join("\n");
+  }
+  const rows = Array.from(mix.entries()).sort((a, b) => b[1].usd - a[1].usd);
+  lines.push("| Model | Tokens | USD |");
+  lines.push("| --- | --- | --- |");
+  for (const [model, m] of rows) {
+    lines.push(`| ${escapeCell(model)} | ${m.tokens} | ${fmtUsd(m.usd)} |`);
+  }
+  lines.push("");
+  lines.push("_Note: Opus 4.7 tokenizer counts ~35% more tokens than older models \u2014 token totals are not directly comparable across model cohorts._");
+  lines.push("");
+  return lines.join("\n");
+}
+function renderR7TopN(buckets) {
+  const lines = [];
+  lines.push("### R7 \u2014 Top-N Tasks");
+  lines.push("");
+  if (buckets.length === 0) {
+    lines.push("_no data_");
+    lines.push("");
+    return lines.join("\n");
+  }
+  const sorted = [...buckets].sort((a, b) => b.totalUSD - a.totalUSD);
+  lines.push("| Rank | Task | Total USD | Rows | Trailers |");
+  lines.push("| --- | --- | --- | --- | --- |");
+  sorted.forEach((b, i) => {
+    lines.push(`| ${i + 1} | ${escapeCell(b.key)} | ${fmtUsd(b.totalUSD)} | ${b.rowCount} | ${b.trailerCount} |`);
+  });
+  lines.push("");
+  return lines.join("\n");
+}
+var SEV_PREFIX = {
+  sev: "[SEV]",
+  warn: "[WARN]",
+  info: "[INFO]",
+  insufficient_data: "[N/A]"
+};
+var SEV_COLOR = {
+  sev: "\x1B[31m",
+  warn: "\x1B[33m",
+  info: "\x1B[34m",
+  insufficient_data: "\x1B[90m"
+};
+var ANSI_RESET = "\x1B[0m";
+function colorAllowed() {
+  return !(typeof process !== "undefined" && process.env && "NO_COLOR" in process.env);
+}
+function severityPrefix(sev) {
+  const tag = SEV_PREFIX[sev];
+  if (!colorAllowed()) return tag;
+  return `${SEV_COLOR[sev]}${tag}${ANSI_RESET}`;
+}
+function formatScope(scope) {
+  const parts = [];
+  if (scope.spec) parts.push(`spec=${scope.spec}`);
+  if (scope.phase) parts.push(`phase=${scope.phase}`);
+  if (scope.task) parts.push(`task=${scope.task}`);
+  return parts.length === 0 ? "global" : parts.join("/");
+}
+function formatEvidence(evidence) {
+  try {
+    return JSON.stringify(evidence);
+  } catch {
+    return "{}";
+  }
+}
+function renderRecommendations(recs) {
+  if (!recs || recs.length === 0) return "";
+  const lines = [];
+  lines.push("## Recommendations");
+  lines.push("");
+  for (const r of recs) {
+    const prefix = severityPrefix(r.severity);
+    const scope = formatScope(r.scope ?? {});
+    const evidence = formatEvidence(r.evidence ?? {});
+    let line = `- ${prefix} ${r.rule} @ ${scope} \u2014 ${r.message} (${evidence})`;
+    if (r.severity === "insufficient_data") {
+      const n = r.evidence?.n;
+      const nDisplay = typeof n === "number" ? n : "?";
+      line += ` _n=${nDisplay} \u4E0D\u8DB3\u4EE5\u5224\u65AD_`;
+    }
+    lines.push(line);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function renderCostBreakdown(input) {
+  const lines = [];
+  lines.push("## Cost Breakdown");
+  lines.push("");
+  lines.push(`_Total: ${fmtUsd(input.totalCost?.usd ?? 0)} USD across ${input.R3_perTask?.length ?? 0} task bucket(s)_`);
+  lines.push("");
+  lines.push(renderR1PerSpec(input.R1_perSpec ?? []));
+  lines.push(renderR2PerPhase(input.R2_perPhase ?? []));
+  lines.push(renderR3PerTask(input.R3_perTask ?? []));
+  lines.push(renderR4CacheHit(input.R3_perTask ?? []));
+  lines.push(renderR5WallClock(input.R3_perTask ?? []));
+  lines.push(renderR6ModelMix(input.R3_perTask ?? []));
+  lines.push(renderR7TopN(input.R7_topN ?? []));
+  return lines.join("\n");
+}
+function renderReport(events, errorEntries, specStates, opts) {
+  const limit = typeof opts.limit === "number" && opts.limit > 0 ? opts.limit : DEFAULT_LIMIT;
+  const hookFailures = rollupHookFailures(events, errorEntries, limit);
+  const slashCommands = rollupSlashCommands(events, limit);
+  const subagents = rollupSubagents(events, limit);
+  const specFunnel = rollupSpecFunnel(specStates);
+  const hookDuration = rollupHookDuration(events);
+  const parentChain = rollupParentChain(events);
+  let markdown = renderHookFailures(hookFailures, limit) + "\n" + renderSlashCommands(slashCommands, limit) + "\n" + renderSubagents(subagents, limit) + "\n" + renderSpecFunnel(specFunnel) + "\n" + renderHookDuration(hookDuration) + "\n" + renderSchemaDrift(opts.schemaDrift) + "\n" + renderParentChain(parentChain);
+  if (opts.costBreakdown) {
+    markdown += "\n" + renderCostBreakdown(opts.costBreakdown);
+  }
+  if (opts.recommendations && opts.recommendations.length > 0) {
+    const recsMd = renderRecommendations(opts.recommendations);
+    if (recsMd) markdown += "\n" + recsMd;
+  }
+  const json = {
+    hookFailures,
+    slashCommands,
+    subagents,
+    specFunnel,
+    hookDuration,
+    schemaDrift: {
+      unknownTypeCount: opts.schemaDrift.unknownTypeCount,
+      parseErrorCount: opts.schemaDrift.parseErrorCount
+    },
+    parentChain
+  };
+  return { markdown, json };
+}
+
+// src/analyze/transcript-path.ts
+import { readdirSync, realpathSync, statSync as statSync2 } from "fs";
+import { homedir } from "os";
+import path3 from "path";
+var TranscriptNotFoundError = class extends Error {
+  path;
+  hint;
+  constructor(p, hint) {
+    super(`Transcript not found at ${p}
+  hint: ${hint}`);
+    this.name = "TranscriptNotFoundError";
+    this.path = p;
+    this.hint = hint;
+  }
+};
+var REALPATH_CACHE = /* @__PURE__ */ new Map();
+function resolveRealCwd(cwd) {
+  const cached = REALPATH_CACHE.get(cwd);
+  if (cached !== void 0) return cached;
+  let real;
+  try {
+    real = realpathSync(cwd);
+  } catch {
+    real = cwd;
+  }
+  REALPATH_CACHE.set(cwd, real);
+  return real;
+}
+function encodeCwd(realCwd) {
+  return realCwd.replace(/\//g, "-");
+}
+function resolveTranscriptSource(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  if (opts.fixtureOverride) {
+    const fixturePath = opts.fixtureOverride;
+    try {
+      const st = statSync2(fixturePath);
+      if (!st.isFile()) {
+        throw new TranscriptNotFoundError(
+          fixturePath,
+          "fixture path is not a regular file"
+        );
+      }
+    } catch (err) {
+      if (err instanceof TranscriptNotFoundError) throw err;
+      throw new TranscriptNotFoundError(
+        fixturePath,
+        "fixture not found \u2014 check CURDX_TRANSCRIPT_FIXTURE points to an existing .jsonl file"
+      );
+    }
+    return { kind: "fixture", paths: [fixturePath], cwd };
+  }
+  const home = opts.homedir ?? homedir();
+  const realCwd = resolveRealCwd(cwd);
+  const encoded = encodeCwd(realCwd);
+  const encodedDir = path3.join(home, ".claude", "projects", encoded);
+  let entries = [];
+  try {
+    entries = readdirSync(encodedDir, { withFileTypes: true });
+  } catch {
+    throw new TranscriptNotFoundError(
+      encodedDir,
+      `no Claude Code project dir for cwd ${cwd} \u2014 run \`claude\` here at least once, or pass CURDX_TRANSCRIPT_FIXTURE=\u2026 for tests`
+    );
+  }
+  let paths = entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => path3.join(encodedDir, e.name));
+  if (opts.sessionFilter) {
+    const wanted = `${opts.sessionFilter}.jsonl`;
+    paths = paths.filter((p) => path3.basename(p) === wanted);
+  }
+  if (paths.length === 0) {
+    const hint = opts.sessionFilter ? `no transcript file ${opts.sessionFilter}.jsonl in ${encodedDir} \u2014 drop --session or check the uuid` : `no .jsonl transcripts in ${encodedDir} \u2014 open Claude Code in this cwd to generate one`;
+    throw new TranscriptNotFoundError(encodedDir, hint);
+  }
+  return { kind: "real", paths, cwd, realCwd, encodedDir };
+}
+
+// src/analyze/index.ts
+var STATE_DIR = path4.join(homedir2(), ".claude", "curdx-flow");
+var STATE_PATH = path4.join(STATE_DIR, "observability-state.json");
+var ERRORS_LOG_PATH = path4.join(STATE_DIR, "errors.jsonl");
+var SPECS_DIR_REL = "specs";
+function readState() {
+  if (!existsSync(STATE_PATH)) return { version: 1, files: {} };
+  try {
+    const raw = readFileSync2(STATE_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && parsed.version === 1 && parsed.files) return parsed;
+  } catch {
+  }
+  return { version: 1, files: {} };
+}
+function writeState(state) {
+  if (!existsSync(STATE_DIR)) mkdirSync(STATE_DIR, { recursive: true });
+  writeFileSync(STATE_PATH, JSON.stringify(state, null, 2), "utf8");
+}
+function cleanupOrphanState(state, currentPaths) {
+  const now = Date.now();
+  const THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1e3;
+  const KEEP_MAX = 100;
+  const protectedKeys = new Set(currentPaths);
+  const dropped = [];
+  for (const key of Object.keys(state.files)) {
+    if (protectedKeys.has(key)) continue;
+    const entry = state.files[key];
+    if (!entry) continue;
+    const stale = now - entry.lastModifiedMs > THIRTY_DAYS_MS;
+    const gone = !existsSync(key);
+    if (stale || gone) {
+      delete state.files[key];
+      dropped.push(key);
+    }
+  }
+  const overflow = Object.keys(state.files).length - KEEP_MAX;
+  if (overflow > 0) {
+    const candidates = Object.entries(state.files).filter(([k]) => !protectedKeys.has(k)).sort((a, b) => a[1].lastModifiedMs - b[1].lastModifiedMs);
+    for (const [key] of candidates.slice(0, overflow)) {
+      delete state.files[key];
+      dropped.push(key);
+    }
+  }
+  if (dropped.length) {
+    console.warn(`state: GC dropped ${dropped.length} orphan entr${dropped.length === 1 ? "y" : "ies"}`);
+  }
+  return state;
+}
+function loadSpecStates() {
+  const specsDir = path4.resolve(process.cwd(), SPECS_DIR_REL);
+  if (!existsSync(specsDir)) return [];
+  let entries;
+  try {
+    entries = readdirSync2(specsDir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of entries) {
+    if (name.startsWith(".")) continue;
+    const stateFile = path4.join(specsDir, name, ".curdx-state.json");
+    if (!existsSync(stateFile)) continue;
+    try {
+      const raw = readFileSync2(stateFile, "utf8");
+      const parsed = JSON.parse(raw);
+      const phase = typeof parsed.phase === "string" ? parsed.phase : void 0;
+      if (!phase) continue;
+      out.push({ name, phase });
+    } catch {
+      continue;
+    }
+  }
+  return out;
+}
+function loadErrorEntries() {
+  if (!existsSync(ERRORS_LOG_PATH)) return [];
+  let raw;
+  try {
+    raw = readFileSync2(ERRORS_LOG_PATH, "utf8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const line of raw.split(/\r?\n/)) {
+    if (!line) continue;
+    try {
+      const parsed = JSON.parse(line);
+      const level = parsed.level === "error" || parsed.level === "info" || parsed.level === "metric" || parsed.level === "decision" ? parsed.level : "error";
+      const kind = typeof parsed.kind === "string" ? parsed.kind : "unknown";
+      const payload = parsed.payload && typeof parsed.payload === "object" && !Array.isArray(parsed.payload) ? parsed.payload : void 0;
+      const correlationId = typeof parsed.correlationId === "string" ? parsed.correlationId : void 0;
+      out.push({
+        ts: typeof parsed.ts === "string" ? parsed.ts : "",
+        ...typeof parsed.hook === "string" ? { hook: parsed.hook } : {},
+        ...typeof parsed.event === "string" ? { event: parsed.event } : {},
+        ...typeof parsed.msg === "string" ? { msg: parsed.msg } : {},
+        ...typeof parsed.cwd === "string" ? { cwd: parsed.cwd } : {},
+        ...typeof parsed.transcript_path === "string" ? { transcript_path: parsed.transcript_path } : {},
+        level,
+        kind,
+        ...payload !== void 0 ? { payload } : {},
+        ...correlationId !== void 0 ? { correlationId } : {}
+      });
+    } catch {
+      continue;
+    }
+  }
+  return out;
+}
+async function runAnalyzeInner(opts) {
+  const source = resolveTranscriptSource({
+    fixtureOverride: process.env.CURDX_TRANSCRIPT_FIXTURE,
+    sessionFilter: opts.session
+  });
+  const limit = Number(opts.limit) || 10;
+  const state = readState();
+  const pathStats = [];
+  let allCachedReady = true;
+  for (const p of source.paths) {
+    const stat = statSync3(p);
+    const prev = state.files[p];
+    const rotate = shouldRotate(prev, { sizeBytes: stat.size, lastModifiedMs: stat.mtimeMs });
+    const startOffset = rotate || !prev ? 0 : prev.byteOffset;
+    if (rotate || !prev || startOffset < stat.size) allCachedReady = false;
+    pathStats.push({ p, sizeBytes: stat.size, lastModifiedMs: stat.mtimeMs, rotate, startOffset });
+  }
+  const includePrompts = Boolean(opts.includePrompts);
+  const costSummary = opts.costSummary === true;
+  const cacheCompatible = (state.lastIncludePrompts ?? false) === includePrompts && (state.lastCostSummary ?? false) === costSummary;
+  if (allCachedReady && pathStats.length > 0 && cacheCompatible && (state.lastReportJson || state.lastReportMarkdown)) {
+    if (opts.json && state.lastReportJson) {
+      process.stdout.write(state.lastReportJson);
+      writeState(state);
+      return;
+    }
+    if (!opts.json && state.lastReportMarkdown) {
+      process.stdout.write(state.lastReportMarkdown);
+      writeState(state);
+      return;
+    }
+  }
+  const schemaMap = loadSchemaMap();
+  const counters = { unknown_type: 0, parse_error: 0, processed: 0 };
+  const collected = [];
+  try {
+    for (const { p, startOffset } of pathStats) {
+      for await (const ev of parseTranscript(p, startOffset, schemaMap, counters)) {
+        collected.push(ev);
+      }
+    }
+    const redacted = [];
+    for (const ev of collected) {
+      const r = redactEvent(ev, { includePrompts });
+      if (r) redacted.push(r);
+    }
+    const filtered = filterEvents(redacted, { ...opts, limit });
+    const errorEntries = loadErrorEntries();
+    const specStates = loadSpecStates();
+    let costBreakdown;
+    let recommendations = [];
+    if (opts.costSummary === true) {
+      let specPhaseMap = {};
+      try {
+        for (const s of specStates) {
+          if (s && typeof s.name === "string" && typeof s.phase === "string") {
+            specPhaseMap[s.name] = s.phase;
+          }
+        }
+      } catch {
+        specPhaseMap = {};
+      }
+      const usageRows = extractUsageRowsFromEvents(filtered, errorEntries);
+      let totalUsd = 0;
+      for (const r of usageRows) totalUsd += computeCost(r);
+      totalUsd = Math.round(totalUsd * 1e4) / 1e4;
+      const anyByFlag = opts.bySpec === true || opts.byPhase === true || opts.byTask === true;
+      const wantSpec = anyByFlag ? opts.bySpec === true : true;
+      const wantPhase = anyByFlag ? opts.byPhase === true : true;
+      const wantTask = anyByFlag ? opts.byTask === true : true;
+      const top = typeof opts.top === "number" && Number.isFinite(opts.top) && opts.top > 0 ? Math.floor(opts.top) : 10;
+      const costAggregates = {};
+      if (wantSpec) costAggregates.spec = aggregateBy(usageRows, "spec", { specPhaseMap });
+      if (wantPhase) costAggregates.phase = aggregateBy(usageRows, "phase", { specPhaseMap });
+      if (wantTask) {
+        const taskBuckets = aggregateBy(usageRows, "task", { specPhaseMap });
+        costAggregates.task = taskBuckets.slice(0, top);
+      }
+      const taskBucketsAll = costAggregates.task ?? [];
+      const r7TopN = taskBucketsAll.slice(0, top);
+      costBreakdown = {
+        R1_perSpec: costAggregates.spec ?? [],
+        R2_perPhase: costAggregates.phase ?? [],
+        R3_perTask: taskBucketsAll,
+        R4_cacheHit: [],
+        R5_wallClock: [],
+        R6_modelMix: [],
+        R7_topN: r7TopN,
+        totalCost: { usd: totalUsd }
+      };
+      try {
+        const allBuckets = [
+          ...costAggregates.spec ?? [],
+          ...costAggregates.phase ?? [],
+          ...taskBucketsAll
+        ];
+        recommendations = recommend(allBuckets, {
+          errorEntries,
+          criticalPhases: ["critical", "debug-hard", "security"]
+        });
+      } catch {
+        recommendations = [];
+      }
+    }
+    const { markdown, json } = renderReport(filtered, errorEntries, specStates, {
+      ...opts,
+      limit,
+      schemaDrift: {
+        unknownTypeCount: counters.unknown_type,
+        parseErrorCount: counters.parse_error
+      },
+      ...costBreakdown ? { costBreakdown } : {},
+      ...recommendations.length > 0 ? { recommendations } : {}
+    });
+    const safeJson = redactReportFields(json, { includePrompts });
+    void opts.out;
+    const markdownStr = markdown;
+    let jsonObj = safeJson;
+    if (opts.costSummary === true && costBreakdown) {
+      jsonObj = {
+        ...jsonObj,
+        totalCost: { usd: costBreakdown.totalCost.usd },
+        costBreakdown,
+        recommendations
+      };
+    }
+    const jsonStr = `${JSON.stringify(jsonObj)}
+`;
+    state.lastReportJson = jsonStr;
+    state.lastReportMarkdown = markdownStr;
+    state.lastIncludePrompts = includePrompts;
+    state.lastCostSummary = costSummary;
+    if (opts.json) {
+      process.stdout.write(jsonStr);
+    } else {
+      process.stdout.write(markdownStr);
+    }
+    void safeJson;
+    if (counters.parse_error || counters.unknown_type) {
+      process.stderr.write(
+        `(analyze: parse_error=${counters.parse_error} unknown_type=${counters.unknown_type} processed=${counters.processed})
+`
+      );
+    }
+  } finally {
+    for (const ps of pathStats) {
+      state.files[ps.p] = {
+        byteOffset: ps.sizeBytes,
+        lastModifiedMs: ps.lastModifiedMs,
+        sizeBytes: ps.sizeBytes
+      };
+    }
+    void getStateForPath;
+    try {
+      cleanupOrphanState(state, pathStats.map((ps) => ps.p));
+    } catch (err) {
+      console.warn("state: GC failed (continuing without cleanup):", err.message);
+    }
+    writeState(state);
+  }
+}
+async function runAnalyze(opts) {
+  try {
+    await runAnalyzeInner(opts);
+  } catch (err) {
+    if (err instanceof TranscriptNotFoundError) {
+      process.stderr.write(`warning: no transcripts found at ${err.path}
+`);
+      process.stderr.write(`hint: ${err.hint}
+`);
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+export {
+  cleanupOrphanState,
+  runAnalyze
+};