@curdx/flow 7.1.1 → 7.1.3

package/dist/index.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import * as p9 from "@clack/prompts";
-import { defineCommand, runMain } from "citty";
+import * as p10 from "@clack/prompts";
+import { defineCommand as defineCommand2, runMain } from "citty";
 
 // src/ui/language.ts
 import * as p from "@clack/prompts";
@@ -66,6 +66,15 @@ var messages = {
   "context7.dashboardHint": "\u53EF\u5728 https://context7.com/dashboard \u521B\u5EFA API Key",
   "chrome.prereqNode": "\u9700\u8981 Node.js >= 20.19\uFF0C\u5F53\u524D\u7248\u672C {current}",
   "chrome.prereqChrome": "\u9700\u8981\u672C\u673A\u5DF2\u5B89\u88C5 Chrome\uFF08chrome-devtools-mcp \u4F1A\u8C03\u7528\u672C\u5730\u6D4F\u89C8\u5668\uFF09",
+  "bun.missing": "\u672A\u68C0\u6D4B\u5230 Bun\uFF0Cclaude-mem \u7684\u540E\u53F0 worker \u4F9D\u8D56 Bun \u8FD0\u884C\u3002",
+  "bun.installerSource": "Bun \u5B89\u88C5\u811A\u672C\u6765\u6E90\uFF1Ahttps://bun.sh\uFF08macOS/Linux \u7528 curl\uFF0CWindows \u7528 powershell irm\uFF09\u3002",
+  "bun.confirmInstall": "\u662F\u5426\u73B0\u5728\u81EA\u52A8\u5B89\u88C5 Bun\uFF1F\uFF08\u9ED8\u8BA4\u5426\u2014\u2014\u9009\u5426\u5C06\u8DF3\u8FC7 claude-mem\uFF0C\u5176\u4ED6\u63D2\u4EF6\u7EE7\u7EED\u5B89\u88C5\uFF09",
+  "bun.declined": "\u5DF2\u8DF3\u8FC7 Bun \u5B89\u88C5\uFF1Bclaude-mem \u9700\u8981 Bun\uFF0C\u672C\u6B21\u4E0D\u5B89\u88C5\u3002\u624B\u52A8\u88C5\u597D Bun \u540E\u53EF\u91CD\u8DD1 install\u3002",
+  "bun.installing": "\u6B63\u5728\u4E0B\u8F7D\u5E76\u5B89\u88C5 Bun\uFF08\u9996\u6B21\u7EA6 60MB\uFF09\u2026",
+  "bun.installed": "Bun \u5B89\u88C5\u5B8C\u6210\u3002",
+  "bun.installFailedTitle": "Bun \u5B89\u88C5\u5931\u8D25",
+  "bun.installFailedReason": "Bun \u5B89\u88C5\u5931\u8D25\uFF1A{error}",
+  "bun.installedButNotFound": "Bun \u5B89\u88C5\u811A\u672C\u58F0\u660E\u6210\u529F\uFF0C\u4F46\u672A\u5728\u5DF2\u77E5\u8DEF\u5F84\u627E\u5230 bun \u53EF\u6267\u884C\u6587\u4EF6\u2014\u2014\u8BF7\u624B\u52A8\u786E\u8BA4\u540E\u91CD\u8DD1\u3002",
   "reinstall.uninstalling": "\u5148\u5378\u8F7D\u65E7\u7248\u672C\u2026",
   "reinstall.installing": "\u5B89\u88C5\u65B0\u7248\u672C\u2026",
   "state.checking": "\u68C0\u67E5\u5DF2\u5B89\u88C5\u72B6\u6001\u2026\uFF08claude plugin list / mcp list\uFF09",
@@ -75,7 +84,17 @@ var messages = {
   "claudeMd.unchanged": "CLAUDE.md \u5DF2\u662F\u6700\u65B0",
   "claudeMd.removed": "\u5DF2\u4ECE CLAUDE.md \u79FB\u9664 @curdx/flow \u533A\u5757",
   "claudeMd.skipped": "\u5DF2\u8DF3\u8FC7 CLAUDE.md \u540C\u6B65\uFF08--no-claude-md\uFF09",
-  "claudeMd.failed": "CLAUDE.md \u540C\u6B65\u5931\u8D25\uFF1A{error}"
+  "claudeMd.failed": "CLAUDE.md \u540C\u6B65\u5931\u8D25\uFF1A{error}",
+  "analyze.description": "\u89E3\u6790 Claude Code session jsonl + curdx-flow errors.jsonl\uFF0C\u8F93\u51FA markdown \u62A5\u544A",
+  "analyze.helpSummary": "analyze \u2014 \u672C\u5730\u89C2\u6D4B\uFF1A\u5408\u5E76 ~/.claude/projects/<cwd-encoded>/<sessionId>.jsonl \u4E0E ~/.claude/curdx-flow/errors.jsonl\uFF0C\u6E32\u67D3 7 \u6BB5 markdown\uFF08hook \u5931\u8D25 / slash command \u9891\u6B21 / subagent \u8C03\u5EA6 / spec \u6F0F\u6597 / hook \u65F6\u5EF6 P50/P95/P99 / schema \u6F02\u79FB / parentUuid \u94FE\u5B8C\u6574\u6027\uFF09",
+  "analyze.flags.json": "\u8F93\u51FA JSON \u800C\u975E markdown\uFF08CI \u53CB\u597D\uFF1B\u4E0E --out \u4E92\u65A5\u8BED\u4E49\uFF1AJSON \u4E0D\u5199\u6587\u4EF6\uFF09",
+  "analyze.flags.out": "\u628A markdown \u62A5\u544A\u5199\u5165\u6307\u5B9A\u6587\u4EF6\uFF08\u7F3A\u7701\u5199\u5230 stdout\uFF09",
+  "analyze.flags.limit": "\u8868\u683C\u6BB5 Top-N \u622A\u65AD\uFF08\u9ED8\u8BA4 10\uFF1B\u4F20 0 \u89C6\u4E3A\u65E0\u610F\u4E49\u56DE\u843D 10\uFF09",
+  "analyze.flags.since": "\u53EA\u7EDF\u8BA1\u76F8\u5BF9\u7A97\u53E3\u5185\u7684\u4E8B\u4EF6\uFF0C\u4F8B\u5982 `7d` / `24h` / `30m`\uFF08\u9ED8\u8BA4\u5168\u91CF\uFF1B--since \u4E0E\u589E\u91CF offset \u7F13\u5B58\u5171\u5B58\uFF0C\u7F13\u5B58\u547D\u4E2D\u65F6\u76F4\u63A5 replay \u4E0A\u6B21\u62A5\u544A\uFF09",
+  "analyze.flags.project": "\u6307\u5B9A ~/.claude/projects/ \u4E0B\u7684 encoded-cwd \u5B50\u76EE\u5F55\uFF1B\u7F3A\u7701\u6309\u5F53\u524D git \u4ED3\u5E93\u6839\u76EE\u5F55\u63A8\u65AD\uFF08\u975E git \u76EE\u5F55\u9000\u5316\u4E3A\u7A7A\u62A5\u544A + warning\uFF09",
+  "analyze.flags.includePrompts": "\u5173\u95ED\u9ED8\u8BA4 redact\uFF0C\u628A\u539F\u59CB prompt \u6587\u672C\u900F\u51FA\uFF08\u4EC5\u672C\u5730\u8C03\u8BD5\uFF0C\u8C28\u614E\u4F7F\u7528\uFF1BD-9 \u767D\u540D\u5355\u9ED8\u8BA4\u88C1\u526A\u6240\u6709\u672A\u5728\u767D\u540D\u5355\u5B57\u6BB5\uFF09",
+  "analyze.warning.noProject": "\u672A\u80FD\u4ECE cwd \u63A8\u65AD\u5230 ~/.claude/projects/ \u5B50\u76EE\u5F55\uFF08\u975E git \u4ED3\u5E93\u6216\u65E0\u5BF9\u5E94 session\uFF09\uFF1B\u8F93\u51FA\u7A7A\u62A5\u544A\uFF0C\u8BF7\u7528 --project \u663E\u5F0F\u6307\u5B9A",
+  "analyze.warning.schemaFallback": "plugins/curdx-flow/schemas/transcript-events.json \u672A\u627E\u5230\uFF0C\u56DE\u843D\u5230\u5185\u7F6E\u6700\u5C0F\u767D\u540D\u5355\u2014\u2014schema \u6F02\u79FB\u8BCA\u65AD\u53EF\u80FD\u6F0F\u62A5"
 };
 var zh_default = messages;
 
@@ -138,6 +157,15 @@ var messages2 = {
   "context7.dashboardHint": "Get a key at https://context7.com/dashboard",
   "chrome.prereqNode": "Requires Node.js >= 20.19 (current: {current})",
   "chrome.prereqChrome": "Requires Chrome installed locally (chrome-devtools-mcp drives the local browser)",
+  "bun.missing": "Bun runtime not found \u2014 claude-mem's background worker requires Bun.",
+  "bun.installerSource": "Bun installer source: https://bun.sh (curl on macOS/Linux, PowerShell irm on Windows).",
+  "bun.confirmInstall": "Auto-install Bun now? (default: No \u2014 declining will skip claude-mem; other packages continue)",
+  "bun.declined": "Bun install declined; claude-mem requires Bun and will be skipped this run. Install Bun manually and re-run install.",
+  "bun.installing": "Downloading and installing Bun (~60 MB on first run)\u2026",
+  "bun.installed": "Bun installed.",
+  "bun.installFailedTitle": "Bun install failed",
+  "bun.installFailedReason": "Bun install failed: {error}",
+  "bun.installedButNotFound": "Bun installer reported success but bun was not found at any known path \u2014 verify manually and re-run.",
   "reinstall.uninstalling": "Uninstalling old version\u2026",
   "reinstall.installing": "Installing new version\u2026",
   "state.checking": "Checking installed state\u2026 (claude plugin list / mcp list)",
@@ -147,7 +175,17 @@ var messages2 = {
   "claudeMd.unchanged": "CLAUDE.md already up to date",
   "claudeMd.removed": "Removed @curdx/flow block from CLAUDE.md",
   "claudeMd.skipped": "Skipped CLAUDE.md sync (--no-claude-md)",
-  "claudeMd.failed": "CLAUDE.md sync failed: {error}"
+  "claudeMd.failed": "CLAUDE.md sync failed: {error}",
+  "analyze.description": "Analyze Claude Code session jsonl + curdx-flow errors.jsonl, output markdown report",
+  "analyze.helpSummary": "analyze \u2014 local observability: merge ~/.claude/projects/<cwd-encoded>/<sessionId>.jsonl with ~/.claude/curdx-flow/errors.jsonl into 7 markdown sections (hook failures / slash command frequency / subagent dispatch / spec funnel / hook duration P50/P95/P99 / schema drift / parentUuid chain integrity)",
+  "analyze.flags.json": "Emit JSON instead of markdown (CI-friendly; --out is ignored when --json is set)",
+  "analyze.flags.out": "Write the markdown report to the given file path (defaults to stdout)",
+  "analyze.flags.limit": "Top-N truncation for tabular sections (default 10; 0 falls back to 10)",
+  "analyze.flags.since": "Only count events within a relative window such as `7d` / `24h` / `30m` (default: full history; --since coexists with the incremental offset cache, replays the last report when cache hits)",
+  "analyze.flags.project": "Pin to a specific encoded-cwd directory under ~/.claude/projects/; defaults to inferring from the current git repository root (non-git directories degrade to an empty report with a warning)",
+  "analyze.flags.includePrompts": "Skip default redaction and pass raw prompt text through (local debugging only; D-9 white-list redacts every non-whitelisted field by default)",
+  "analyze.warning.noProject": "Could not infer a ~/.claude/projects/ subdirectory from cwd (not a git repo or no matching session); emitting an empty report \u2014 pass --project to override",
+  "analyze.warning.schemaFallback": "plugins/curdx-flow/schemas/transcript-events.json not found, falling back to the builtin minimal whitelist \u2014 schema drift diagnostics may underreport"
 };
 var en_default = messages2;
 
@@ -196,10 +234,10 @@ async function initLanguage(override) {
 }
 
 // src/ui/menu.ts
-import * as p8 from "@clack/prompts";
+import * as p9 from "@clack/prompts";
 
 // src/flows/install.ts
-import * as p4 from "@clack/prompts";
+import * as p5 from "@clack/prompts";
 import pc from "picocolors";
 
 // src/runner/state.ts
@@ -218,15 +256,15 @@ async function run(cmd, args) {
     stderr: result.stderr
   };
 }
-async function runStreaming(cmd, args, log5) {
-  log5.message(`$ ${cmd} ${args.join(" ")}`);
+async function runStreaming(cmd, args, log6) {
+  log6.message(`$ ${cmd} ${args.join(" ")}`);
   const proc = x(cmd, args, { throwOnError: false });
   let stdout = "";
   for await (const line of proc) {
     const trimmed = line.replace(/\r?\n$/, "");
     if (trimmed.length > 0) {
       stdout += trimmed + "\n";
-      log5.message(trimmed);
+      log6.message(trimmed);
     }
   }
   const finished = await proc;
@@ -269,15 +307,15 @@ async function listPlugins(force = false) {
   }
   try {
     const arr = JSON.parse(res.stdout);
-    pluginCache = arr.map((p10) => {
-      const [name = p10.id, marketplace = ""] = p10.id.split("@");
+    pluginCache = arr.map((p11) => {
+      const [name = p11.id, marketplace = ""] = p11.id.split("@");
       return {
-        id: p10.id,
+        id: p11.id,
         name,
         marketplace,
-        version: p10.version,
-        scope: p10.scope,
-        enabled: p10.enabled
+        version: p11.version,
+        scope: p11.scope,
+        enabled: p11.enabled
       };
     });
   } catch {
@@ -323,7 +361,7 @@ async function listMcp(force = false) {
 }
 async function isPluginInstalled(id) {
   const list = await listPlugins();
-  return list.some((p10) => p10.id === id);
+  return list.some((p11) => p11.id === id);
 }
 async function isMarketplaceAdded(name) {
   const list = await listMarketplaces();
@@ -335,7 +373,7 @@ async function isMcpInstalled(name) {
 }
 async function findPlugin(id) {
   const list = await listPlugins();
-  return list.find((p10) => p10.id === id);
+  return list.find((p11) => p11.id === id);
 }
 var marketplaceJsonCache = /* @__PURE__ */ new Map();
 function marketplaceDir(name) {
@@ -357,7 +395,7 @@ async function readMarketplaceJson(name) {
 async function getMarketplacePluginVersion(marketplaceName, pluginName) {
   const m = await readMarketplaceJson(marketplaceName);
   if (!m?.plugins) return null;
-  const entry = m.plugins.find((p10) => p10.name === pluginName);
+  const entry = m.plugins.find((p11) => p11.name === pluginName);
   return entry?.version ?? null;
 }
 var REFRESH_TTL_MS = 60 * 60 * 1e3;
@@ -478,8 +516,8 @@ var pua = {
   marketplaces: () => [MARKETPLACE_NAME],
   isInstalled: () => isPluginInstalled(PLUGIN_ID),
   installedVersion: async () => {
-    const p10 = await findPlugin(PLUGIN_ID);
-    const v = p10?.version;
+    const p11 = await findPlugin(PLUGIN_ID);
+    const v = p11?.version;
     return v && v !== "unknown" ? v : null;
   },
   latestVersion: () => getMarketplacePluginVersion(MARKETPLACE_NAME, PLUGIN_NAME),
@@ -492,6 +530,72 @@ var pua = {
 };
 var pua_default = pua;
 
+// src/runner/ensureBun.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import path2 from "path";
+import * as p2 from "@clack/prompts";
+var IS_WINDOWS = process.platform === "win32";
+function fallbackPaths() {
+  const home = homedir();
+  if (IS_WINDOWS) return [path2.join(home, ".bun", "bin", "bun.exe")];
+  return [
+    path2.join(home, ".bun", "bin", "bun"),
+    "/usr/local/bin/bun",
+    "/opt/homebrew/bin/bun",
+    "/home/linuxbrew/.linuxbrew/bin/bun"
+  ];
+}
+async function findBun() {
+  const probe = IS_WINDOWS ? await run("where", ["bun"]) : await run("which", ["bun"]);
+  if (probe.exitCode === 0 && probe.stdout.trim()) {
+    const lines = probe.stdout.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+    if (IS_WINDOWS) {
+      const cmd = lines.find((l) => l.toLowerCase().endsWith("bun.cmd") || l.toLowerCase().endsWith("bun.exe"));
+      if (cmd) return cmd;
+    }
+    if (lines[0]) return lines[0];
+  }
+  for (const candidate of fallbackPaths()) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+async function runInstaller() {
+  const result = IS_WINDOWS ? await run("powershell", ["-NoProfile", "-Command", "irm bun.sh/install.ps1 | iex"]) : await run("bash", ["-lc", "curl -fsSL https://bun.sh/install | bash"]);
+  if (result.exitCode !== 0) {
+    const detail = (result.stderr || result.stdout || "").trim().slice(0, 500);
+    return { ok: false, error: detail || `exit ${result.exitCode}` };
+  }
+  return { ok: true };
+}
+async function ensureBun(t2) {
+  const found = await findBun();
+  if (found) return { ok: true };
+  p2.log.warn(t2("bun.missing"));
+  p2.log.info(t2("bun.installerSource"));
+  const ans = await p2.confirm({
+    message: t2("bun.confirmInstall"),
+    initialValue: false
+  });
+  if (p2.isCancel(ans) || ans === false) {
+    return { ok: false, reason: t2("bun.declined") };
+  }
+  const sp = p2.spinner();
+  sp.start(t2("bun.installing"));
+  const result = await runInstaller();
+  if (!result.ok) {
+    sp.stop(t2("bun.installFailedTitle"));
+    return { ok: false, reason: t2("bun.installFailedReason", { error: result.error }) };
+  }
+  sp.stop(t2("bun.installed"));
+  const reFound = await findBun();
+  if (!reFound) {
+    return { ok: false, reason: t2("bun.installedButNotFound") };
+  }
+  return { ok: true };
+}
+
 // src/registry/plugins/claude-mem.ts
 var PLUGIN_ID2 = "claude-mem@thedotmack";
 var PLUGIN_NAME2 = "claude-mem";
@@ -505,10 +609,11 @@ var claudeMem = {
   slashNamespace: "/claude-mem:*",
   whenToUse: 'for cross-session memory search ("did we solve this before?"), phased planning (`make-plan`), or phased execution (`do`).',
   marketplaces: () => [MARKETPLACE_NAME2],
+  prereqCheck: (t2) => ensureBun(t2),
   isInstalled: () => isPluginInstalled(PLUGIN_ID2),
   installedVersion: async () => {
-    const p10 = await findPlugin(PLUGIN_ID2);
-    const v = p10?.version;
+    const p11 = await findPlugin(PLUGIN_ID2);
+    const v = p11?.version;
     return v && v !== "unknown" ? v : null;
   },
   latestVersion: () => getMarketplacePluginVersion(MARKETPLACE_NAME2, PLUGIN_NAME2),
@@ -522,32 +627,32 @@ var claudeMem = {
 var claude_mem_default = claudeMem;
 
 // src/registry/plugins/chrome-devtools-mcp.ts
-import { existsSync } from "fs";
-import path2 from "path";
+import { existsSync as existsSync2 } from "fs";
+import path3 from "path";
 var PLUGIN_ID3 = "chrome-devtools-mcp@chrome-devtools-plugins";
 var MARKETPLACE_NAME3 = "chrome-devtools-plugins";
 var MARKETPLACE_SOURCE3 = "ChromeDevTools/chrome-devtools-mcp";
 async function checkChrome() {
-  if (process.env.CHROME_PATH && existsSync(process.env.CHROME_PATH)) return true;
+  if (process.env.CHROME_PATH && existsSync2(process.env.CHROME_PATH)) return true;
   if (process.platform === "win32") {
     const suffixes = [
-      path2.join("Google", "Chrome SxS", "Application", "chrome.exe"),
-      path2.join("Google", "Chrome", "Application", "chrome.exe")
+      path3.join("Google", "Chrome SxS", "Application", "chrome.exe"),
+      path3.join("Google", "Chrome", "Application", "chrome.exe")
     ];
     const prefixes = [
       process.env.LOCALAPPDATA,
       process.env.PROGRAMFILES,
       process.env["PROGRAMFILES(X86)"]
-    ].filter((p10) => Boolean(p10));
+    ].filter((p11) => Boolean(p11));
     for (const prefix of prefixes) {
       for (const suffix of suffixes) {
-        if (existsSync(path2.join(prefix, suffix))) return true;
+        if (existsSync2(path3.join(prefix, suffix))) return true;
       }
     }
     return false;
   }
   if (process.platform === "darwin") {
-    return existsSync("/Applications/Google Chrome.app/Contents/MacOS/Google Chrome");
+    return existsSync2("/Applications/Google Chrome.app/Contents/MacOS/Google Chrome");
   }
   const [viaPath, viaPathChromium] = await Promise.all([
     run("which", ["google-chrome"]),
@@ -613,8 +718,8 @@ var curdxFlow = {
   marketplaces: () => [MARKETPLACE_NAME4],
   isInstalled: () => isPluginInstalled(PLUGIN_ID5),
   installedVersion: async () => {
-    const p10 = await findPlugin(PLUGIN_ID5);
-    const v = p10?.version;
+    const p11 = await findPlugin(PLUGIN_ID5);
+    const v = p11?.version;
     return v && v !== "unknown" ? v : null;
   },
   latestVersion: () => getMarketplacePluginVersion(MARKETPLACE_NAME4, PLUGIN_NAME3),
@@ -667,7 +772,7 @@ var sequentialThinking = {
 var sequential_thinking_default = sequentialThinking;
 
 // src/registry/mcps/context7.ts
-import * as p2 from "@clack/prompts";
+import * as p3 from "@clack/prompts";
 var MCP_NAME2 = "context7";
 var URL = "https://mcp.context7.com/mcp";
 var context7 = {
@@ -678,14 +783,14 @@ var context7 = {
   whenToUse: "for any library / SDK / framework / API / Claude Code docs lookup. Use instead of web search.",
   isInstalled: () => isMcpInstalled(MCP_NAME2),
   configPrompts: async ({ t: t2 }) => {
-    p2.note(`${t2("context7.dashboardHint")}
+    p3.note(`${t2("context7.dashboardHint")}
 ${t2("context7.keyWarning")}`, "context7");
-    const key = await p2.text({
+    const key = await p3.text({
       message: t2("context7.askKey"),
       placeholder: t2("context7.keyPlaceholder"),
       defaultValue: ""
     });
-    if (p2.isCancel(key)) return null;
+    if (p3.isCancel(key)) return null;
     const trimmed = String(key ?? "").trim();
     const out = {};
     if (trimmed) out["CONTEXT7_API_KEY"] = trimmed;
@@ -729,19 +834,19 @@ var PKGS = [
   context7_default
 ];
 function findPkg(id) {
-  return PKGS.find((p10) => p10.id === id);
+  return PKGS.find((p11) => p11.id === id);
 }
 
 // src/runner/claudeMd.ts
 import { promises as fs2 } from "fs";
-import path3 from "path";
+import path4 from "path";
 import os2 from "os";
-import * as p3 from "@clack/prompts";
+import * as p4 from "@clack/prompts";
 var BEGIN_MARKER = "<!-- BEGIN @curdx/flow v1 -->";
 var END_MARKER = "<!-- END @curdx/flow v1 -->";
 var BLOCK_RE = /<!-- BEGIN @curdx\/flow v\d+[^>]*-->[\s\S]*?<!-- END @curdx\/flow v\d+ -->/;
 function claudeMdPath() {
-  return path3.join(os2.homedir(), ".claude", "CLAUDE.md");
+  return path4.join(os2.homedir(), ".claude", "CLAUDE.md");
 }
 function buildCombinationPatterns(ids) {
   const has = (k) => ids.has(k);
@@ -917,7 +1022,7 @@ async function syncClaudeMd(opts) {
     if (next === existing) {
       return { status: "unchanged", path: file };
     }
-    await fs2.mkdir(path3.dirname(file), { recursive: true });
+    await fs2.mkdir(path4.dirname(file), { recursive: true });
     const tmp = `${file}.tmp.${process.pid}`;
     await fs2.writeFile(tmp, next, "utf8");
     await fs2.rename(tmp, file);
@@ -931,10 +1036,10 @@ async function syncClaudeMd(opts) {
 }
 async function syncFromState(opts) {
   if (opts?.skip) {
-    p3.log.info(t("claudeMd.skipped"));
+    p4.log.info(t("claudeMd.skipped"));
     return;
   }
-  const sp = p3.spinner();
+  const sp = p4.spinner();
   sp.start(t("claudeMd.syncing"));
   const r = await syncClaudeMd();
   switch (r.status) {
@@ -989,7 +1094,7 @@ async function selectInteractive(states) {
   const optionalPkgs = PKGS.filter((pkg) => !pkg.required);
   if (requiredPkgs.length > 0) {
     const lines = requiredPkgs.map((pkg) => `  ${stateLabel(pkg, states.get(pkg.id))}`);
-    p4.note(lines.join("\n"), t("install.requiredHeader"));
+    p5.note(lines.join("\n"), t("install.requiredHeader"));
   }
   const options = optionalPkgs.map((pkg) => {
     const s = states.get(pkg.id);
@@ -999,13 +1104,13 @@ async function selectInteractive(states) {
     const s = states.get(pkg.id);
     return s.kind === "not_installed" || s.kind === "update_available";
   }).map((pkg) => pkg.id);
-  const picked = await p4.multiselect({
+  const picked = await p5.multiselect({
     message: t("install.selectPrompt"),
     options,
     initialValues,
     required: false
   });
-  if (p4.isCancel(picked)) return null;
+  if (p5.isCancel(picked)) return null;
   const userPicked = picked.map((id) => findPkg(id)).filter((x2) => Boolean(x2));
   const requiredAuto = requiredPkgs.filter((pkg) => states.get(pkg.id)?.kind !== "up_to_date");
   return [...requiredAuto, ...userPicked];
@@ -1017,7 +1122,7 @@ function selectFromIds(opts) {
   for (const id of opts.ids) {
     const pkg = findPkg(id);
     if (pkg) found.push(pkg);
-    else p4.log.warn(`Unknown id: ${id}`);
+    else p5.log.warn(`Unknown id: ${id}`);
   }
   return found;
 }
@@ -1029,11 +1134,11 @@ async function runOne(pkg, state, opts) {
     mode = "update";
   } else {
     if (!opts.yes) {
-      const ans = await p4.confirm({
+      const ans = await p5.confirm({
         message: t("install.confirmReinstall", { name: pkg.name }),
         initialValue: false
       });
-      if (p4.isCancel(ans) || ans === false) {
+      if (p5.isCancel(ans) || ans === false) {
         return { id: pkg.id, status: "skip", message: t("install.skippedReinstall", { name: pkg.name }) };
       }
     }
@@ -1042,7 +1147,7 @@ async function runOne(pkg, state, opts) {
   if (pkg.prereqCheck) {
     const r = await pkg.prereqCheck(t);
     if (!r.ok) {
-      p4.log.warn(t("install.prereqFail", { name: pkg.name, reason: r.reason }));
+      p5.log.warn(t("install.prereqFail", { name: pkg.name, reason: r.reason }));
       return { id: pkg.id, status: "skip", message: r.reason };
     }
   }
@@ -1057,30 +1162,30 @@ async function runOne(pkg, state, opts) {
   if (mode === "update" && state.kind === "update_available") {
     titleVars["version"] = state.latest;
   }
-  const log5 = p4.taskLog({ title: t(titleKey, titleVars) });
+  const log6 = p5.taskLog({ title: t(titleKey, titleVars) });
   try {
     if (mode === "reinstall") {
-      log5.message(t("reinstall.uninstalling"));
-      await pkg.uninstall({ log: log5, config, t });
-      log5.message(t("reinstall.installing"));
-      await pkg.install({ log: log5, config, t });
+      log6.message(t("reinstall.uninstalling"));
+      await pkg.uninstall({ log: log6, config, t });
+      log6.message(t("reinstall.installing"));
+      await pkg.install({ log: log6, config, t });
     } else if (mode === "update") {
       if (pkg.update) {
-        await pkg.update({ log: log5, config, t });
+        await pkg.update({ log: log6, config, t });
       } else {
-        log5.message(t("reinstall.uninstalling"));
-        await pkg.uninstall({ log: log5, config, t });
-        log5.message(t("reinstall.installing"));
-        await pkg.install({ log: log5, config, t });
+        log6.message(t("reinstall.uninstalling"));
+        await pkg.uninstall({ log: log6, config, t });
+        log6.message(t("reinstall.installing"));
+        await pkg.install({ log: log6, config, t });
       }
     } else {
-      await pkg.install({ log: log5, config, t });
+      await pkg.install({ log: log6, config, t });
     }
-    log5.success(t("install.success", { name: pkg.name }));
+    log6.success(t("install.success", { name: pkg.name }));
     return { id: pkg.id, status: "ok" };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    log5.error(`${t("install.failed", { name: pkg.name })}
+    log6.error(`${t("install.failed", { name: pkg.name })}
 ${msg}`);
     return { id: pkg.id, status: "fail", message: msg };
   }
@@ -1098,7 +1203,7 @@ function summarize(results) {
     ...skip.map((r) => `  ${pc.yellow("-")} ${r.id}${r.message ? pc.dim(` (${r.message})`) : ""}`),
     ...fail.map((r) => `  ${pc.red("\u2717")} ${r.id}${r.message ? pc.dim(` (${r.message.split("\n")[0]})`) : ""}`)
   ];
-  p4.note(lines.join("\n"), t("install.summaryTitle"));
+  p5.note(lines.join("\n"), t("install.summaryTitle"));
 }
 async function maybeRefreshMarketplaces(opts) {
   if (opts.noRefresh) return;
@@ -1107,7 +1212,7 @@ async function maybeRefreshMarketplaces(opts) {
     if (pkg.marketplaces) for (const n of pkg.marketplaces()) names.add(n);
   }
   if (names.size === 0) return;
-  const sp = p4.spinner();
+  const sp = p5.spinner();
   sp.start(t("marketplace.refreshing"));
   const refreshed = await refreshMarketplaces([...names]);
   sp.stop(
@@ -1121,7 +1226,7 @@ async function installFlow(opts = {}) {
     const explicit = opts.all || opts.ids && opts.ids.length > 0;
     const candidates = explicit ? selectFromIds(opts) : [...PKGS];
     if (candidates.length === 0) {
-      p4.log.info(t("install.nothingSelected"));
+      p5.log.info(t("install.nothingSelected"));
       return;
     }
     if (opts.ids && opts.ids.length > 0) {
@@ -1132,7 +1237,7 @@ async function installFlow(opts = {}) {
       }
     }
     const stateMap = /* @__PURE__ */ new Map();
-    const sp = p4.spinner();
+    const sp = p5.spinner();
     sp.start(t("state.checking"));
     try {
       await Promise.all([listPlugins(), listMcp()]);
@@ -1160,13 +1265,13 @@ async function installFlow(opts = {}) {
       const picked = await selectInteractive(stateMap);
       if (picked === null) {
         userCancelled = true;
-        p4.cancel(t("app.cancelled"));
+        p5.cancel(t("app.cancelled"));
         return;
       }
       targets = picked;
     }
     if (targets.length === 0) {
-      p4.log.info(t("install.nothingSelected"));
+      p5.log.info(t("install.nothingSelected"));
       return;
     }
     const results = [];
@@ -1183,14 +1288,14 @@ async function installFlow(opts = {}) {
 }
 
 // src/flows/uninstall.ts
-import * as p5 from "@clack/prompts";
+import * as p6 from "@clack/prompts";
 import pc2 from "picocolors";
 async function getInstalled() {
   const states = await Promise.all(PKGS.map(async (pkg) => ({ pkg, installed: await pkg.isInstalled() })));
   return states.filter((s) => s.installed).map((s) => s.pkg);
 }
 async function probeInstalled() {
-  const sp = p5.spinner();
+  const sp = p6.spinner();
   sp.start(t("state.checking"));
   try {
     await Promise.all([listPlugins(), listMcp()]);
@@ -1212,21 +1317,21 @@ async function uninstallFlow(opts = {}) {
       for (const id of opts.ids) {
         const pkg = findPkg(id);
         if (!pkg) {
-          p5.log.warn(`Unknown id: ${id}`);
+          p6.log.warn(`Unknown id: ${id}`);
           continue;
         }
         if (!installed.some((x2) => x2.id === pkg.id)) {
-          p5.log.warn(`${pkg.name}: ${t("pkg.notInstalled")}`);
+          p6.log.warn(`${pkg.name}: ${t("pkg.notInstalled")}`);
           continue;
         }
         targets.push(pkg);
       }
     } else {
       if (installed.length === 0) {
-        p5.log.info(t("uninstall.noneInstalled"));
+        p6.log.info(t("uninstall.noneInstalled"));
         return;
       }
-      const picked = await p5.multiselect({
+      const picked = await p6.multiselect({
         message: t("uninstall.selectPrompt"),
         options: installed.map((pkg) => ({
           value: pkg.id,
@@ -1235,45 +1340,45 @@ async function uninstallFlow(opts = {}) {
         })),
         required: false
       });
-      if (p5.isCancel(picked)) {
+      if (p6.isCancel(picked)) {
         userCancelled = true;
-        p5.cancel(t("app.cancelled"));
+        p6.cancel(t("app.cancelled"));
         return;
       }
       targets = picked.map((id) => findPkg(id)).filter((x2) => Boolean(x2));
     }
     if (targets.length === 0) {
-      p5.log.info(t("install.nothingSelected"));
+      p6.log.info(t("install.nothingSelected"));
       return;
     }
     if (!opts.yes) {
-      const ok2 = await p5.confirm({
+      const ok2 = await p6.confirm({
         message: t("uninstall.confirm", { count: targets.length }),
         initialValue: false
       });
-      if (p5.isCancel(ok2) || ok2 === false) {
+      if (p6.isCancel(ok2) || ok2 === false) {
         userCancelled = true;
-        p5.cancel(t("app.cancelled"));
+        p6.cancel(t("app.cancelled"));
         return;
       }
     }
     const results = [];
     for (const pkg of targets) {
-      const log5 = p5.taskLog({ title: t("uninstall.starting", { name: pkg.name }) });
+      const log6 = p6.taskLog({ title: t("uninstall.starting", { name: pkg.name }) });
       try {
-        await pkg.uninstall({ log: log5, config: {}, t });
-        log5.success(t("uninstall.success", { name: pkg.name }));
+        await pkg.uninstall({ log: log6, config: {}, t });
+        log6.success(t("uninstall.success", { name: pkg.name }));
         results.push({ id: pkg.id, status: "ok" });
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        log5.error(`${t("uninstall.failed", { name: pkg.name })}
+        log6.error(`${t("uninstall.failed", { name: pkg.name })}
 ${msg}`);
         results.push({ id: pkg.id, status: "fail", message: msg });
       }
     }
     const ok = results.filter((r) => r.status === "ok").length;
     const fail = results.filter((r) => r.status === "fail").length;
-    p5.note(
+    p6.note(
       [
         pc2.green(t("install.summaryOk", { count: ok })),
         pc2.red(t("install.summaryFail", { count: fail }))
@@ -1288,14 +1393,14 @@ ${msg}`);
 }
 
 // src/flows/update.ts
-import * as p6 from "@clack/prompts";
+import * as p7 from "@clack/prompts";
 import pc3 from "picocolors";
 async function getInstalled2() {
   const states = await Promise.all(PKGS.map(async (pkg) => ({ pkg, installed: await pkg.isInstalled() })));
   return states.filter((s) => s.installed).map((s) => s.pkg);
 }
 async function probeInstalled2() {
-  const sp = p6.spinner();
+  const sp = p7.spinner();
   sp.start(t("state.checking"));
   try {
     await Promise.all([listPlugins(), listMcp()]);
@@ -1312,7 +1417,7 @@ async function updateFlow(opts = {}) {
   try {
     const installed = await probeInstalled2();
     if (installed.length === 0) {
-      p6.log.info(t("update.noneInstalled"));
+      p7.log.info(t("update.noneInstalled"));
       return;
     }
     let targets;
@@ -1323,17 +1428,17 @@ async function updateFlow(opts = {}) {
       for (const id of opts.ids) {
         const pkg = findPkg(id);
         if (!pkg) {
-          p6.log.warn(`Unknown id: ${id}`);
+          p7.log.warn(`Unknown id: ${id}`);
           continue;
         }
         if (!installed.some((x2) => x2.id === pkg.id)) {
-          p6.log.warn(`${pkg.name}: ${t("pkg.notInstalled")}`);
+          p7.log.warn(`${pkg.name}: ${t("pkg.notInstalled")}`);
           continue;
         }
         targets.push(pkg);
       }
     } else {
-      const picked = await p6.multiselect({
+      const picked = await p7.multiselect({
         message: t("update.selectPrompt"),
         options: installed.map((pkg) => ({
           value: pkg.id,
@@ -1342,42 +1447,42 @@ async function updateFlow(opts = {}) {
         })),
         required: false
       });
-      if (p6.isCancel(picked)) {
+      if (p7.isCancel(picked)) {
         userCancelled = true;
-        p6.cancel(t("app.cancelled"));
+        p7.cancel(t("app.cancelled"));
         return;
       }
       targets = picked.map((id) => findPkg(id)).filter((x2) => Boolean(x2));
     }
     if (targets.length === 0) {
-      p6.log.info(t("install.nothingSelected"));
+      p7.log.info(t("install.nothingSelected"));
       return;
     }
     const results = [];
     for (const pkg of targets) {
       if (pkg.id === "sequential-thinking") {
-        p6.log.info(t("update.mcpAutoNote", { name: pkg.name }));
+        p7.log.info(t("update.mcpAutoNote", { name: pkg.name }));
         results.push({ id: pkg.id, status: "noop" });
         continue;
       }
       if (pkg.id === "context7") {
-        p6.log.info(t("update.context7Note"));
+        p7.log.info(t("update.context7Note"));
         results.push({ id: pkg.id, status: "noop" });
         continue;
       }
-      const log5 = p6.taskLog({ title: t("update.starting", { name: pkg.name }) });
+      const log6 = p7.taskLog({ title: t("update.starting", { name: pkg.name }) });
       try {
         if (pkg.update) {
-          await pkg.update({ log: log5, config: {}, t });
+          await pkg.update({ log: log6, config: {}, t });
         } else {
-          await pkg.uninstall({ log: log5, config: {}, t });
-          await pkg.install({ log: log5, config: {}, t });
+          await pkg.uninstall({ log: log6, config: {}, t });
+          await pkg.install({ log: log6, config: {}, t });
         }
-        log5.success(t("update.success", { name: pkg.name }));
+        log6.success(t("update.success", { name: pkg.name }));
         results.push({ id: pkg.id, status: "ok" });
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        log5.error(`${t("update.failed", { name: pkg.name })}
+        log6.error(`${t("update.failed", { name: pkg.name })}
 ${msg}`);
         results.push({ id: pkg.id, status: "fail", message: msg });
       }
@@ -1385,7 +1490,7 @@ ${msg}`);
     const ok = results.filter((r) => r.status === "ok").length;
     const fail = results.filter((r) => r.status === "fail").length;
     const noop = results.filter((r) => r.status === "noop").length;
-    p6.note(
+    p7.note(
       [
         pc3.green(t("install.summaryOk", { count: ok })),
         pc3.red(t("install.summaryFail", { count: fail })),
@@ -1401,7 +1506,7 @@ ${msg}`);
 }
 
 // src/flows/status.ts
-import * as p7 from "@clack/prompts";
+import * as p8 from "@clack/prompts";
 import pc4 from "picocolors";
 async function statusFlow(opts = {}) {
   const states = await Promise.all(
@@ -1434,12 +1539,12 @@ async function statusFlow(opts = {}) {
   const rows = states.map(
     (s) => `${s.name.padEnd(nameW)}  ${s.type.padEnd(typeW)}  ${s.installed ? pc4.green(`\u2713 ${t("pkg.installed")}`) : pc4.yellow(`\u2717 ${t("pkg.notInstalled")}`)}`
   );
-  p7.note([header, sep, ...rows].join("\n"), t("status.title"));
+  p8.note([header, sep, ...rows].join("\n"), t("status.title"));
 }
 
 // src/ui/menu.ts
 async function mainMenu() {
-  const action = await p8.select({
+  const action = await p9.select({
     message: t("menu.title"),
     options: [
       { value: "install", label: t("menu.install") },
@@ -1449,8 +1554,8 @@ async function mainMenu() {
       { value: "exit", label: t("menu.exit") }
     ]
   });
-  if (p8.isCancel(action) || action === "exit") {
-    p8.cancel(t("app.cancelled"));
+  if (p9.isCancel(action) || action === "exit") {
+    p9.cancel(t("app.cancelled"));
     return;
   }
   switch (action) {
@@ -1469,6 +1574,45 @@ async function mainMenu() {
   }
 }
 
+// src/flows/analyze.ts
+import { defineCommand } from "citty";
+var analyzeCmd = defineCommand({
+  meta: {
+    name: "analyze",
+    description: "Analyze Claude Code session jsonl + curdx-flow errors.jsonl into a markdown report"
+  },
+  args: {
+    out: {
+      type: "string",
+      description: "Output file path (default: stdout)"
+    },
+    json: {
+      type: "boolean",
+      description: "Emit JSON instead of markdown"
+    },
+    limit: {
+      type: "string",
+      description: "Top-N truncation for tabular sections (default: 10)"
+    },
+    "include-prompts": {
+      type: "boolean",
+      description: "Skip prompt redaction (D-9 white-list passthrough disabled \u2014 local debugging only)"
+    }
+  },
+  async run({ args }) {
+    const limitRaw = args.limit;
+    const limit = typeof limitRaw === "string" && limitRaw.length > 0 ? Number(limitRaw) : void 0;
+    const { runAnalyze } = await import("./analyze-4DE3HVCA.mjs");
+    await runAnalyze({
+      out: typeof args.out === "string" ? args.out : void 0,
+      json: Boolean(args.json),
+      limit: Number.isFinite(limit) ? limit : void 0,
+      includePrompts: Boolean(args["include-prompts"])
+    });
+  }
+});
+var analyze_default = analyzeCmd;
+
 // src/index.ts
 function parseLang(v) {
   return v === "zh" || v === "en" ? v : void 0;
@@ -1484,7 +1628,7 @@ var sharedArgs = {
     description: "Skip syncing the @curdx/flow block in ~/.claude/CLAUDE.md"
   }
 };
-var installCmd = defineCommand({
+var installCmd = defineCommand2({
   meta: { name: "install", description: "Install, reinstall, or update plugins / MCP servers" },
   args: {
     ...sharedArgs,
@@ -1495,7 +1639,7 @@ var installCmd = defineCommand({
   },
   async run({ args }) {
     await initLanguage(parseLang(args.lang));
-    p9.intro(t("app.intro"));
+    p10.intro(t("app.intro"));
     const ids = collectPositional(args);
     await installFlow({
       ids,
@@ -1504,10 +1648,10 @@ var installCmd = defineCommand({
       noRefresh: Boolean(args["no-refresh"]),
       noClaudeMd: noClaudeMdFromArgs(args)
     });
-    p9.outro(t("app.outro"));
+    p10.outro(t("app.outro"));
   }
 });
-var uninstallCmd = defineCommand({
+var uninstallCmd = defineCommand2({
   meta: { name: "uninstall", description: "Uninstall installed plugins / MCP servers" },
   args: {
     ...sharedArgs,
@@ -1516,17 +1660,17 @@ var uninstallCmd = defineCommand({
   },
   async run({ args }) {
     await initLanguage(parseLang(args.lang));
-    p9.intro(t("app.intro"));
+    p10.intro(t("app.intro"));
     const ids = collectPositional(args);
     await uninstallFlow({
       ids,
       yes: Boolean(args.yes),
       noClaudeMd: noClaudeMdFromArgs(args)
     });
-    p9.outro(t("app.outro"));
+    p10.outro(t("app.outro"));
   }
 });
-var updateCmd = defineCommand({
+var updateCmd = defineCommand2({
   meta: { name: "update", description: "Update installed plugins" },
   args: {
     ...sharedArgs,
@@ -1535,17 +1679,17 @@ var updateCmd = defineCommand({
   },
   async run({ args }) {
     await initLanguage(parseLang(args.lang));
-    p9.intro(t("app.intro"));
+    p10.intro(t("app.intro"));
     const ids = collectPositional(args);
     await updateFlow({
       ids,
       all: Boolean(args.all),
       noClaudeMd: noClaudeMdFromArgs(args)
     });
-    p9.outro(t("app.outro"));
+    p10.outro(t("app.outro"));
   }
 });
-var statusCmd = defineCommand({
+var statusCmd = defineCommand2({
   meta: { name: "status", description: "Show install status" },
   args: {
     ...sharedArgs,
@@ -1553,13 +1697,13 @@ var statusCmd = defineCommand({
   },
   async run({ args }) {
     await initLanguage(parseLang(args.lang));
-    if (!args.json) p9.intro(t("app.intro"));
+    if (!args.json) p10.intro(t("app.intro"));
     await statusFlow({ json: Boolean(args.json) });
-    if (!args.json) p9.outro(t("app.outro"));
+    if (!args.json) p10.outro(t("app.outro"));
   }
 });
-var SUBCOMMANDS = /* @__PURE__ */ new Set(["install", "uninstall", "update", "status"]);
-var root = defineCommand({
+var SUBCOMMANDS = /* @__PURE__ */ new Set(["install", "uninstall", "update", "status", "analyze"]);
+var root = defineCommand2({
   meta: {
     name: "@curdx/flow",
     version: "3.3.2",
@@ -1570,7 +1714,8 @@ var root = defineCommand({
     install: installCmd,
     uninstall: uninstallCmd,
     update: updateCmd,
-    status: statusCmd
+    status: statusCmd,
+    analyze: analyze_default
   }
   // No root run() — citty 0.1.6 calls parent.run AFTER a matching subcommand,
   // which would render the menu after a subcommand finishes. We dispatch the
@@ -1597,9 +1742,9 @@ async function runInteractive(argv2) {
     else if (argv2[i]?.startsWith("--lang=")) lang = parseLang(argv2[i].slice("--lang=".length));
   }
   await initLanguage(lang);
-  p9.intro(t("app.intro"));
+  p10.intro(t("app.intro"));
   await mainMenu();
-  p9.outro(t("app.outro"));
+  p10.outro(t("app.outro"));
 }
 var argv = process.argv.slice(2);
 var first = firstNonFlag(argv);