@mingozhou/dsh-replay 0.3.3 → 0.4.2

package/lib/core.js

@@ -90,11 +90,34 @@ function fromInspection(header, records) {
 // src/core/timeline.ts
 function contentText(message) {
   if (!message?.content) return "";
-  return message.content.filter((b) => typeof b.text === "string").map((b) => b.text).join("");
+  return message.content.filter((b) => typeof b.text === "string" && b.type !== "reasoning").map((b) => b.text).join("");
+}
+function contentReasoning(message) {
+  if (!message?.content) return "";
+  return message.content.filter((b) => b.type === "reasoning" && typeof b.text === "string").map((b) => b.text).join("");
+}
+function oneLine(text, max) {
+  return truncate(text.replaceAll(/\s+/gu, " ").trim(), max);
+}
+function summarizeToolArguments(name, raw) {
+  let args;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null) args = parsed;
+  } catch {
+    args = void 0;
+  }
+  if (args === void 0) return oneLine(raw, 64);
+  const keys = ["command", "cmd", "script", "path", "file_path", "filePath", "url", "query", "pattern", "description"];
+  for (const key of keys) {
+    const value = args[key];
+    if (typeof value === "string" && value.trim() !== "") return oneLine(value, 64);
+  }
+  return name;
 }
 function truncate(text, max = 96) {
-  const oneLine = text.replaceAll(/\s+/gu, " ").trim();
-  return oneLine.length > max ? `${oneLine.slice(0, max - 1)}\u2026` : oneLine;
+  const oneLine2 = text.replaceAll(/\s+/gu, " ").trim();
+  return oneLine2.length > max ? `${oneLine2.slice(0, max - 1)}\u2026` : oneLine2;
 }
 function tryPretty(raw) {
   try {
@@ -170,10 +193,13 @@ function buildTimeline(session) {
   const toolCallsBySeq = /* @__PURE__ */ new Map();
   const toolCalls = [];
   const usageByStep = /* @__PURE__ */ new Map();
+  const usageModelByStep = /* @__PURE__ */ new Map();
+  const modelTotals = {};
   const models = /* @__PURE__ */ new Set();
   const shadowed = shadowedSeqs(events);
   let seedBoundarySeq;
   let activeTurn;
+  let activeModel;
   let sessionTitle;
   const ensureTurn = (turn, event) => {
     let model = turns.get(turn);
@@ -245,10 +271,16 @@ function buildTimeline(session) {
         const message = get(d, "message");
         const usage = get(d, "usage");
         const text = contentText(message);
+        const reasoningText = contentReasoning(message);
         const source = message?.source;
-        if (typeof source?.["model"] === "string") models.add(source["model"]);
+        if (typeof source?.["model"] === "string") {
+          activeModel = source["model"];
+          models.add(activeModel);
+        }
         if (usage) {
-          usageByStep.set(`${String(turn)}/${String(step)}`, usage);
+          const key = `${String(turn)}/${String(step)}`;
+          usageByStep.set(key, usage);
+          if (activeModel !== void 0) usageModelByStep.set(key, activeModel);
         }
         push({
           kind: "assistant",
@@ -259,6 +291,7 @@ function buildTimeline(session) {
           type: event.type,
           label: truncate(text) || "(assistant message)",
           text,
+          reasoningText,
           usage,
           event
         });
@@ -268,16 +301,23 @@ function buildTimeline(session) {
         const chunk = get(d, "chunk");
         if (get(chunk, "type") === "usage") {
           const usage = get(chunk, "usage");
-          usageByStep.set(`${String(turn)}/${String(step)}`, usage);
+          const key = `${String(turn)}/${String(step)}`;
+          usageByStep.set(key, usage);
+          if (activeModel !== void 0 && !usageModelByStep.has(key)) {
+            usageModelByStep.set(key, activeModel);
+          }
         }
         break;
       }
       case "tool/call": {
+        const raw = String(get(d, "arguments") ?? "");
+        const name = String(get(d, "name") ?? "");
         const info = {
           callId: String(get(d, "callId") ?? ""),
-          name: String(get(d, "name") ?? ""),
-          argumentsRaw: String(get(d, "arguments") ?? ""),
-          argumentsPretty: tryPretty(String(get(d, "arguments") ?? "")),
+          name,
+          argumentsRaw: raw,
+          argumentsPretty: tryPretty(raw),
+          summary: summarizeToolArguments(name, raw),
           callSeq: event.seq,
           callTime: event.time
         };
@@ -290,7 +330,7 @@ function buildTimeline(session) {
           turn,
           step,
           type: event.type,
-          label: `${info.name}(${truncate(info.argumentsRaw, 48)})`,
+          label: info.summary === name ? name : `${name} \xB7 ${info.summary}`,
           toolCall: info,
           event
         });
@@ -302,7 +342,7 @@ function buildTimeline(session) {
         const callId = String(source?.["callId"] ?? "");
         const info = toolCallsBySeq.get(callId);
         const block = message?.content?.[0];
-        const resultText = typeof get(block, "text") === "string" ? get(block, "text") : contentText({ content: get(block, "content") });
+        const resultText = contentText(message) || (typeof get(block, "text") === "string" ? get(block, "text") : contentText({ content: get(block, "content") }));
         const error = get(d, "error");
         if (info) {
           info.resultSeq = event.seq;
@@ -324,9 +364,44 @@ function buildTimeline(session) {
           event
         });
         break;
+      case "system/message": {
+        const message = get(d, "message");
+        const text = contentText(message);
+        push({
+          kind: "meta",
+          seq: event.seq,
+          time: event.time,
+          turn: typeof turn === "number" ? turn : void 0,
+          step: typeof step === "number" ? step : void 0,
+          type: event.type,
+          label: "system prompt",
+          text,
+          event
+        });
+        break;
+      }
+      case "model/selection": {
+        const model = get(d, "model");
+        if (typeof model === "string" && model !== "") {
+          activeModel = model;
+          models.add(model);
+          push({
+            kind: "meta",
+            seq: event.seq,
+            time: event.time,
+            type: event.type,
+            label: `model selected: ${model}`,
+            event
+          });
+        }
+        break;
+      }
       case "request/context": {
         const model = get(d, "model");
-        if (typeof model === "string") models.add(model);
+        if (typeof model === "string") {
+          activeModel = model;
+          models.add(model);
+        }
         break;
       }
       case "session/title": {
@@ -353,13 +428,31 @@ function buildTimeline(session) {
     }
   }
   const totals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0, billedInput: 0 };
+  const emptyTotals = () => ({
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    reasoning: 0,
+    billedInput: 0
+  });
   for (const [key, usage] of usageByStep) {
     const [turnStr, stepStr] = key.split("/");
+    const billed = usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0);
     totals.input += usage.inputTokens;
     totals.output += usage.outputTokens;
     totals.cacheRead += usage.cacheReadTokens ?? 0;
     totals.cacheWrite += usage.cacheWriteTokens ?? 0;
     totals.reasoning += usage.reasoningTokens ?? 0;
+    const modelName = usageModelByStep.get(key) ?? activeModel ?? "unknown";
+    const modelTotal = modelTotals[modelName] ?? emptyTotals();
+    modelTotal.input += usage.inputTokens;
+    modelTotal.output += usage.outputTokens;
+    modelTotal.cacheRead += usage.cacheReadTokens ?? 0;
+    modelTotal.cacheWrite += usage.cacheWriteTokens ?? 0;
+    modelTotal.reasoning += usage.reasoningTokens ?? 0;
+    modelTotal.billedInput += billed;
+    modelTotals[modelName] = modelTotal;
     const turnModel = turns.get(Number(turnStr));
     const stepModel = turnModel?.steps.find((s) => s.step === Number(stepStr));
     if (stepModel) stepModel.usage = usage;
@@ -381,6 +474,7 @@ function buildTimeline(session) {
     turns: orderedTurns,
     items,
     totals,
+    modelTotals,
     usageSamples,
     toolCalls,
     durationMs: endTime - startTime,
@@ -393,129 +487,383 @@ function buildTimeline(session) {
   };
 }
 
+// src/core/redact.ts
+var RULES = [
+  { kind: "openai-key", re: /\bsk-[A-Za-z0-9_-]{16,}\b/g, replacement: "[REDACTED:openai-key]" },
+  {
+    kind: "github-token",
+    re: /\b(?:gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,})\b/g,
+    replacement: "[REDACTED:github-token]"
+  },
+  { kind: "aws-key", re: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g, replacement: "[REDACTED:aws-key]" },
+  { kind: "google-key", re: /\bAIza[0-9A-Za-z_-]{20,}\b/g, replacement: "[REDACTED:google-key]" },
+  { kind: "slack-token", re: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g, replacement: "[REDACTED:slack-token]" },
+  {
+    kind: "private-key",
+    re: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+    replacement: "[REDACTED:private-key]"
+  },
+  {
+    kind: "jwt",
+    re: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g,
+    replacement: "[REDACTED:jwt]"
+  },
+  {
+    kind: "env-assignment",
+    re: /(\b[A-Z][A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD|PRIVATE|CREDENTIAL)[A-Z0-9_]*\s*=\s*)(["']?)([^\s"'\\]{4,})\2/g,
+    replacement: (_m, prefix, quote) => `${prefix}${quote}[REDACTED]${quote}`
+  },
+  {
+    kind: "key-value",
+    re: /(["']?(?:api[_-]?key|secret|token|password|passwd|authorization|jwt[_-]?secret)["']?\s*[:=]\s*["']?)([^"'\s,}]{4,})/gi,
+    replacement: (_m, prefix) => `${prefix}[REDACTED]`
+  },
+  { kind: "bearer", re: /(\bBearer\s+)[A-Za-z0-9._~+/-]{8,}/gi, replacement: "$1[REDACTED]" },
+  {
+    kind: "basic-auth-url",
+    re: /(https?:\/\/[^/\s:@]+:)([^@\s/]+)(@)/g,
+    replacement: "$1[REDACTED]$3"
+  },
+  { kind: "windows-user", re: /([A-Za-z]:\\Users\\)([^\\\s"']+)/g, replacement: "$1[user]" },
+  { kind: "unix-home", re: /(\/(?:home|Users)\/)([^/\s"']+)/g, replacement: "$1[user]" },
+  { kind: "email", re: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g, replacement: "[email]" },
+  { kind: "session-id", re: /\bsession-[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}\b/gi, replacement: "session-[id]" }
+];
+var CREDENTIAL_KINDS = /* @__PURE__ */ new Set([
+  "openai-key",
+  "github-token",
+  "aws-key",
+  "google-key",
+  "slack-token",
+  "private-key",
+  "jwt",
+  "env-assignment",
+  "key-value",
+  "bearer",
+  "basic-auth-url"
+]);
+function redactText(input) {
+  let text = input;
+  let count = 0;
+  const kinds = /* @__PURE__ */ new Set();
+  for (const rule of RULES) {
+    rule.re.lastIndex = 0;
+    const matches = text.match(rule.re);
+    if (matches === null) continue;
+    count += matches.length;
+    kinds.add(rule.kind);
+    rule.re.lastIndex = 0;
+    text = text.replace(rule.re, rule.replacement);
+  }
+  return { text, count, kinds: [...kinds] };
+}
+function containsSecret(input) {
+  for (const rule of RULES) {
+    if (!CREDENTIAL_KINDS.has(rule.kind)) continue;
+    rule.re.lastIndex = 0;
+    const hit = rule.re.test(input);
+    rule.re.lastIndex = 0;
+    if (hit) return true;
+  }
+  return false;
+}
+function redactValue(value, depth = 0) {
+  if (depth > 20) return { value, count: 0 };
+  if (typeof value === "string") {
+    const result = redactText(value);
+    return { value: result.text, count: result.count };
+  }
+  if (Array.isArray(value)) {
+    let count = 0;
+    const next = value.map((item) => {
+      const result = redactValue(item, depth + 1);
+      count += result.count;
+      return result.value;
+    });
+    return { value: next, count };
+  }
+  if (typeof value === "object" && value !== null) {
+    let count = 0;
+    const next = {};
+    for (const [key, item] of Object.entries(value)) {
+      const result = redactValue(item, depth + 1);
+      count += result.count;
+      next[key] = result.value;
+    }
+    return { value: next, count };
+  }
+  return { value, count: 0 };
+}
+function redactSession(session) {
+  let count = 0;
+  const kinds = /* @__PURE__ */ new Set();
+  const header = { ...session.header };
+  for (const key of ["cwd", "title"]) {
+    const value = header[key];
+    if (typeof value === "string") {
+      const result = redactText(value);
+      header[key] = result.text;
+      count += result.count;
+      for (const kind of result.kinds) kinds.add(kind);
+    }
+  }
+  const events = session.events.map((event) => {
+    const data = redactValue(event.data);
+    count += data.count;
+    if (data.count > 0) {
+      for (const rule of RULES) {
+        rule.re.lastIndex = 0;
+        if (rule.re.test(JSON.stringify(event.data))) kinds.add(rule.kind);
+        rule.re.lastIndex = 0;
+      }
+    }
+    return { ...event, data: data.value };
+  });
+  return { session: { ...session, header, events }, count, kinds: [...kinds] };
+}
+
 // src/core/audit.ts
 function get2(obj, key) {
   return typeof obj === "object" && obj !== null ? obj[key] : void 0;
 }
 function str(value) {
-  return typeof value === "string" ? value : JSON.stringify(value) ?? "";
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "";
+  }
+}
+function clipped(value, max = 500) {
+  return redactText(value).text.slice(0, max);
 }
-var SHELL_TOOLS = /^(bash|shell|exec|run_command|terminal|subprocess)/iu;
-var WRITE_TOOLS = /^(write|edit|create_file|str_replace|apply_patch|notebook_edit|fs_write|mv|rm|delete)/iu;
-var NETWORK_TOOLS = /^(fetch|web_fetch|http|curl|download|web_search|browser)/iu;
+function toolName(event) {
+  return str(get2(event.data, "name"));
+}
+function argsOf(event) {
+  return str(get2(event.data, "arguments"));
+}
+function parseArgs(raw) {
+  try {
+    const value = JSON.parse(raw);
+    return typeof value === "object" && value !== null ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var PATH_KEYS = [
+  "path",
+  "file_path",
+  "filePath",
+  "target",
+  "destination",
+  "dest",
+  "filename",
+  "file",
+  "name"
+];
+function pathOf(raw) {
+  const args = parseArgs(raw);
+  if (args === void 0) return void 0;
+  for (const key of PATH_KEYS) {
+    const value = args[key];
+    if (typeof value === "string" && value !== "" && /[\\/.]/u.test(value)) return value;
+  }
+  return void 0;
+}
+var SHELL_TOOLS = /^(bash|shell|exec|run_command|terminal|subprocess|pwsh|powershell|cmd|run_code|code_execution)/iu;
+var WRITE_TOOLS = /^(write|write_file|edit|edit_file|create_file|str_replace|multi_edit|apply_patch|notebook_edit|fs_write|mv|move|rename|copy|rm|remove|delete|del|remove_item|rmdir|rd)/iu;
+var DESTRUCTIVE_TOOLS = /^(rm|remove|delete|del|remove_item|rmdir|rd|mv|move|rename)/iu;
+var READ_TOOLS = /^(read|read_file|view|open|cat|type|get-content|grep|search|glob|list|find|head|tail|less|more|strings|xxd)/iu;
+var NETWORK_TOOLS = /^(fetch|web_fetch|http|curl|download|web_search|browser|invoke-webrequest|iwr|invoke-restmethod|start-bitstransfer)/iu;
 var DANGEROUS_SHELL = [
-  { re: /\brm\s+(-[a-z]*[rf][a-z]*\s+)+/iu, why: "recursive/forced delete", key: "rm-rf" },
-  { re: /\bsudo\b/u, why: "privilege escalation", key: "sudo" },
-  { re: /\bchmod\s+([0-7]{3,4}|\+x)/u, why: "permission change", key: "chmod" },
-  { re: /\b(curl|wget)\b[^|;&]*\|\s*(ba)?sh\b/iu, why: "pipe remote script to shell", key: "curl-pipe" },
-  { re: /\bgit\s+push\s+.*--force/iu, why: "force push", key: "force-push" },
-  { re: /\b(dd|mkfs|fdisk)\b/u, why: "raw disk operation", key: "disk" },
-  { re: /(\bssh\b|\bscp\b|\brsync\b.*@)/u, why: "remote host access", key: "remote" },
-  { re: /\b(export|echo)\b.*\b(API_?KEY|TOKEN|SECRET|PASSWORD)\b/iu, why: "credential material in command", key: "creds" }
+  // --- destructive deletes -------------------------------------------------
+  { re: /\brm\s+(-[a-z]*[rf][a-z]*\s+)+/iu, why: "recursive/forced delete", key: "rm-rf", severity: "critical" },
+  { re: /\bremove-item\b[^\n]*(?:-recurse|-force)/iu, why: "recursive/forced delete", key: "rm-rf", severity: "critical" },
+  { re: /\b(?:del|erase)\b[^\n]*\/[sq]/iu, why: "forced delete", key: "rm-rf", severity: "critical" },
+  { re: /\b(?:rd|rmdir)\b[^\n]*\/s/iu, why: "recursive directory delete", key: "rm-rf", severity: "critical" },
+  // --- privilege / system --------------------------------------------------
+  { re: /\bsudo\b/iu, why: "privilege escalation", key: "sudo", severity: "critical" },
+  { re: /\b(?:takeown|icacls)\b[^\n]*(?:grant|\/grant|\/f|\/reset)/iu, why: "ownership/permission change", key: "chmod", severity: "serious" },
+  { re: /\bchmod\s+([0-7]{3,4}|\+x)/u, why: "permission change", key: "chmod", severity: "serious" },
+  { re: /\bset-executionpolicy\b/iu, why: "script execution policy change", key: "exec-policy", severity: "serious" },
+  { re: /\b(?:bcdedit|vssadmin\s+delete|wevtutil\s+cl)\b/iu, why: "boot/shadow/log tampering", key: "system-tamper", severity: "critical" },
+  { re: /\b(?:reg\s+delete|schtasks\b[^\n]*\/create|sc\s+create|net\s+user|net\s+localgroup)\b/iu, why: "persistence or account change", key: "persistence", severity: "serious" },
+  // --- disk / remote code --------------------------------------------------
+  { re: /\b(?:dd|mkfs|fdisk|diskpart|format)\b/iu, why: "raw disk operation", key: "disk", severity: "critical" },
+  { re: /\b(?:iwr|invoke-webrequest|curl|wget|start-bitstransfer)\b[^\n|;]*(?:\||;)\s*(?:iex|invoke-expression)\b/iu, why: "pipe remote script to shell", key: "curl-pipe", severity: "critical" },
+  { re: /\b(?:downloadstring|downloadfile)\b/iu, why: "download and execute", key: "curl-pipe", severity: "critical" },
+  { re: /\b(?:powershell|pwsh)\b[^\n]*-e(?:nc|ncodedcommand)?\s+[A-Za-z0-9+/=]{40,}/iu, why: "encoded PowerShell command", key: "encoded-shell", severity: "critical" },
+  // --- credentials / exfiltration -----------------------------------------
+  { re: /\b(?:export|\$env:|\bset\b|\becho\b)[^\n]*(?:api[_-]?key|token|secret|password|passwd)/iu, why: "credential material in command", key: "creds", severity: "serious" },
+  { re: /\b(?:get-content|type|cat)\b[^\n]*(?:\.env\b|id_rsa|\.ssh[\\/]|credentials)/iu, why: "credential file read", key: "creds", severity: "serious" },
+  { re: /\b(?:curl|wget|iwr|invoke-webrequest|invoke-restmethod)\b[^\n]*(?:-d\b|--data|--upload-file|-f\b|\.env\b|secret|token|password)/iu, why: "possible credential exfiltration", key: "exfil", severity: "critical" },
+  { re: /\b(?:ssh|scp|rsync)\b[^\n]*(?:@|\bremote\b)/iu, why: "remote host access", key: "remote", severity: "warning" },
+  { re: /\b(?:invoke-command|enter-pssession|winrs)\b/iu, why: "remote execution", key: "remote", severity: "serious" },
+  // --- supply chain / repo ------------------------------------------------
+  { re: /\bgit\s+push\s+[^\n]*--force/iu, why: "force push", key: "force-push", severity: "serious" },
+  { re: /\b(?:npm|pnpm|yarn)\s+publish\b/iu, why: "package publish", key: "publish", severity: "warning" },
+  { re: /\bgh\s+release\s+create\b/iu, why: "release publish", key: "publish", severity: "warning" }
 ];
-var SENSITIVE_PATH = /(\.env\b|\.ssh\/|id_rsa|\.aws\/|credentials|\.npmrc|\.netrc|secrets?\.|\.pem\b)/iu;
+var SENSITIVE_PATH = /(?:^|[\\/])(?:\.env(?:\.[\w-]+)?(?:[\\/]|$)|\.ssh(?:[\\/]|$)|id_rsa|id_ed25519|\.aws(?:[\\/]|$)|\.kube(?:[\\/]|$)|\.docker(?:[\\/]config\.json|$)|credentials|\.npmrc|\.netrc|secrets?\.|\.pem|\.pfx|\.p12|ntuser\.dat|\.git[\\/]config|\.config[\\/]gh[\\/]hosts\.yml)/iu;
+var NETWORK_RISK = /(?:--data|-d\s|--upload-file|-f\s|body\s*[:=]|\.env\b|secret|token|password|passwd|private[_-]?key|authorization|api[_-]?key)/iu;
+function messageText(message) {
+  const content = get2(message, "content");
+  if (!Array.isArray(content)) return "";
+  return content.map((block) => typeof get2(block, "text") === "string" ? get2(block, "text") : "").join("");
+}
+function findDanger(event) {
+  if (event.type !== "tool/call") return void 0;
+  const name = toolName(event);
+  if (!SHELL_TOOLS.test(name)) return void 0;
+  const args = argsOf(event);
+  return DANGEROUS_SHELL.find((pattern) => pattern.re.test(args));
+}
 var DEFAULT_RULES = [
   {
     id: "shell-exec",
-    severity: (event) => {
-      const args = str(get2(event.data, "arguments"));
-      return DANGEROUS_SHELL.some((p) => p.re.test(args)) ? "critical" : "warning";
-    },
+    category: "shell",
+    severity: (event) => findDanger(event)?.severity ?? "warning",
     match: (event) => {
       if (event.type !== "tool/call") return void 0;
-      const name = str(get2(event.data, "name"));
+      const name = toolName(event);
       if (!SHELL_TOOLS.test(name)) return void 0;
-      const args = str(get2(event.data, "arguments"));
-      const hit = DANGEROUS_SHELL.find((p) => p.re.test(args));
+      const args = argsOf(event);
+      const hit = DANGEROUS_SHELL.find((pattern) => pattern.re.test(args));
+      if (hit === void 0) return void 0;
       return {
-        title: hit ? `shell: ${hit.why}` : `shell command via ${name}`,
-        detail: args.slice(0, 400),
-        messageKey: hit ? "f.shell.dangerous" : "f.shell.plain",
-        params: hit ? { whyKey: hit.key, why: hit.why } : { name }
+        title: `shell: ${hit.why}`,
+        detail: clipped(args),
+        messageKey: "f.shell.dangerous",
+        params: { whyKey: hit.key, why: hit.why, name }
       };
     }
   },
   {
     id: "file-write",
-    severity: (event) => SENSITIVE_PATH.test(str(get2(event.data, "arguments"))) ? "critical" : "info",
+    category: "file",
+    severity: (event) => {
+      const args = argsOf(event);
+      const path = pathOf(args) ?? args;
+      return SENSITIVE_PATH.test(path) || containsSecret(args) ? "critical" : "warning";
+    },
     match: (event) => {
       if (event.type !== "tool/call") return void 0;
-      const name = str(get2(event.data, "name"));
+      const name = toolName(event);
       if (!WRITE_TOOLS.test(name)) return void 0;
-      const args = str(get2(event.data, "arguments"));
-      const sensitive = SENSITIVE_PATH.test(args);
+      const args = argsOf(event);
+      const path = pathOf(args) ?? args;
+      const sensitive = SENSITIVE_PATH.test(path);
+      const secret = containsSecret(args);
+      if (!sensitive && !secret && !DESTRUCTIVE_TOOLS.test(name)) return void 0;
+      const reason = sensitive ? "file write touches a sensitive path" : secret ? "credential material written to a file" : `destructive file operation via ${name}`;
       return {
-        title: sensitive ? `file write touches sensitive path` : `file mutation via ${name}`,
-        detail: args.slice(0, 400),
-        messageKey: sensitive ? "f.file.sensitive" : "f.file.write",
-        params: { name }
+        title: reason,
+        detail: clipped(args),
+        messageKey: sensitive ? "f.file.sensitive" : secret ? "f.file.secret" : "f.file.destructive",
+        params: { name, ...path !== args ? { path } : {} }
       };
     }
   },
   {
     id: "sensitive-read",
+    category: "file",
     severity: "serious",
     match: (event) => {
       if (event.type !== "tool/call") return void 0;
-      const args = str(get2(event.data, "arguments"));
-      const name = str(get2(event.data, "name"));
-      if (WRITE_TOOLS.test(name) || SHELL_TOOLS.test(name)) return void 0;
-      if (!SENSITIVE_PATH.test(args)) return void 0;
+      const name = toolName(event);
+      if (WRITE_TOOLS.test(name) || SHELL_TOOLS.test(name) || NETWORK_TOOLS.test(name)) return void 0;
+      if (!READ_TOOLS.test(name)) return void 0;
+      const args = argsOf(event);
+      const path = pathOf(args) ?? args;
+      if (!SENSITIVE_PATH.test(path)) return void 0;
       return {
         title: `access to sensitive path via ${name}`,
-        detail: args.slice(0, 400),
+        detail: clipped(args),
         messageKey: "f.read.sensitive",
-        params: { name }
+        params: { name, ...path !== args ? { path } : {} }
       };
     }
   },
   {
     id: "network",
-    severity: "info",
+    category: "network",
+    severity: (event) => {
+      const args = argsOf(event);
+      return containsSecret(args) || SENSITIVE_PATH.test(args) ? "critical" : "warning";
+    },
     match: (event) => {
       if (event.type !== "tool/call") return void 0;
-      const name = str(get2(event.data, "name"));
+      const name = toolName(event);
       if (!NETWORK_TOOLS.test(name)) return void 0;
+      const args = argsOf(event);
+      if (!NETWORK_RISK.test(args)) return void 0;
       return {
-        title: `network access via ${name}`,
-        detail: str(get2(event.data, "arguments")).slice(0, 400),
+        title: `network request may carry sensitive data via ${name}`,
+        detail: clipped(args),
         messageKey: "f.network",
         params: { name }
       };
     }
   },
+  {
+    id: "secret-output",
+    category: "secret",
+    severity: "critical",
+    match: (event) => {
+      if (event.type !== "tool/result") return void 0;
+      const message = get2(event.data, "message");
+      const text = messageText(message) || str(message) || str(get2(event.data, "error"));
+      if (text === "" || !containsSecret(text)) return void 0;
+      return {
+        title: "tool output contains credential material",
+        detail: clipped(text, 300),
+        messageKey: "f.output.secret"
+      };
+    }
+  },
   {
     id: "approval-denied",
+    category: "approval",
     severity: "warning",
     match: (event) => {
       if (event.type !== "approval/decided") return void 0;
       const outcome = str(get2(event.data, "outcome") ?? get2(event.data, "decision"));
-      if (!/den|reject|refus/iu.test(outcome)) return void 0;
-      return { title: "user denied an approval", detail: outcome, messageKey: "f.approval.denied" };
+      if (!/deny|denied|reject|refus/iu.test(outcome)) return void 0;
+      return { title: "user denied an approval", detail: clipped(outcome), messageKey: "f.approval.denied" };
     }
   },
   {
     id: "sandbox-change",
-    severity: "serious",
-    match: (event) => event.type === "sandbox/mode" ? { title: "sandbox mode changed", detail: JSON.stringify(event.data), messageKey: "f.sandbox.change" } : void 0
+    category: "config",
+    severity: (event) => {
+      const mode = str(get2(event.data, "mode"));
+      return /danger|full/iu.test(mode) ? "critical" : "serious";
+    },
+    match: (event) => event.type === "sandbox/mode" ? {
+      title: `sandbox mode changed to ${str(get2(event.data, "mode")) || "unknown"}`,
+      detail: clipped(JSON.stringify(event.data)),
+      messageKey: "f.sandbox.change",
+      params: { mode: str(get2(event.data, "mode")) }
+    } : void 0
   },
   {
     id: "permission-change",
-    severity: "serious",
-    match: (event) => event.type === "permission/preset" ? { title: "permission preset changed", detail: JSON.stringify(event.data), messageKey: "f.permission.change" } : void 0
-  },
-  {
-    id: "subagent",
-    severity: "info",
-    match: (event) => event.type === "subagent/descriptor" ? {
-      title: `subagent spawned (${str(get2(event.data, "mode"))})`,
-      detail: str(get2(event.data, "persona") ?? get2(event.data, "label") ?? ""),
-      messageKey: "f.subagent",
-      params: { mode: str(get2(event.data, "mode")) }
+    category: "config",
+    severity: (event) => {
+      const preset = str(get2(event.data, "preset"));
+      return /danger|full/iu.test(preset) ? "critical" : "serious";
+    },
+    match: (event) => event.type === "permission/preset" ? {
+      title: `permission preset changed to ${str(get2(event.data, "preset")) || "unknown"}`,
+      detail: clipped(JSON.stringify(event.data)),
+      messageKey: "f.permission.change",
+      params: { preset: str(get2(event.data, "preset")) }
     } : void 0
   },
   {
     id: "tool-error",
+    category: "error",
     severity: "warning",
     match: (event) => {
       if (event.type !== "tool/result") return void 0;
@@ -523,32 +871,62 @@ var DEFAULT_RULES = [
       if (error === void 0) return void 0;
       return {
         title: `tool failed: ${str(get2(error, "name"))}`,
-        detail: str(get2(error, "code")),
+        detail: clipped(str(get2(error, "code"))),
         messageKey: "f.tool.error",
-        params: { name: str(get2(error, "name")) }
+        params: { name: str(get2(error, "name")), code: str(get2(error, "code")) }
       };
     }
   },
   {
     id: "turn-error",
+    category: "error",
     severity: "warning",
     match: (event) => {
       if (event.type !== "turn/end") return void 0;
       const kind = str(get2(get2(event.data, "reason"), "kind"));
-      if (kind === "completed" || kind === "") return void 0;
+      if (kind === "" || kind === "completed" || kind === "aborted") return void 0;
       return { title: `turn ended abnormally: ${kind}`, messageKey: "f.turn.error", params: { kind } };
     }
   }
 ];
 var SEVERITY_ORDER = ["critical", "serious", "warning", "info"];
+var CONFIG_RULES = /* @__PURE__ */ new Set(["sandbox-change", "permission-change"]);
 function auditSession(session, rules = DEFAULT_RULES) {
+  const lastConfig = /* @__PURE__ */ new Map();
+  const changedConfig = /* @__PURE__ */ new Set();
+  let suppressed = 0;
+  for (const event of session.events) {
+    if (event.type !== "permission/preset" && event.type !== "sandbox/mode" && event.type !== "approval/policy") {
+      continue;
+    }
+    const value = JSON.stringify(event.data);
+    if (!lastConfig.has(event.type)) {
+      lastConfig.set(event.type, value);
+      suppressed++;
+      continue;
+    }
+    if (lastConfig.get(event.type) === value) {
+      suppressed++;
+      continue;
+    }
+    lastConfig.set(event.type, value);
+    changedConfig.add(event.seq);
+  }
   const findings = [];
   for (const event of session.events) {
     for (const rule of rules) {
+      if (CONFIG_RULES.has(rule.id) && !changedConfig.has(event.seq)) continue;
       const hit = rule.match(event);
       if (hit === void 0) continue;
       const severity = typeof rule.severity === "function" ? rule.severity(event) : rule.severity;
-      findings.push({ ruleId: rule.id, severity, seq: event.seq, time: event.time, ...hit });
+      findings.push({
+        ruleId: rule.id,
+        severity,
+        category: hit.category ?? rule.category,
+        seq: event.seq,
+        time: event.time,
+        ...hit
+      });
     }
   }
   findings.sort(
@@ -556,7 +934,7 @@ function auditSession(session, rules = DEFAULT_RULES) {
   );
   const counts = { critical: 0, serious: 0, warning: 0, info: 0 };
   for (const finding of findings) counts[finding.severity]++;
-  return { findings, counts };
+  return { findings, counts, scanned: session.events.length, rules: rules.length, suppressed };
 }
 
 // src/core/forktree.ts
@@ -654,54 +1032,139 @@ function stats(session, timeline, title) {
 function eventFingerprint(event) {
   return `${event.type}\0${JSON.stringify(event.data)}`;
 }
-function compareSessions(a, b, titles) {
+function relatedBy(a, b, parentOf) {
+  if (a.header.id === b.header.id) return "same";
+  if (b.header.parentSession === a.header.id) return "a-parent-of-b";
+  if (a.header.parentSession === b.header.id) return "b-parent-of-a";
+  const ancestorsOfB = /* @__PURE__ */ new Set();
+  let cursor = b.header.parentSession;
+  while (cursor !== void 0 && !ancestorsOfB.has(cursor)) {
+    ancestorsOfB.add(cursor);
+    cursor = parentOf(cursor);
+  }
+  if (ancestorsOfB.has(a.header.id)) return "a-parent-of-b";
+  const ancestorsOfA = /* @__PURE__ */ new Set();
+  cursor = a.header.parentSession;
+  while (cursor !== void 0 && !ancestorsOfA.has(cursor)) {
+    ancestorsOfA.add(cursor);
+    cursor = parentOf(cursor);
+  }
+  if (ancestorsOfA.has(b.header.id)) return "b-parent-of-a";
+  if (a.header.parentSession !== void 0 && a.header.parentSession === b.header.parentSession) {
+    return "siblings";
+  }
+  return "none";
+}
+function compareSessions(a, b, titles, parentOf = () => void 0) {
   const timelineA = buildTimeline(a);
   const timelineB = buildTimeline(b);
   const statsA = stats(a, timelineA, titles?.a);
   const statsB = stats(b, timelineB, titles?.b);
   const toolNames = [.../* @__PURE__ */ new Set([...Object.keys(statsA.toolMix), ...Object.keys(statsB.toolMix)])].sort();
-  const related = a.header.parentSession === b.header.id || b.header.parentSession === a.header.id || a.header.parentSession !== void 0 && a.header.parentSession === b.header.parentSession;
+  const relation = relatedBy(a, b, parentOf);
+  const related = relation !== "none";
   let divergenceSeq;
+  let divergenceA;
+  let divergenceB;
   const shared = Math.min(a.events.length, b.events.length);
   for (let i = 0; i < shared; i++) {
     if (a.events[i].type === "session/end-seed" || b.events[i].type === "session/end-seed") {
       if (a.events[i].type !== b.events[i].type) {
         divergenceSeq = Math.min(a.events[i].seq, b.events[i].seq);
+        divergenceA = a.events[i];
+        divergenceB = b.events[i];
         break;
       }
       continue;
     }
     if (eventFingerprint(a.events[i]) !== eventFingerprint(b.events[i])) {
       divergenceSeq = a.events[i].seq;
+      divergenceA = a.events[i];
+      divergenceB = b.events[i];
       break;
     }
   }
   if (divergenceSeq === void 0 && a.events.length !== b.events.length) {
     divergenceSeq = shared > 0 ? (a.events[shared - 1]?.seq ?? 0) + 1 : 0;
+    divergenceA = a.events[shared];
+    divergenceB = b.events[shared];
   }
-  return { a: statsA, b: statsB, toolNames, divergenceSeq, related };
+  return { a: statsA, b: statsB, toolNames, divergenceSeq, divergenceA, divergenceB, related, relation };
 }
 
 // src/core/cost.ts
 var DEFAULT_PRICING = [
-  { match: /deepseek.*pro/iu, rate: { input: 1.1, cacheRead: 0.27, output: 4.4 }, label: "DeepSeek Pro" },
-  { match: /deepseek/iu, rate: { input: 0.27, cacheRead: 0.07, output: 1.1 }, label: "DeepSeek" },
-  { match: /claude|anthropic/iu, rate: { input: 3, cacheRead: 0.3, cacheWrite: 3.75, output: 15 }, label: "Claude" },
-  { match: /gpt|^o\d|openai|codex/iu, rate: { input: 2.5, cacheRead: 1.25, output: 10 }, label: "OpenAI" },
-  { match: /gemini/iu, rate: { input: 1.25, cacheRead: 0.31, output: 10 }, label: "Gemini" }
+  {
+    match: /deepseek.*pro/iu,
+    rate: { input: 1.1, cacheRead: 0.27, output: 4.4 },
+    label: "DeepSeek Pro",
+    updatedAt: "2026-08-18",
+    source: "provider list price (estimate)"
+  },
+  {
+    match: /deepseek/iu,
+    rate: { input: 0.27, cacheRead: 0.07, output: 1.1 },
+    label: "DeepSeek",
+    updatedAt: "2026-08-18",
+    source: "provider list price (estimate)"
+  },
+  {
+    match: /claude|anthropic/iu,
+    rate: { input: 3, cacheRead: 0.3, cacheWrite: 3.75, output: 15 },
+    label: "Claude",
+    updatedAt: "2026-08-18",
+    source: "provider list price (estimate)"
+  },
+  {
+    match: /gpt|^o\d|openai|codex/iu,
+    rate: { input: 2.5, cacheRead: 1.25, output: 10 },
+    label: "OpenAI",
+    updatedAt: "2026-08-18",
+    source: "provider list price (estimate)"
+  },
+  {
+    match: /gemini/iu,
+    rate: { input: 1.25, cacheRead: 0.31, output: 10 },
+    label: "Gemini",
+    updatedAt: "2026-08-18",
+    source: "provider list price (estimate)"
+  }
 ];
+function costOf(totals, rate) {
+  return (totals.input * rate.input + totals.cacheRead * rate.cacheRead + totals.cacheWrite * (rate.cacheWrite ?? rate.input) + totals.output * rate.output) / 1e6;
+}
 function estimateCost(totals, models, pricing = DEFAULT_PRICING) {
   const entry = pricing.find((p) => models.some((m) => p.match.test(m)));
   if (entry === void 0) return void 0;
-  const { rate } = entry;
-  const usd = (totals.input * rate.input + totals.cacheRead * rate.cacheRead + totals.cacheWrite * (rate.cacheWrite ?? rate.input) + totals.output * rate.output) / 1e6;
-  return { usd, label: entry.label };
+  return { usd: costOf(totals, entry.rate), label: entry.label };
+}
+function estimateCostDetailed(modelTotals, pricing = DEFAULT_PRICING) {
+  if (modelTotals === void 0 || modelTotals === null) return void 0;
+  const parts = [];
+  for (const [model, totals] of Object.entries(modelTotals)) {
+    const entry = pricing.find((p) => p.match.test(model));
+    if (entry === void 0) continue;
+    parts.push({ model, label: entry.label, usd: costOf(totals, entry.rate), totals });
+  }
+  if (parts.length === 0) return void 0;
+  const usd = parts.reduce((sum, part) => sum + part.usd, 0);
+  const labels = [...new Set(parts.map((part) => part.label))];
+  return { usd, label: labels.length === 1 ? labels[0] : `Mixed (${labels.length} models)`, parts };
 }
 function formatUsd(usd) {
   if (usd >= 1) return `$${usd.toFixed(2)}`;
   if (usd >= 0.01) return `$${usd.toFixed(3)}`;
   return `$${usd.toFixed(4)}`;
 }
+function formatCny(usd, rate = 7.2) {
+  const cny = usd * rate;
+  if (cny >= 1) return `\xA5${cny.toFixed(2)}`;
+  if (cny >= 0.01) return `\xA5${cny.toFixed(3)}`;
+  return `\xA5${cny.toFixed(4)}`;
+}
+function formatMoney(usd, currency, rate = 7.2) {
+  return currency === "CNY" ? formatCny(usd, rate) : formatUsd(usd);
+}
 export {
   DEFAULT_PRICING,
   DEFAULT_RULES,
@@ -709,12 +1172,20 @@ export {
   buildForkForest,
   buildTimeline,
   compareSessions,
+  containsSecret,
   decodeStorageRecord,
   estimateCost,
+  estimateCostDetailed,
   expandChunkRow,
+  formatCny,
+  formatMoney,
   formatUsd,
   fromInspection,
   isChunkRow,
   lineageOf,
-  parseSessionJsonl
+  parseSessionJsonl,
+  redactSession,
+  redactText,
+  redactValue,
+  summarizeToolArguments
 };