@sonnechasser/ntrp 0.3.4 → 0.3.5

package/dist/mcp/server.js

@@ -113,6 +113,259 @@ var init_formatters = __esm({
   }
 });
 
+// src/config/store.ts
+var store_exports = {};
+__export(store_exports, {
+  deleteConfigValue: () => deleteConfigValue,
+  getConfigValue: () => getConfigValue,
+  getConfiguredAiInboxDir: () => getConfiguredAiInboxDir,
+  getExportsDir: () => getExportsDir,
+  getKnowledgeDir: () => getKnowledgeDir,
+  getMemoryDir: () => getMemoryDir,
+  getStrategiesDir: () => getStrategiesDir,
+  getWinsDir: () => getWinsDir,
+  loadConfig: () => loadConfig,
+  ntrpHome: () => ntrpHome,
+  resetConfigCache: () => resetConfigCache,
+  saveConfig: () => saveConfig,
+  setConfigValue: () => setConfigValue
+});
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join, resolve } from "path";
+function ntrpHome() {
+  return NTRP_DIR;
+}
+function ensureDir() {
+  if (!existsSync(NTRP_DIR)) {
+    mkdirSync(NTRP_DIR, { recursive: true });
+  }
+}
+function loadConfig() {
+  if (cachedConfig) return cachedConfig;
+  ensureDir();
+  if (!existsSync(CONFIG_PATH)) {
+    cachedConfig = {};
+    return cachedConfig;
+  }
+  try {
+    cachedConfig = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+  } catch {
+    cachedConfig = {};
+  }
+  return cachedConfig;
+}
+function saveConfig(config) {
+  ensureDir();
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
+  cachedConfig = config;
+}
+function resetConfigCache() {
+  cachedConfig = null;
+}
+function getConfigValue(key) {
+  if (key === "api-key") return loadConfig()["api-key"];
+  if (key === "license-key") return process.env.NTRP_LICENSE_KEY ?? loadConfig()["license-key"];
+  const config = loadConfig();
+  return config[key];
+}
+function setConfigValue(key, value) {
+  const config = loadConfig();
+  config[key] = value;
+  saveConfig(config);
+}
+function deleteConfigValue(key) {
+  const config = loadConfig();
+  delete config[key];
+  saveConfig(config);
+}
+function getExportsDir() {
+  const config = loadConfig();
+  const dir = resolve(config["export-dir"] ?? join(NTRP_DIR, "exports"));
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function getConfiguredAiInboxDir() {
+  const raw = loadConfig()["ai-inbox-dir"];
+  return raw ? resolve(raw) : null;
+}
+function getStrategiesDir() {
+  const dir = join(NTRP_DIR, "strategies");
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "README.md"), `# Strategies
+
+This directory holds your GTM strategy files. Each file describes a strategy you're executing.
+
+## How to use
+
+1. Create a markdown file for each active strategy (e.g., \`multi-thread-q2.md\`)
+2. Describe the goal, target segment, and success criteria
+3. Reference playbook plays that support this strategy
+4. After diagnosis, check if vital signs improved in the targeted area
+
+## Example
+
+\`\`\`markdown
+# Multi-Thread Enterprise Deals \u2014 Q2
+
+**Goal:** Reduce single-threaded deals from 65% to under 30%
+**Segment:** Enterprise accounts > $100K
+**Play:** Multi-Thread Your Deals
+**Success metric:** Thread depth score > 70
+\`\`\`
+`);
+  }
+  return dir;
+}
+function getMemoryDir() {
+  const dir = join(NTRP_DIR, "memory");
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function getKnowledgeDir() {
+  const dir = join(NTRP_DIR, "knowledge");
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "README.md"), `# Knowledge Packs
+
+Drop case studies, GTM frameworks, benchmark reports, or playbooks here as
+markdown, text, or PDF. NTRP ingests them with \`/knowledge add <file>\` and
+references the most relevant passages during analysis \u2014 so the agent can learn
+from work done outside this platform.
+
+## How to use
+
+1. Add a file: \`/knowledge add ~/Downloads/plg-benchmarks-2026.pdf\`
+2. List what's indexed: \`/knowledge list\`
+3. Ask a question \u2014 relevant passages are pulled in automatically.
+`);
+  }
+  return dir;
+}
+function getWinsDir() {
+  const dir = join(NTRP_DIR, "wins");
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "README.md"), `# Wins
+
+This directory logs outcomes when a strategy or play succeeds. Each win creates a record that future diagnoses can reference.
+
+## How to use
+
+1. After executing a play, log the result here (e.g., \`2026-04-clean-pipeline.md\`)
+2. Include: what you did, what changed, before/after scores
+3. Future AI findings will reference wins to track improvement over time
+
+## Example
+
+\`\`\`markdown
+# Pipeline Cleanup \u2014 April 2026
+
+**Play:** Clean Dead Pipeline
+**Before:** Freshness 29/100, $3.1M stale pipeline
+**After:** Freshness 72/100, removed 45 zombie deals
+**Impact:** Forecast accuracy improved from 62% to 84%
+\`\`\`
+`);
+  }
+  return dir;
+}
+var NTRP_DIR, CONFIG_PATH, cachedConfig;
+var init_store = __esm({
+  "src/config/store.ts"() {
+    "use strict";
+    NTRP_DIR = process.env.NTRP_HOME ? resolve(process.env.NTRP_HOME) : join(homedir(), ".ntrp");
+    CONFIG_PATH = join(NTRP_DIR, "config.json");
+    cachedConfig = null;
+  }
+});
+
+// src/output/path-safety.ts
+import { homedir as homedir2 } from "os";
+import { resolve as resolve2, sep } from "path";
+var NTRP_HOME;
+var init_path_safety = __esm({
+  "src/output/path-safety.ts"() {
+    "use strict";
+    init_store();
+    NTRP_HOME = ntrpHome();
+  }
+});
+
+// src/services/exports-registry.ts
+import {
+  appendFileSync,
+  copyFileSync,
+  cpSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  readdirSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { basename, dirname, join as join2, resolve as resolve3, sep as sep2 } from "path";
+import { randomUUID } from "crypto";
+function ensureExportsLayout(root = getExportsDir()) {
+  mkdirSync2(root, { recursive: true });
+  mkdirSync2(join2(root, "latest"), { recursive: true });
+  for (const sub of KIND_DIRS) {
+    mkdirSync2(join2(root, sub), { recursive: true });
+  }
+  const readme = join2(root, "README.md");
+  if (!existsSync2(readme)) {
+    writeFileSync2(readme, ARCHIVE_README, "utf-8");
+  }
+  if (!existsSync2(join2(root, "INDEX.md"))) {
+    writeFileSync2(join2(root, "INDEX.md"), "# NTRP exports\n\n_No exports yet._\n", "utf-8");
+  }
+  if (!existsSync2(join2(root, "manifest.jsonl"))) {
+    writeFileSync2(join2(root, "manifest.jsonl"), "", "utf-8");
+  }
+  return root;
+}
+function getAiInboxDir() {
+  return getConfiguredAiInboxDir();
+}
+function archiveIndexPath() {
+  return join2(ensureExportsLayout(), "INDEX.md");
+}
+var KIND_DIRS, ARCHIVE_README;
+var init_exports_registry = __esm({
+  "src/services/exports-registry.ts"() {
+    "use strict";
+    init_store();
+    init_path_safety();
+    KIND_DIRS = ["handoffs", "reports", "notes", "csv", "publish"];
+    ARCHIVE_README = `# NTRP exports archive
+
+Handoffs, reports, notes, CSV receipts, and publish packages land here by kind:
+
+- \`handoffs/\` \u2014 agent prompts (\`handoff-deck-*.md\`, \u2026)
+- \`reports/\` \u2014 markdown reports
+- \`notes/\` \u2014 Obsidian-style notes
+- \`csv/\` \u2014 backmeup receipt folders
+- \`publish/\` \u2014 repository export packages
+- \`latest/\` \u2014 stable copies of the newest file per kind
+
+\`INDEX.md\` is regenerated from \`manifest.jsonl\` on every write/move.
+
+Point a desktop AI app at a dedicated inbox instead of this folder:
+
+\`\`\`
+/inbox set ~/Documents/Claude/ntrp-inbox
+\`\`\`
+`;
+  }
+});
+
 // src/services/terminal-capture.ts
 function redactSecrets(line) {
   let out = line;
@@ -335,7 +588,7 @@ var init_terminal_capture = __esm({
 });
 
 // src/services/context-doc.ts
-import { writeFileSync } from "fs";
+import { writeFileSync as writeFileSync3 } from "fs";
 function buildSessionContextDoc(file, opts = {}) {
   const id = file.id;
   const shortId = id.slice(-4);
@@ -447,6 +700,21 @@ function buildSessionContextDoc(file, opts = {}) {
     lines.push("- None yet.");
   }
   lines.push("");
+  lines.push("## Exports");
+  lines.push("");
+  try {
+    lines.push(`- Archive index: \`${archiveIndexPath()}\``);
+    lines.push(`- Archive root: \`${getExportsDir()}\``);
+    const inbox = getAiInboxDir();
+    if (inbox) {
+      lines.push(`- AI inbox: \`${inbox}\` (open \`latest-handoff.md\` or \`INDEX.md\`)`);
+    } else {
+      lines.push("- AI inbox: unset \u2014 `/inbox set <folder>` for Claude Desktop");
+    }
+  } catch {
+    lines.push("- Export catalog unavailable.");
+  }
+  lines.push("");
   lines.push(`## Conversation (${exchanges} exchange${exchanges === 1 ? "" : "s"})`);
   lines.push("");
   if (file.messages.length === 0) {
@@ -489,13 +757,13 @@ function writeSessionContextDoc(ctx) {
   try {
     const file = buildSessionFileSnapshot(ctx);
     const doc = buildSessionContextDoc(file, { snapshot: ctx.snapshot.computeResult });
-    writeFileSync(contextDocPathForSession(ctx.sessionId), doc);
+    writeFileSync3(contextDocPathForSession(ctx.sessionId), doc);
   } catch {
   }
 }
 function writeContextDocForSessionFile(file, opts = {}) {
   try {
-    writeFileSync(contextDocPathForSession(file.id), buildSessionContextDoc(file, opts));
+    writeFileSync3(contextDocPathForSession(file.id), buildSessionContextDoc(file, opts));
   } catch {
   }
 }
@@ -505,18 +773,20 @@ var init_context_doc = __esm({
     "use strict";
     init_context2();
     init_formatters();
+    init_store();
+    init_exports_registry();
     init_terminal_capture();
     AGENT_EXCERPT_CHARS = 400;
   }
 });
 
 // src/services/transcript.ts
-import { existsSync, readFileSync, writeFileSync as writeFileSync2, rmSync } from "fs";
-import { join } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync4, rmSync as rmSync2 } from "fs";
+import { join as join3 } from "path";
 function rebindSessionTranscript(ctx) {
   if (!state || state.sessionId === ctx.sessionId) return;
-  const priorJson = join(getSessionsDir(), `${state.sessionId}.json`);
-  if (existsSync(priorJson)) {
+  const priorJson = join3(getSessionsDir(), `${state.sessionId}.json`);
+  if (existsSync3(priorJson)) {
     finalizeCurrentFile("switched session");
   } else {
     discardSessionTranscript(state.sessionId);
@@ -530,16 +800,16 @@ function discardSessionTranscript(sessionId) {
     clearFlushTimer();
   }
   try {
-    rmSync(transcriptPathForSession(sessionId), { force: true });
+    rmSync2(transcriptPathForSession(sessionId), { force: true });
   } catch {
   }
 }
 function createState(sessionId) {
   const filePath = transcriptPathForSession(sessionId);
   let base = "";
-  if (existsSync(filePath)) {
+  if (existsSync3(filePath)) {
     try {
-      base = readFileSync(filePath, "utf-8").trimEnd() + "\n";
+      base = readFileSync3(filePath, "utf-8").trimEnd() + "\n";
     } catch {
       base = "";
     }
@@ -599,7 +869,7 @@ function flushNow(closedNote) {
   s.lastFlushMs = Date.now();
   try {
     getSessionsDir();
-    writeFileSync2(s.filePath, render(s, closedNote));
+    writeFileSync4(s.filePath, render(s, closedNote));
   } catch {
   }
 }
@@ -638,12 +908,12 @@ __export(connection_exports, {
   run: () => run,
   setActiveDbPath: () => setActiveDbPath
 });
-import { mkdirSync, existsSync as existsSync2, rmSync as rmSync2 } from "fs";
-import { dirname, join as join2, resolve } from "path";
-function ensureDir() {
-  const dir = dirname(activeDbPath);
-  if (!existsSync2(dir)) {
-    mkdirSync(dir, { recursive: true });
+import { mkdirSync as mkdirSync3, existsSync as existsSync4, rmSync as rmSync3 } from "fs";
+import { dirname as dirname2, join as join4, resolve as resolve4 } from "path";
+function ensureDir2() {
+  const dir = dirname2(activeDbPath);
+  if (!existsSync4(dir)) {
+    mkdirSync3(dir, { recursive: true });
   }
 }
 function getActiveDbPath() {
@@ -651,7 +921,7 @@ function getActiveDbPath() {
 }
 async function setActiveDbPath(path) {
   if (DB_PATH_PINNED) return;
-  const resolved = resolve(path);
+  const resolved = resolve4(path);
   if (resolved === activeDbPath) return;
   await discardConnection();
   activeDbPath = resolved;
@@ -671,7 +941,7 @@ async function getConnection() {
     }
     await discardConnection();
   }
-  ensureDir();
+  ensureDir2();
   const duckdb = await loadDuckDB();
   db = new duckdb.Database(activeDbPath);
   conn = new duckdb.Connection(db);
@@ -689,20 +959,20 @@ function isClosedConnectionError(err) {
 function closeConnection(c) {
   const close2 = c.close;
   if (typeof close2 !== "function") return Promise.resolve();
-  return new Promise((resolve8) => {
+  return new Promise((resolve10) => {
     try {
-      close2.call(c, () => resolve8());
+      close2.call(c, () => resolve10());
     } catch {
-      resolve8();
+      resolve10();
     }
   });
 }
 function isConnectionAlive(c) {
-  return new Promise((resolve8) => {
+  return new Promise((resolve10) => {
     try {
-      c.all("SELECT 1", (err) => resolve8(!err));
+      c.all("SELECT 1", (err) => resolve10(!err));
     } catch {
-      resolve8(false);
+      resolve10(false);
     }
   });
 }
@@ -716,8 +986,8 @@ async function discardConnection() {
     await closeConnection(currentConn).catch(() => void 0);
   }
   if (currentDb) {
-    await new Promise((resolve8) => {
-      currentDb.close(() => resolve8());
+    await new Promise((resolve10) => {
+      currentDb.close(() => resolve10());
     }).catch(() => void 0);
   }
 }
@@ -732,10 +1002,10 @@ async function withReconnect(op) {
 }
 async function execAllOnce(sql, params) {
   const c = await getConnection();
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve10, reject) => {
     const cb = (err, rows) => {
       if (err) reject(err);
-      else resolve8(rows ?? []);
+      else resolve10(rows ?? []);
     };
     if (params.length > 0) {
       const stmt = c.prepare(sql);
@@ -750,18 +1020,18 @@ async function execAllOnce(sql, params) {
 }
 async function runOnce(sql, params = []) {
   const c = await getConnection();
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve10, reject) => {
     if (params.length > 0) {
       const stmt = c.prepare(sql);
       stmt.run(...params, (err) => {
         stmt.finalize();
         if (err) reject(err);
-        else resolve8();
+        else resolve10();
       });
     } else {
       c.run(sql, (err) => {
         if (err) reject(err);
-        else resolve8();
+        else resolve10();
       });
     }
   });
@@ -781,15 +1051,15 @@ async function close() {
 async function recreateDatabaseFile() {
   await discardConnection();
   for (const path of [activeDbPath, `${activeDbPath}.wal`]) {
-    rmSync2(path, { force: true });
+    rmSync3(path, { force: true });
   }
 }
-var NTRP_DIR, DEFAULT_DB_PATH, DB_PATH_PINNED, activeDbPath, db, conn, duckdbModule, connectionGeneration, lastHealthCheckMs, HEALTH_CHECK_INTERVAL_MS;
+var NTRP_DIR2, DEFAULT_DB_PATH, DB_PATH_PINNED, activeDbPath, db, conn, duckdbModule, connectionGeneration, lastHealthCheckMs, HEALTH_CHECK_INTERVAL_MS;
 var init_connection = __esm({
   "src/db/connection.ts"() {
     "use strict";
-    NTRP_DIR = process.env.NTRP_HOME ? resolve(process.env.NTRP_HOME) : join2(process.env.HOME ?? "", ".ntrp");
-    DEFAULT_DB_PATH = process.env.NTRP_DB_PATH ? resolve(process.env.NTRP_DB_PATH) : join2(NTRP_DIR, "ntrp.duckdb");
+    NTRP_DIR2 = process.env.NTRP_HOME ? resolve4(process.env.NTRP_HOME) : join4(process.env.HOME ?? "", ".ntrp");
+    DEFAULT_DB_PATH = process.env.NTRP_DB_PATH ? resolve4(process.env.NTRP_DB_PATH) : join4(NTRP_DIR2, "ntrp.duckdb");
     DB_PATH_PINNED = !!process.env.NTRP_DB_PATH;
     activeDbPath = DEFAULT_DB_PATH;
     db = null;
@@ -859,9 +1129,9 @@ __export(queries_exports, {
   upsertStrategy: () => upsertStrategy,
   uuid: () => uuid
 });
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 function uuid() {
-  return randomUUID();
+  return randomUUID2();
 }
 function now() {
   return (/* @__PURE__ */ new Date()).toISOString();
@@ -1907,216 +2177,49 @@ CREATE INDEX IF NOT EXISTS idx_health_readings_batch ON health_readings(upload_b
   }
 });
 
-// src/config/store.ts
-var store_exports = {};
-__export(store_exports, {
-  deleteConfigValue: () => deleteConfigValue,
-  getConfigValue: () => getConfigValue,
-  getExportsDir: () => getExportsDir,
-  getKnowledgeDir: () => getKnowledgeDir,
-  getMemoryDir: () => getMemoryDir,
-  getStrategiesDir: () => getStrategiesDir,
-  getWinsDir: () => getWinsDir,
-  loadConfig: () => loadConfig,
-  ntrpHome: () => ntrpHome,
-  resetConfigCache: () => resetConfigCache,
-  saveConfig: () => saveConfig,
-  setConfigValue: () => setConfigValue
-});
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
-import { homedir } from "os";
-import { join as join3, resolve as resolve2 } from "path";
-function ntrpHome() {
-  return NTRP_DIR2;
+// src/config/install.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4, unlinkSync, writeFileSync as writeFileSync5 } from "fs";
+import { join as join5 } from "path";
+function installPath() {
+  return join5(ntrpHome(), "install.json");
 }
-function ensureDir2() {
-  if (!existsSync3(NTRP_DIR2)) {
-    mkdirSync2(NTRP_DIR2, { recursive: true });
+function ensureDir3() {
+  const dir = ntrpHome();
+  if (!existsSync5(dir)) {
+    mkdirSync4(dir, { recursive: true });
   }
 }
-function loadConfig() {
-  if (cachedConfig) return cachedConfig;
-  ensureDir2();
-  if (!existsSync3(CONFIG_PATH)) {
-    cachedConfig = {};
-    return cachedConfig;
-  }
-  try {
-    cachedConfig = JSON.parse(readFileSync2(CONFIG_PATH, "utf-8"));
-  } catch {
-    cachedConfig = {};
-  }
-  return cachedConfig;
+function isValidInstall(value) {
+  if (!value || typeof value !== "object") return false;
+  const r = value;
+  return r.schema_version === 1 && typeof r.install_id === "string" && r.install_id.length > 0 && typeof r.created_at === "string";
 }
-function saveConfig(config) {
-  ensureDir2();
-  writeFileSync3(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
-  cachedConfig = config;
+function ensureInstall() {
+  if (cachedInstall) return cachedInstall;
+  const path = installPath();
+  if (existsSync5(path)) {
+    try {
+      const parsed = JSON.parse(readFileSync4(path, "utf-8"));
+      if (isValidInstall(parsed)) {
+        cachedInstall = parsed;
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  const record = {
+    schema_version: 1,
+    install_id: randomUUID3(),
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  ensureDir3();
+  writeFileSync5(path, JSON.stringify(record, null, 2) + "\n");
+  cachedInstall = record;
+  return record;
 }
-function resetConfigCache() {
-  cachedConfig = null;
-}
-function getConfigValue(key) {
-  if (key === "api-key") return loadConfig()["api-key"];
-  if (key === "license-key") return process.env.NTRP_LICENSE_KEY ?? loadConfig()["license-key"];
-  const config = loadConfig();
-  return config[key];
-}
-function setConfigValue(key, value) {
-  const config = loadConfig();
-  config[key] = value;
-  saveConfig(config);
-}
-function deleteConfigValue(key) {
-  const config = loadConfig();
-  delete config[key];
-  saveConfig(config);
-}
-function getExportsDir() {
-  const config = loadConfig();
-  const dir = resolve2(config["export-dir"] ?? join3(NTRP_DIR2, "exports"));
-  if (!existsSync3(dir)) {
-    mkdirSync2(dir, { recursive: true });
-  }
-  return dir;
-}
-function getStrategiesDir() {
-  const dir = join3(NTRP_DIR2, "strategies");
-  if (!existsSync3(dir)) {
-    mkdirSync2(dir, { recursive: true });
-    writeFileSync3(join3(dir, "README.md"), `# Strategies
-
-This directory holds your GTM strategy files. Each file describes a strategy you're executing.
-
-## How to use
-
-1. Create a markdown file for each active strategy (e.g., \`multi-thread-q2.md\`)
-2. Describe the goal, target segment, and success criteria
-3. Reference playbook plays that support this strategy
-4. After diagnosis, check if vital signs improved in the targeted area
-
-## Example
-
-\`\`\`markdown
-# Multi-Thread Enterprise Deals \u2014 Q2
-
-**Goal:** Reduce single-threaded deals from 65% to under 30%
-**Segment:** Enterprise accounts > $100K
-**Play:** Multi-Thread Your Deals
-**Success metric:** Thread depth score > 70
-\`\`\`
-`);
-  }
-  return dir;
-}
-function getMemoryDir() {
-  const dir = join3(NTRP_DIR2, "memory");
-  if (!existsSync3(dir)) {
-    mkdirSync2(dir, { recursive: true });
-  }
-  return dir;
-}
-function getKnowledgeDir() {
-  const dir = join3(NTRP_DIR2, "knowledge");
-  if (!existsSync3(dir)) {
-    mkdirSync2(dir, { recursive: true });
-    writeFileSync3(join3(dir, "README.md"), `# Knowledge Packs
-
-Drop case studies, GTM frameworks, benchmark reports, or playbooks here as
-markdown, text, or PDF. NTRP ingests them with \`/knowledge add <file>\` and
-references the most relevant passages during analysis \u2014 so the agent can learn
-from work done outside this platform.
-
-## How to use
-
-1. Add a file: \`/knowledge add ~/Downloads/plg-benchmarks-2026.pdf\`
-2. List what's indexed: \`/knowledge list\`
-3. Ask a question \u2014 relevant passages are pulled in automatically.
-`);
-  }
-  return dir;
-}
-function getWinsDir() {
-  const dir = join3(NTRP_DIR2, "wins");
-  if (!existsSync3(dir)) {
-    mkdirSync2(dir, { recursive: true });
-    writeFileSync3(join3(dir, "README.md"), `# Wins
-
-This directory logs outcomes when a strategy or play succeeds. Each win creates a record that future diagnoses can reference.
-
-## How to use
-
-1. After executing a play, log the result here (e.g., \`2026-04-clean-pipeline.md\`)
-2. Include: what you did, what changed, before/after scores
-3. Future AI findings will reference wins to track improvement over time
-
-## Example
-
-\`\`\`markdown
-# Pipeline Cleanup \u2014 April 2026
-
-**Play:** Clean Dead Pipeline
-**Before:** Freshness 29/100, $3.1M stale pipeline
-**After:** Freshness 72/100, removed 45 zombie deals
-**Impact:** Forecast accuracy improved from 62% to 84%
-\`\`\`
-`);
-  }
-  return dir;
-}
-var NTRP_DIR2, CONFIG_PATH, cachedConfig;
-var init_store = __esm({
-  "src/config/store.ts"() {
-    "use strict";
-    NTRP_DIR2 = process.env.NTRP_HOME ? resolve2(process.env.NTRP_HOME) : join3(homedir(), ".ntrp");
-    CONFIG_PATH = join3(NTRP_DIR2, "config.json");
-    cachedConfig = null;
-  }
-});
-
-// src/config/install.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, unlinkSync, writeFileSync as writeFileSync4 } from "fs";
-import { join as join4 } from "path";
-function installPath() {
-  return join4(ntrpHome(), "install.json");
-}
-function ensureDir3() {
-  const dir = ntrpHome();
-  if (!existsSync4(dir)) {
-    mkdirSync3(dir, { recursive: true });
-  }
-}
-function isValidInstall(value) {
-  if (!value || typeof value !== "object") return false;
-  const r = value;
-  return r.schema_version === 1 && typeof r.install_id === "string" && r.install_id.length > 0 && typeof r.created_at === "string";
-}
-function ensureInstall() {
-  if (cachedInstall) return cachedInstall;
-  const path = installPath();
-  if (existsSync4(path)) {
-    try {
-      const parsed = JSON.parse(readFileSync3(path, "utf-8"));
-      if (isValidInstall(parsed)) {
-        cachedInstall = parsed;
-        return parsed;
-      }
-    } catch {
-    }
-  }
-  const record = {
-    schema_version: 1,
-    install_id: randomUUID2(),
-    created_at: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  ensureDir3();
-  writeFileSync4(path, JSON.stringify(record, null, 2) + "\n");
-  cachedInstall = record;
-  return record;
-}
-function getInstallId() {
-  return ensureInstall().install_id;
+function getInstallId() {
+  return ensureInstall().install_id;
 }
 var cachedInstall;
 var init_install = __esm({
@@ -2128,16 +2231,16 @@ var init_install = __esm({
 });
 
 // src/config/progress-migrate.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4, renameSync, writeFileSync as writeFileSync5 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5, renameSync as renameSync2, writeFileSync as writeFileSync6 } from "fs";
+import { join as join6 } from "path";
 function legacyStatePath() {
-  return join5(ntrpHome(), "state.json");
+  return join6(ntrpHome(), "state.json");
 }
 function legacyStateBackupPath() {
-  return join5(ntrpHome(), "state.json.bak");
+  return join6(ntrpHome(), "state.json.bak");
 }
 function progressPath() {
-  return join5(ntrpHome(), "progress.json");
+  return join6(ntrpHome(), "progress.json");
 }
 function isValidLegacyState(value) {
   if (!value || typeof value !== "object") return false;
@@ -2145,11 +2248,11 @@ function isValidLegacyState(value) {
   return s.schema_version === 1 && typeof s.total_minutes_saved === "number" && Array.isArray(s.credits) && Array.isArray(s.milestones_unlocked);
 }
 function migrateLegacyStateIfNeeded(installId) {
-  if (existsSync5(progressPath())) return null;
+  if (existsSync6(progressPath())) return null;
   const legacyPath = legacyStatePath();
-  if (!existsSync5(legacyPath)) return null;
+  if (!existsSync6(legacyPath)) return null;
   try {
-    const parsed = JSON.parse(readFileSync4(legacyPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync5(legacyPath, "utf-8"));
     if (!isValidLegacyState(parsed)) return null;
     const { schema_version: _v, ...rest } = parsed;
     const progress = {
@@ -2157,9 +2260,9 @@ function migrateLegacyStateIfNeeded(installId) {
       schema_version: 2,
       install_id: installId
     };
-    writeFileSync5(progressPath(), JSON.stringify(progress, null, 2) + "\n");
+    writeFileSync6(progressPath(), JSON.stringify(progress, null, 2) + "\n");
     try {
-      renameSync(legacyPath, legacyStateBackupPath());
+      renameSync2(legacyPath, legacyStateBackupPath());
     } catch {
     }
     return progress;
@@ -2264,15 +2367,15 @@ var init_usage_backfill = __esm({
 });
 
 // src/config/progress.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync7 } from "fs";
+import { join as join7 } from "path";
 function progressPath2() {
-  return join6(ntrpHome(), "progress.json");
+  return join7(ntrpHome(), "progress.json");
 }
 function ensureDir4() {
   const dir = ntrpHome();
-  if (!existsSync6(dir)) {
-    mkdirSync4(dir, { recursive: true });
+  if (!existsSync7(dir)) {
+    mkdirSync5(dir, { recursive: true });
   }
 }
 function emptyProgress(installId) {
@@ -2302,9 +2405,9 @@ function reconcileInstallId(state2) {
 }
 function readProgressFile() {
   const path = progressPath2();
-  if (!existsSync6(path)) return { state: null, changed: false };
+  if (!existsSync7(path)) return { state: null, changed: false };
   try {
-    const parsed = JSON.parse(readFileSync5(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync6(path, "utf-8"));
     if (!isValidProgress(parsed)) return { state: null, changed: false };
     return reconcileInstallId(parsed);
   } catch {
@@ -2345,7 +2448,7 @@ function saveProgress(state2) {
     schema_version: 2,
     install_id: getInstallId()
   };
-  writeFileSync6(progressPath2(), JSON.stringify(next, null, 2) + "\n");
+  writeFileSync7(progressPath2(), JSON.stringify(next, null, 2) + "\n");
 }
 function appendCredit(state2, credit) {
   const credits = [...state2.credits, credit];
@@ -3111,20 +3214,20 @@ var init_time_bank = __esm({
 });
 
 // src/ai/llm/providers.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync7 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync8 } from "fs";
+import { join as join8 } from "path";
 function providersPath() {
-  return join7(ntrpHome(), "providers.json");
+  return join8(ntrpHome(), "providers.json");
 }
 function loadCustomProviders() {
   if (cachedEntries) return cachedEntries;
   const path = providersPath();
-  if (!existsSync7(path)) {
+  if (!existsSync8(path)) {
     cachedEntries = [];
     return cachedEntries;
   }
   try {
-    const parsed = JSON.parse(readFileSync6(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync7(path, "utf-8"));
     cachedEntries = Array.isArray(parsed.providers) ? parsed.providers : [];
   } catch {
     cachedEntries = [];
@@ -3885,20 +3988,20 @@ var init_openai_compat = __esm({
 });
 
 // src/ai/llm/models-cache.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync8 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync8, writeFileSync as writeFileSync9 } from "fs";
+import { join as join9 } from "path";
 function cachePath() {
-  return join8(ntrpHome(), "models.json");
+  return join9(ntrpHome(), "models.json");
 }
 function loadFile() {
   if (cached) return cached;
   const path = cachePath();
-  if (!existsSync8(path)) {
+  if (!existsSync9(path)) {
     cached = { version: 1, providers: {} };
     return cached;
   }
   try {
-    const parsed = JSON.parse(readFileSync7(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync8(path, "utf-8"));
     cached = { version: 1, providers: parsed.providers ?? {} };
   } catch {
     cached = { version: 1, providers: {} };
@@ -3906,7 +4009,7 @@ function loadFile() {
   return cached;
 }
 function saveFile(file) {
-  writeFileSync8(cachePath(), JSON.stringify(file, null, 2) + "\n");
+  writeFileSync9(cachePath(), JSON.stringify(file, null, 2) + "\n");
   cached = file;
 }
 function getProviderModels(provider) {
@@ -4067,10 +4170,10 @@ var init_catalog = __esm({
 });
 
 // src/ai/llm/http.ts
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 function fixtureResponse(url, headers) {
   try {
-    const raw = readFileSync8(process.env.NTRP_LLM_HTTP_FIXTURE, "utf-8");
+    const raw = readFileSync9(process.env.NTRP_LLM_HTTP_FIXTURE, "utf-8");
     const entries = JSON.parse(raw);
     const headerValues = Object.values(headers).join(" ");
     for (const entry of entries) {
@@ -5038,24 +5141,24 @@ var init_errors2 = __esm({
 
 // src/strategies/readers.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
-import { extname, resolve as resolve3 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync10 } from "fs";
+import { extname, resolve as resolve5 } from "path";
 import { parse as parseYaml } from "yaml";
 import { PDFParse } from "pdf-parse";
 async function readStrategyFile(pathOrDash) {
   if (pathOrDash === "-") {
-    const text2 = readFileSync9(0, "utf-8");
+    const text2 = readFileSync10(0, "utf-8");
     return createDocument("stdin", null, text2, {});
   }
-  const sourcePath = resolve3(pathOrDash);
-  if (!existsSync9(sourcePath)) {
+  const sourcePath = resolve5(pathOrDash);
+  if (!existsSync10(sourcePath)) {
     throw new NtrpError("strategy_file_not_found", `Strategy file not found: ${pathOrDash}`, 2 /* Usage */);
   }
   const ext = extname(sourcePath).toLowerCase();
   if (ext === ".pdf") {
     return readPdf(sourcePath);
   }
-  const text = readFileSync9(sourcePath, "utf-8");
+  const text = readFileSync10(sourcePath, "utf-8");
   if (ext === ".yaml" || ext === ".yml") {
     const structured = parseStructuredYaml(text);
     return createDocument("yaml", sourcePath, text, structured);
@@ -5070,7 +5173,7 @@ function readStrategyText(text) {
   return createDocument("text", null, text, {});
 }
 async function readPdf(sourcePath) {
-  const data = readFileSync9(sourcePath);
+  const data = readFileSync10(sourcePath);
   const parser = new PDFParse({ data });
   try {
     const result = await parser.getText();
@@ -5117,17 +5220,17 @@ var init_readers = __esm({
 });
 
 // src/memory/knowledge.ts
-import { existsSync as existsSync10, readFileSync as readFileSync10, appendFileSync, readdirSync } from "fs";
-import { join as join9 } from "path";
-import { randomUUID as randomUUID3 } from "crypto";
+import { existsSync as existsSync11, readFileSync as readFileSync11, appendFileSync as appendFileSync2, readdirSync as readdirSync2 } from "fs";
+import { join as join10 } from "path";
+import { randomUUID as randomUUID4 } from "crypto";
 function knowledgePath() {
-  return join9(getMemoryDir(), KNOWLEDGE_FILE);
+  return join10(getMemoryDir(), KNOWLEDGE_FILE);
 }
 function loadKnowledgeChunks() {
   const path = knowledgePath();
-  if (!existsSync10(path)) return [];
+  if (!existsSync11(path)) return [];
   const out = [];
-  for (const line of readFileSync10(path, "utf-8").split("\n")) {
+  for (const line of readFileSync11(path, "utf-8").split("\n")) {
     const trimmed = line.trim();
     if (!trimmed) continue;
     try {
@@ -5160,16 +5263,16 @@ __export(playbook_exports, {
   getPlaysForVitalSign: () => getPlaysForVitalSign,
   matchTriggeredPlays: () => matchTriggeredPlays
 });
-import { existsSync as existsSync11, readFileSync as readFileSync11, appendFileSync as appendFileSync2 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync12, appendFileSync as appendFileSync3 } from "fs";
+import { join as join11 } from "path";
 function playsPath() {
-  return join10(getMemoryDir(), PLAYS_FILE);
+  return join11(getMemoryDir(), PLAYS_FILE);
 }
 function getCustomPlays() {
   const path = playsPath();
-  if (!existsSync11(path)) return [];
+  if (!existsSync12(path)) return [];
   const out = [];
-  for (const line of readFileSync11(path, "utf-8").split("\n")) {
+  for (const line of readFileSync12(path, "utf-8").split("\n")) {
     const trimmed = line.trim();
     if (!trimmed) continue;
     try {
@@ -5201,7 +5304,7 @@ function addCustomPlay(input) {
     source: "learned"
   };
   try {
-    appendFileSync2(playsPath(), JSON.stringify(play) + "\n");
+    appendFileSync3(playsPath(), JSON.stringify(play) + "\n");
   } catch {
   }
   return play;
@@ -5591,15 +5694,15 @@ JSON SHAPE:
 });
 
 // src/strategies/library.ts
-import { writeFileSync as writeFileSync9 } from "fs";
-import { join as join11 } from "path";
+import { writeFileSync as writeFileSync10 } from "fs";
+import { join as join12 } from "path";
 import { stringify as stringifyYaml } from "yaml";
 function strategyLibraryPath(slug) {
-  return join11(getStrategiesDir(), `${slug}.md`);
+  return join12(getStrategiesDir(), `${slug}.md`);
 }
 function writeStrategyMarkdown(strategy) {
   const path = strategyLibraryPath(strategy.slug);
-  writeFileSync9(path, renderStrategyMarkdown(strategy), "utf-8");
+  writeFileSync10(path, renderStrategyMarkdown(strategy), "utf-8");
   return path;
 }
 function renderStrategyMarkdown(strategy) {
@@ -5723,12 +5826,12 @@ var init_library = __esm({
 });
 
 // src/strategies/connectors.ts
-import { readdirSync as readdirSync2, statSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { basename, extname as extname2, join as join12, relative, resolve as resolve4, sep } from "path";
+import { readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { basename as basename2, extname as extname2, join as join13, relative, resolve as resolve6, sep as sep3 } from "path";
 function createLocalFolderConnector(options) {
-  const rootPath = resolveUserPath(options.rootPath);
-  const name = options.name ?? (basename(rootPath) || "local");
+  const rootPath = resolveUserPath2(options.rootPath);
+  const name = options.name ?? (basename2(rootPath) || "local");
   const includePatterns = normalizePatterns(options.includePatterns);
   const excludePatterns = normalizePatterns(options.excludePatterns);
   const maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
@@ -5767,8 +5870,8 @@ function createLocalFolderConnector(options) {
   };
 }
 function walkLocalFolder(rootPath, currentPath, refs, opts) {
-  for (const entry of readdirSync2(currentPath, { withFileTypes: true })) {
-    const absolutePath = join12(currentPath, entry.name);
+  for (const entry of readdirSync3(currentPath, { withFileTypes: true })) {
+    const absolutePath = join13(currentPath, entry.name);
     const relativePath = normalizePath(relative(rootPath, absolutePath));
     if (entry.isDirectory()) {
       if (shouldSkipDirectory(entry.name) || matchesAny(relativePath, opts.excludePatterns)) continue;
@@ -5802,7 +5905,7 @@ function shouldSkipDirectory(name) {
 }
 function safeStat(path) {
   try {
-    return statSync(path);
+    return statSync2(path);
   } catch {
     return null;
   }
@@ -5816,7 +5919,7 @@ function matchesAny(relativePath, patterns) {
 function matchesPattern(relativePath, pattern) {
   const normalizedPath = normalizePath(relativePath);
   const normalizedPattern = normalizePath(pattern);
-  const base = basename(normalizedPath);
+  const base = basename2(normalizedPath);
   if (!normalizedPattern.includes("*")) {
     return normalizedPath === normalizedPattern || normalizedPath.endsWith(`/${normalizedPattern}`) || normalizedPath.includes(normalizedPattern);
   }
@@ -5828,12 +5931,12 @@ function wildcardToRegExp(pattern) {
   return new RegExp(`^${escaped}$`, "i");
 }
 function normalizePath(path) {
-  return path.split(sep).join("/");
+  return path.split(sep3).join("/");
 }
-function resolveUserPath(path) {
-  if (path === "~") return homedir2();
-  if (path.startsWith("~/")) return join12(homedir2(), path.slice(2));
-  return resolve4(path);
+function resolveUserPath2(path) {
+  if (path === "~") return homedir3();
+  if (path.startsWith("~/")) return join13(homedir3(), path.slice(2));
+  return resolve6(path);
 }
 var DEFAULT_MAX_FILES, DEFAULT_MAX_BYTES, SUPPORTED_EXTENSIONS, DEFAULT_EXCLUDED_DIRS;
 var init_connectors = __esm({
@@ -6044,17 +6147,17 @@ __export(store_exports2, {
   rewriteJsonl: () => rewriteJsonl,
   scrubText: () => scrubText
 });
-import { existsSync as existsSync12, readFileSync as readFileSync12, appendFileSync as appendFileSync3, readdirSync as readdirSync3, writeFileSync as writeFileSync10 } from "fs";
-import { join as join13 } from "path";
-import { randomUUID as randomUUID4 } from "crypto";
+import { existsSync as existsSync13, readFileSync as readFileSync13, appendFileSync as appendFileSync4, readdirSync as readdirSync4, writeFileSync as writeFileSync11 } from "fs";
+import { join as join14 } from "path";
+import { randomUUID as randomUUID5 } from "crypto";
 function memPath(file) {
-  return join13(getMemoryDir(), file);
+  return join14(getMemoryDir(), file);
 }
 function readJsonl(file) {
   const path = memPath(file);
-  if (!existsSync12(path)) return [];
+  if (!existsSync13(path)) return [];
   const out = [];
-  for (const line of readFileSync12(path, "utf-8").split("\n")) {
+  for (const line of readFileSync13(path, "utf-8").split("\n")) {
     const trimmed = line.trim();
     if (!trimmed) continue;
     try {
@@ -6066,13 +6169,13 @@ function readJsonl(file) {
 }
 function appendJsonl(file, obj) {
   try {
-    appendFileSync3(memPath(file), JSON.stringify(obj) + "\n");
+    appendFileSync4(memPath(file), JSON.stringify(obj) + "\n");
   } catch {
   }
 }
 function rewriteJsonl(file, rows) {
   try {
-    writeFileSync10(memPath(file), rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length ? "\n" : ""));
+    writeFileSync11(memPath(file), rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length ? "\n" : ""));
   } catch {
   }
 }
@@ -6081,7 +6184,7 @@ function scrubText(text) {
 }
 function addFact(input) {
   const fact = {
-    id: randomUUID4(),
+    id: randomUUID5(),
     text: scrubText(input.text),
     kind: input.kind ?? "fact",
     source: input.source ?? "user",
@@ -6108,7 +6211,7 @@ function summarizeAnswer(answer) {
 }
 function recordAnalysis(input) {
   const entry = {
-    id: randomUUID4(),
+    id: randomUUID5(),
     question: scrubText(input.question).slice(0, 300),
     summary: scrubText(summarizeAnswer(input.answer)),
     tools: input.tools,
@@ -6138,9 +6241,9 @@ function loadWinSnippets() {
   try {
     const dir = getWinsDir();
     const out = [];
-    for (const name of readdirSync3(dir)) {
+    for (const name of readdirSync4(dir)) {
       if (!name.endsWith(".md") || name.toLowerCase() === "readme.md") continue;
-      const raw = readFileSync12(join13(dir, name), "utf-8");
+      const raw = readFileSync13(join14(dir, name), "utf-8");
       const title = raw.match(/^#\s+(.+)$/m)?.[1]?.trim() ?? name.replace(/\.md$/, "");
       const body = raw.replace(/^#.*$/m, "").replace(/\s+/g, " ").trim().slice(0, 300);
       out.push({ id: `win:${name}`, title, text: `${title}. ${body}` });
@@ -6342,7 +6445,7 @@ async function distillSessionFactsWithTimeout(ctx, sessionId, timeoutMs = DISTIL
   });
   const raced = await Promise.race([
     work,
-    new Promise((resolve8) => setTimeout(() => resolve8(-1), timeoutMs))
+    new Promise((resolve10) => setTimeout(() => resolve10(-1), timeoutMs))
   ]);
   if (raced >= 0) return { count: raced, background };
   if (settled) return { count: await background, background };
@@ -6420,10 +6523,10 @@ __export(context_exports, {
   setPrimaryLens: () => setPrimaryLens,
   transcriptPathForSession: () => transcriptPathForSession
 });
-import { basename as basename2, join as join14, resolve as resolve5, sep as sep2 } from "path";
-import { existsSync as existsSync13, mkdirSync as mkdirSync5, writeFileSync as writeFileSync11, readFileSync as readFileSync13, readdirSync as readdirSync4, statSync as statSync2, rmSync as rmSync3 } from "fs";
-import { homedir as homedir3 } from "os";
-import { randomUUID as randomUUID5 } from "crypto";
+import { basename as basename3, join as join15, resolve as resolve7, sep as sep4 } from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync6, writeFileSync as writeFileSync12, readFileSync as readFileSync14, readdirSync as readdirSync5, statSync as statSync3, rmSync as rmSync4 } from "fs";
+import { homedir as homedir4 } from "os";
+import { randomUUID as randomUUID6 } from "crypto";
 function isSessionStale(s) {
   return Date.now() - s.mtime > STALE_SESSION_MS;
 }
@@ -6436,35 +6539,35 @@ function isAnalysisReady(ctx) {
   return Object.values(counts).some((n) => n > 0);
 }
 function ntrpHomeDir() {
-  return process.env.NTRP_HOME ? resolve5(process.env.NTRP_HOME) : join14(homedir3(), ".ntrp");
+  return process.env.NTRP_HOME ? resolve7(process.env.NTRP_HOME) : join15(homedir4(), ".ntrp");
 }
 function getSessionsDir() {
-  const dir = join14(ntrpHomeDir(), "sessions");
-  if (!existsSync13(dir)) {
-    mkdirSync5(dir, { recursive: true });
+  const dir = join15(ntrpHomeDir(), "sessions");
+  if (!existsSync14(dir)) {
+    mkdirSync6(dir, { recursive: true });
   }
   return dir;
 }
 function getDatasetsDir() {
-  const dir = join14(ntrpHomeDir(), "datasets");
-  if (!existsSync13(dir)) {
-    mkdirSync5(dir, { recursive: true });
+  const dir = join15(ntrpHomeDir(), "datasets");
+  if (!existsSync14(dir)) {
+    mkdirSync6(dir, { recursive: true });
   }
   return dir;
 }
 function datasetPathForSession(id) {
-  return join14(getDatasetsDir(), `${id}.duckdb`);
+  return join15(getDatasetsDir(), `${id}.duckdb`);
 }
 function transcriptPathForSession(id) {
-  return join14(getSessionsDir(), `${id}.transcript.md`);
+  return join15(getSessionsDir(), `${id}.transcript.md`);
 }
 function contextDocPathForSession(id) {
-  return join14(getSessionsDir(), `${id}.context.md`);
+  return join15(getSessionsDir(), `${id}.context.md`);
 }
 function makeSessionId() {
   const now2 = /* @__PURE__ */ new Date();
   const date = now2.toISOString().slice(0, 10);
-  const uuid2 = randomUUID5().slice(0, 4);
+  const uuid2 = randomUUID6().slice(0, 4);
   return `${date}-${uuid2}`;
 }
 function isValidSessionId(id) {
@@ -6472,14 +6575,14 @@ function isValidSessionId(id) {
 }
 function sessionPathForId(id) {
   if (!isValidSessionId(id)) return null;
-  const dir = resolve5(getSessionsDir());
-  const filePath = resolve5(dir, `${id}.json`);
-  if (filePath !== dir && !filePath.startsWith(dir + sep2)) return null;
+  const dir = resolve7(getSessionsDir());
+  const filePath = resolve7(dir, `${id}.json`);
+  if (filePath !== dir && !filePath.startsWith(dir + sep4)) return null;
   return filePath;
 }
 function initContext(oneShot, execution) {
   const sessionId = makeSessionId();
-  const sessionFile = join14(getSessionsDir(), `${sessionId}.json`);
+  const sessionFile = join15(getSessionsDir(), `${sessionId}.json`);
   return {
     sessionId,
     sessionFile,
@@ -6593,7 +6696,7 @@ function recordMessage(ctx, role, content) {
   ctx.messages.push(msg);
   if (ctx.oneShot) return;
   try {
-    writeFileSync11(ctx.sessionFile, JSON.stringify(buildSessionFileSnapshot(ctx), null, 2) + "\n");
+    writeFileSync12(ctx.sessionFile, JSON.stringify(buildSessionFileSnapshot(ctx), null, 2) + "\n");
   } catch {
   }
   writeSessionContextDoc(ctx);
@@ -6601,7 +6704,7 @@ function recordMessage(ctx, role, content) {
 function saveSessionState(ctx) {
   if (ctx.oneShot) return;
   try {
-    writeFileSync11(ctx.sessionFile, JSON.stringify(buildSessionFileSnapshot(ctx), null, 2) + "\n");
+    writeFileSync12(ctx.sessionFile, JSON.stringify(buildSessionFileSnapshot(ctx), null, 2) + "\n");
   } catch {
   }
   writeSessionContextDoc(ctx);
@@ -6610,9 +6713,9 @@ function getLastActivityRelative() {
   const dir = getSessionsDir();
   let mostRecent = 0;
   try {
-    for (const name of readdirSync4(dir)) {
+    for (const name of readdirSync5(dir)) {
       if (!name.endsWith(".json")) continue;
-      const m = statSync2(join14(dir, name)).mtimeMs;
+      const m = statSync3(join15(dir, name)).mtimeMs;
       if (m > mostRecent) mostRecent = m;
     }
   } catch {
@@ -6638,7 +6741,7 @@ function loadSessionFile(id) {
   const filePath = sessionPathForId(id);
   if (!filePath) return null;
   try {
-    const raw = readFileSync13(filePath, "utf-8");
+    const raw = readFileSync14(filePath, "utf-8");
     const session = JSON.parse(raw);
     if (session.thread?.length) {
       session.thread = normalizeThread(session.thread);
@@ -6652,16 +6755,16 @@ function listSessions(opts) {
   const dir = getSessionsDir();
   const entries = [];
   try {
-    const files = readdirSync4(dir).filter((name) => name.endsWith(".json")).map((name) => {
-      const filePath = join14(dir, name);
-      return { name, filePath, mtime: statSync2(filePath).mtimeMs };
+    const files = readdirSync5(dir).filter((name) => name.endsWith(".json")).map((name) => {
+      const filePath = join15(dir, name);
+      return { name, filePath, mtime: statSync3(filePath).mtimeMs };
     }).sort((a, b) => b.mtime - a.mtime);
     const filesToRead = opts?.limit ? files.slice(0, opts.limit) : files;
     for (const { name, filePath, mtime } of filesToRead) {
-      const id = basename2(name, ".json");
+      const id = basename3(name, ".json");
       if (!isValidSessionId(id)) continue;
       try {
-        const raw = readFileSync13(filePath, "utf-8");
+        const raw = readFileSync14(filePath, "utf-8");
         const session = JSON.parse(raw);
         entries.push({
           id,
@@ -6723,7 +6826,7 @@ async function closeAllActiveSessions(ctx) {
       skipped.push(s.id);
       continue;
     }
-    writeFileSync11(filePath, JSON.stringify(file, null, 2) + "\n");
+    writeFileSync12(filePath, JSON.stringify(file, null, 2) + "\n");
     writeContextDocForSessionFile(file);
     closed.push(s.id);
   }
@@ -6763,7 +6866,7 @@ async function rotateToFreshSession(ctx) {
   const newId = makeSessionId();
   resetContextForSwitch(ctx, {
     sessionId: newId,
-    sessionFile: join14(getSessionsDir(), `${newId}.json`),
+    sessionFile: join15(getSessionsDir(), `${newId}.json`),
     messages: [],
     stage: "new",
     analysis: defaultSessionAnalysis(),
@@ -6802,14 +6905,14 @@ async function finalizeSession(ctx, stage) {
       }
       for (const path of [ctx.datasetPath, `${ctx.datasetPath}.wal`]) {
         try {
-          rmSync3(path, { force: true });
+          rmSync4(path, { force: true });
         } catch {
         }
       }
     }
     discardSessionTranscript(ctx.sessionId);
     try {
-      rmSync3(contextDocPathForSession(ctx.sessionId), { force: true });
+      rmSync4(contextDocPathForSession(ctx.sessionId), { force: true });
     } catch {
     }
     return void 0;
@@ -6864,7 +6967,7 @@ async function finalizeSession(ctx, stage) {
     file.pending_ask = ctx.pendingAsk;
   }
   try {
-    writeFileSync11(ctx.sessionFile, JSON.stringify(file, null, 2) + "\n");
+    writeFileSync12(ctx.sessionFile, JSON.stringify(file, null, 2) + "\n");
   } catch {
   }
   writeContextDocForSessionFile(file, { snapshot: ctx.snapshot.computeResult });
@@ -8020,22 +8123,22 @@ var init_health_score = __esm({
 });
 
 // src/config/profile.ts
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync12, existsSync as existsSync14, mkdirSync as mkdirSync6 } from "fs";
-import { join as join15 } from "path";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync13, existsSync as existsSync15, mkdirSync as mkdirSync7 } from "fs";
+import { join as join16 } from "path";
 function profilePath() {
   return PROFILE_PATH;
 }
 function profileExists() {
-  return existsSync14(PROFILE_PATH);
+  return existsSync15(PROFILE_PATH);
 }
 function isProfileConfigured(profile = loadProfile()) {
   if (!profile) return false;
   return profile.company_name.trim().length > 0;
 }
 function loadProfile() {
-  if (!existsSync14(PROFILE_PATH)) return null;
+  if (!existsSync15(PROFILE_PATH)) return null;
   try {
-    const parsed = JSON.parse(readFileSync14(PROFILE_PATH, "utf-8"));
+    const parsed = JSON.parse(readFileSync15(PROFILE_PATH, "utf-8"));
     if (!parsed || typeof parsed !== "object") return null;
     return parsed;
   } catch {
@@ -8048,7 +8151,7 @@ var init_profile = __esm({
     "use strict";
     init_store();
     NTRP_DIR3 = ntrpHome();
-    PROFILE_PATH = join15(NTRP_DIR3, "profile.json");
+    PROFILE_PATH = join16(NTRP_DIR3, "profile.json");
   }
 });
 
@@ -8060,17 +8163,17 @@ __export(play_outcomes_exports, {
   listPlayOutcomes: () => listPlayOutcomes,
   recordPlayOutcomes: () => recordPlayOutcomes
 });
-import { existsSync as existsSync15, readFileSync as readFileSync15, appendFileSync as appendFileSync4 } from "fs";
-import { join as join16 } from "path";
-import { randomUUID as randomUUID6 } from "crypto";
+import { existsSync as existsSync16, readFileSync as readFileSync16, appendFileSync as appendFileSync5 } from "fs";
+import { join as join17 } from "path";
+import { randomUUID as randomUUID7 } from "crypto";
 function outcomesPath() {
-  return join16(getMemoryDir(), OUTCOMES_FILE);
+  return join17(getMemoryDir(), OUTCOMES_FILE);
 }
 function listPlayOutcomes() {
   const path = outcomesPath();
-  if (!existsSync15(path)) return [];
+  if (!existsSync16(path)) return [];
   const out = [];
-  for (const line of readFileSync15(path, "utf-8").split("\n")) {
+  for (const line of readFileSync16(path, "utf-8").split("\n")) {
     const trimmed = line.trim();
     if (!trimmed) continue;
     try {
@@ -8100,7 +8203,7 @@ function recordPlayOutcomes(strategy, outcomes, batchId) {
       if (seen.has(key)) continue;
       seen.add(key);
       const record = {
-        id: randomUUID6(),
+        id: randomUUID7(),
         play_id: playId,
         strategy_slug: strategy.slug,
         workstream_order: outcome.workstream_order,
@@ -8113,7 +8216,7 @@ function recordPlayOutcomes(strategy, outcomes, batchId) {
         reviewed_at: (/* @__PURE__ */ new Date()).toISOString()
       };
       try {
-        appendFileSync4(outcomesPath(), JSON.stringify(record) + "\n");
+        appendFileSync5(outcomesPath(), JSON.stringify(record) + "\n");
         written++;
       } catch {
       }
@@ -8261,7 +8364,40 @@ Close the loop to action. Produce a markdown report, a notes export, CSV
 receipts, or a repository package \u2014 or generate a ready-to-paste prompt for
 another agent to build a review deck, an Asana project, a Clay table, or an
 action plan from this diagnosis. Producing an output marks the session
-delivered so it stops showing up as unfinished work.`
+delivered so it stops showing up as unfinished work. Files land under
+\`export-dir\` by kind; point Claude Desktop at a folder with \`/inbox set\`.`
+      },
+      {
+        name: "exports",
+        raw: `---
+name: exports
+description: List, open, or move export files
+section: Start
+args: [list [kind]|open|move <id|file> <dest>]
+handler: ../commands/exports.ts
+---
+
+Catalog of handoffs and other deliverables. Lists recent writes from the
+durable \`manifest.jsonl\` under your export archive, prints absolute paths
+(\`open\`), and relocates files while recording the move trail so desktop AI
+apps can see where things went (\`move\`). Companion: \`/inbox\` sets the
+Claude-facing folder with stable \`latest-*\` pointers.`
+      },
+      {
+        name: "inbox",
+        raw: `---
+name: inbox
+description: Set the desktop-AI folder for handoffs
+section: Settings
+args: [show|set <path>|clear]
+handler: ../commands/exports.ts
+---
+
+Declare a folder Claude Desktop (or any desktop AI) can read. NTRP copies
+each handoff there and overwrites stable \`latest-handoff.md\` /
+\`latest-handoff-deck.md\` pointers so the app always finds the newest file.
+\`INDEX.md\` in that folder links back to the canonical archive. Does not
+delete files on \`clear\` \u2014 only removes the config pointer.`
       },
       {
         name: "onboard",
@@ -8307,7 +8443,8 @@ Validate local readiness or configure NTRP non-interactively for automation.
 \`setup check --json\` reports license, profile, API key, database, and writable
 directory state. \`setup agent\` accepts a profile JSON file or direct flags \u2014
 \`--llm-key <key>\` auto-detects the provider from any pasted key
-(\`--llm-provider <id>\` to force one).`
+(\`--llm-provider <id>\` to force one), plus \`--export-dir\` and
+\`--ai-inbox-dir\` for deliverable locations.`
       },
       {
         name: "update",
@@ -8604,6 +8741,22 @@ handler: ../commands/progress.ts
 Hours saved, weekly activity trend, session counts, AI token usage, and the
 full milestone ladder with progress bars. Use reset (type "reset" to confirm)
 to clear hours and milestones while keeping this install's identity.`
+      },
+      {
+        name: "deepdive",
+        raw: `---
+name: deepdive
+description: Metric slides \u2014 what each number means
+section: Navigation
+args: [<metric>|list|tour]
+handler: ../commands/deepdive.ts
+---
+
+CLI slide deck for every vital sign and SaaS metric: definition, formula,
+visual, and dollar translation. Bare \`/deepdive\` runs the onboarding tour
+(SaaS refresher + five vitals). \`/deepdive <metric>\` jumps to one slide.
+\`/deepdive list\` prints the catalog. Works without an AI key. Re-run anytime
+from the homescreen \u2014 live values overlay when an analysis exists.`
       },
       {
         name: "status",
@@ -8782,7 +8935,7 @@ handler: ../commands/config.ts
 Manage CLI configuration stored at \`~/.ntrp/config.json\`. Useful keys:
 \`api-key\` (Anthropic), \`openai-api-key\` (and \`groq-api-key\`, \`google-api-key\`, ...),
 \`llm-primary\` (default engine), \`llm-tier\`, \`llm-auto-failover\`,
-\`default-format\`, \`export-dir\`.
+\`default-format\`, \`export-dir\`, \`ai-inbox-dir\` (or use \`/inbox set\`).
 
 Setting a provider key opens a hidden prompt and auto-discovers that
 provider's models. Prefer \`/connect\` \u2014 it detects the provider for you.`
@@ -8888,8 +9041,8 @@ paragraph that flows into all AI surfaces.`
 });
 
 // src/ai/prompt-parts.ts
-import { existsSync as existsSync16, readFileSync as readFileSync16 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync17 } from "fs";
+import { join as join18 } from "path";
 function buildCompanyProfileBlock() {
   const p = loadProfile();
   if (!p) return "";
@@ -8908,10 +9061,10 @@ function buildCompanyProfileBlock() {
   return lines.join("\n");
 }
 function loadAnalystFile() {
-  const path = join17(ntrpHome(), ANALYST_FILE_NAME);
+  const path = join18(ntrpHome(), ANALYST_FILE_NAME);
   try {
-    if (!existsSync16(path)) return null;
-    const raw = readFileSync16(path, "utf-8").trim();
+    if (!existsSync17(path)) return null;
+    const raw = readFileSync17(path, "utf-8").trim();
     if (!raw) return null;
     if (raw.length <= ANALYST_FILE_MAX_CHARS) return raw;
     const head = raw.slice(0, Math.floor(ANALYST_FILE_MAX_CHARS * 0.75));
@@ -9668,9 +9821,9 @@ var init_tool_schemas = __esm({
 });
 
 // src/ai/privacy.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync7, appendFileSync as appendFileSync5 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join18 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync8, appendFileSync as appendFileSync6 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join19 } from "path";
 function stripPII(obj) {
   if (obj === null || obj === void 0) return obj;
   if (typeof obj !== "object") return obj;
@@ -9685,15 +9838,15 @@ function stripPII(obj) {
   return out;
 }
 function ensureAuditDir() {
-  if (!existsSync17(AUDIT_DIR)) {
-    mkdirSync7(AUDIT_DIR, { recursive: true });
+  if (!existsSync18(AUDIT_DIR)) {
+    mkdirSync8(AUDIT_DIR, { recursive: true });
   }
 }
 function logToolCall(entry) {
   ensureAuditDir();
   const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const path = join18(AUDIT_DIR, `agentic-${date}.jsonl`);
-  appendFileSync5(path, JSON.stringify(entry) + "\n");
+  const path = join19(AUDIT_DIR, `agentic-${date}.jsonl`);
+  appendFileSync6(path, JSON.stringify(entry) + "\n");
 }
 var PII_FIELDS, AUDIT_DIR;
 var init_privacy = __esm({
@@ -9716,7 +9869,7 @@ var init_privacy = __esm({
       "raw_data",
       "metadata"
     ]);
-    AUDIT_DIR = join18(homedir4(), ".ntrp", "audit");
+    AUDIT_DIR = join19(homedir5(), ".ntrp", "audit");
   }
 });
 
@@ -11705,7 +11858,7 @@ function createPromptSession(existing, ctx) {
     }
     process.stdout.write("\n" + prompt);
     try {
-      return await new Promise((resolve8, reject) => {
+      return await new Promise((resolve10, reject) => {
         let value = "";
         let settled = false;
         const cleanup = () => {
@@ -11741,7 +11894,7 @@ function createPromptSession(existing, ctx) {
                 process.stdout.write("\n");
                 const trimmed = stripTerminalArtifacts(value).trim();
                 assertNotGlobalReplCommand(trimmed);
-                resolve8(trimmed);
+                resolve10(trimmed);
               });
               return;
             }
@@ -11757,7 +11910,7 @@ function createPromptSession(existing, ctx) {
                 process.stdout.write("\n");
                 const trimmed = stripTerminalArtifacts(value).trim();
                 assertNotGlobalReplCommand(trimmed);
-                resolve8(trimmed);
+                resolve10(trimmed);
               });
               return;
             }
@@ -12525,8 +12678,25 @@ var init_llm_attribution = __esm({
   }
 });
 
-// src/output/terminal.ts
+// src/ui/slides.ts
 import chalk9 from "chalk";
+function printDeepdiveHint(metricId, label) {
+  const name = label ?? metricId;
+  console.log(
+    "  " + chalk9.dim("How this number works: ") + paint("accent", `/deepdive ${metricId}`) + chalk9.dim(` \u2014 ${name}`)
+  );
+  console.log();
+}
+var init_slides = __esm({
+  "src/ui/slides.ts"() {
+    "use strict";
+    init_theme();
+    init_layout();
+  }
+});
+
+// src/output/terminal.ts
+import chalk10 from "chalk";
 import Table2 from "cli-table3";
 function centerPad(text, width) {
   if (text.length >= width) return text;
@@ -12545,7 +12715,7 @@ function statusBadge(status) {
   }
 }
 function printHeading(label, detail) {
-  console.log(`  ${sectionHeading(label)}${detail ? chalk9.dim(` ${detail}`) : ""}`);
+  console.log(`  ${sectionHeading(label)}${detail ? chalk10.dim(` ${detail}`) : ""}`);
 }
 function printResultCard(title, rows) {
   const width = resolveCardWidth({ min: 60, max: 100, margin: 4 });
@@ -12566,32 +12736,39 @@ function printVitalSignRow(vs) {
   const label = VITAL_SIGN_LABELS[vs.vital_sign].padEnd(18);
   const bar = scoreBar(vs.score, vs.status);
   const score = String(Math.round(vs.score)).padStart(4);
-  const impact = vs.dollar_value != null && vs.dollar_value > 0 ? `${paint("success", formatCurrency(vs.dollar_value))} ${chalk9.dim(vs.dollar_label ?? "")}` : chalk9.dim("\u2014");
-  console.log(`  ${dot} ${label} ${bar}  ${chalk9.bold(score)}  ${chalk9.dim("\u2502")}  ${impact}`);
+  const impact = vs.dollar_value != null && vs.dollar_value > 0 ? `${paint("success", formatCurrency(vs.dollar_value))} ${chalk10.dim(vs.dollar_label ?? "")}` : chalk10.dim("\u2014");
+  console.log(`  ${dot} ${label} ${bar}  ${chalk10.bold(score)}  ${chalk10.dim("\u2502")}  ${impact}`);
 }
 function printHealthSummary(result, _pipelineMetrics) {
-  const scoreStr = `${chalk9.bold(String(Math.round(result.overall_score)))}${chalk9.dim("/100")}`;
-  const impact = result.total_value_at_risk != null && result.total_value_at_risk > 0 ? `${paint("success", formatCurrency(result.total_value_at_risk))} ${chalk9.dim("total at risk")}` : chalk9.dim("No dollar-weighted risk detected");
+  const scoreStr = `${chalk10.bold(String(Math.round(result.overall_score)))}${chalk10.dim("/100")}`;
+  const impact = result.total_value_at_risk != null && result.total_value_at_risk > 0 ? `${paint("success", formatCurrency(result.total_value_at_risk))} ${chalk10.dim("total at risk")}` : chalk10.dim("No dollar-weighted risk detected");
   const next = result.overall_status === "red" ? actionHint("Next:", "/playbook", "review recommended plays") : result.overall_status === "yellow" ? actionHint("Next:", "/diagnose --deep", "investigate the weak signal") : actionHint("Next:", "/report", "export the clean snapshot");
   printResultCard("Overall Health", [
-    `${chalk9.dim("Score")}          ${scoreStr}  ${statusBadge(result.overall_status)}`,
-    `${chalk9.dim("Held back by")}   ${paint("accent", VITAL_SIGN_LABELS[result.gating_vital_sign])}`,
-    `${chalk9.dim("Revenue")}        ${impact}`,
+    `${chalk10.dim("Score")}          ${scoreStr}  ${statusBadge(result.overall_status)}`,
+    `${chalk10.dim("Held back by")}   ${paint("accent", VITAL_SIGN_LABELS[result.gating_vital_sign])}`,
+    `${chalk10.dim("Revenue")}        ${impact}`,
     next
   ]);
+  printDeepdiveHint(
+    result.gating_vital_sign,
+    VITAL_SIGN_LABELS[result.gating_vital_sign]
+  );
 }
 function printHealthLine(result) {
-  const score = `${chalk9.bold(String(Math.round(result.overall_score)))}${chalk9.dim("/100")}`;
+  const score = `${chalk10.bold(String(Math.round(result.overall_score)))}${chalk10.dim("/100")}`;
   const parts = [
-    `${chalk9.dim("Health")} ${score} ${statusBadge(result.overall_status)}`,
-    `${chalk9.dim("held back by")} ${paint("accent", VITAL_SIGN_LABELS[result.gating_vital_sign])}`
+    `${chalk10.dim("Health")} ${score} ${statusBadge(result.overall_status)}`,
+    `${chalk10.dim("held back by")} ${paint("accent", VITAL_SIGN_LABELS[result.gating_vital_sign])}`
   ];
   if (result.total_value_at_risk != null && result.total_value_at_risk > 0) {
-    parts.push(`${paint("success", formatCurrency(result.total_value_at_risk))} ${chalk9.dim("total at risk")}`);
+    parts.push(`${paint("success", formatCurrency(result.total_value_at_risk))} ${chalk10.dim("total at risk")}`);
   }
   console.log();
-  console.log("  " + parts.join(chalk9.dim(" \xB7 ")));
-  console.log();
+  console.log("  " + parts.join(chalk10.dim(" \xB7 ")));
+  printDeepdiveHint(
+    result.gating_vital_sign,
+    VITAL_SIGN_LABELS[result.gating_vital_sign]
+  );
 }
 function printVitalSigns(vitals) {
   console.log();
@@ -12610,8 +12787,8 @@ function printSegmentSummary(segments) {
     const dot = statusDot(seg.result.overall_status);
     const name = seg.segment.name.padEnd(24);
     const score = String(Math.round(seg.result.overall_score)).padStart(4);
-    const gating = chalk9.dim(VITAL_SIGN_LABELS[seg.result.gating_vital_sign]);
-    console.log(`  ${dot} ${name} ${chalk9.bold(score)}  ${chalk9.dim("\u2502")}  ${gating}`);
+    const gating = chalk10.dim(VITAL_SIGN_LABELS[seg.result.gating_vital_sign]);
+    console.log(`  ${dot} ${name} ${chalk10.bold(score)}  ${chalk10.dim("\u2502")}  ${gating}`);
   }
   console.log();
 }
@@ -12636,7 +12813,7 @@ function printTopProblems(segments, limit = 7, opts = {}) {
     if (opts.compact) return;
     printHeading("Top Problems");
     console.log();
-    console.log("  " + chalk9.dim("No dollar-weighted problems found across segments."));
+    console.log("  " + chalk10.dim("No dollar-weighted problems found across segments."));
     console.log();
     return;
   }
@@ -12651,12 +12828,12 @@ function printTopProblems(segments, limit = 7, opts = {}) {
     for (let i = 0; i < top.length; i++) {
       const p = top[i];
       console.log(
-        `  ${statusDot(p.status)} ${p.segment.padEnd(segW)}  ${p.vitalSignLabel.padEnd(vitalW)}  ${paint("success", dollarStrs[i].padStart(dollarW))}  ${chalk9.dim(p.dollarLabel)}`
+        `  ${statusDot(p.status)} ${p.segment.padEnd(segW)}  ${p.vitalSignLabel.padEnd(vitalW)}  ${paint("success", dollarStrs[i].padStart(dollarW))}  ${chalk10.dim(p.dollarLabel)}`
       );
     }
     if (problems.length > top.length) {
       console.log(
-        "  " + chalk9.dim(`${problems.length - top.length} more \u2014 `) + paint("accent", "/diagnose") + chalk9.dim(" for the full report")
+        "  " + chalk10.dim(`${problems.length - top.length} more \u2014 `) + paint("accent", "/diagnose") + chalk10.dim(" for the full report")
       );
     }
     console.log();
@@ -12665,14 +12842,14 @@ function printTopProblems(segments, limit = 7, opts = {}) {
   const labelW = Math.max("".length, ...top.map((p) => p.dollarLabel.length));
   const impactW = dollarW + 2 + labelW;
   console.log(
-    `  ${sectionHeading("Top Problems")}` + chalk9.dim(` (${top.length} of ${problems.length})`)
+    `  ${sectionHeading("Top Problems")}` + chalk10.dim(` (${top.length} of ${problems.length})`)
   );
   console.log();
   const segColW = 2 + segW;
   const hSeg = centerPad("Segment", segColW);
   const hVital = centerPad("Vital Sign", vitalW);
   const hImpact = centerPad("Revenue Impact", Math.max(impactW, "Revenue Impact".length));
-  console.log(`  ${chalk9.dim(hSeg)}  ${chalk9.dim(hVital)}  ${chalk9.dim(hImpact)}`);
+  console.log(`  ${chalk10.dim(hSeg)}  ${chalk10.dim(hVital)}  ${chalk10.dim(hImpact)}`);
   console.log();
   for (let i = 0; i < top.length; i++) {
     const p = top[i];
@@ -12680,39 +12857,46 @@ function printTopProblems(segments, limit = 7, opts = {}) {
     const seg = p.segment.padEnd(segW);
     const vital = p.vitalSignLabel.padEnd(vitalW);
     const dollar = paint("success", dollarStrs[i].padStart(dollarW));
-    const label = chalk9.dim(p.dollarLabel);
+    const label = chalk10.dim(p.dollarLabel);
     console.log(`  ${dot} ${seg}  ${vital}  ${dollar}  ${label}`);
   }
   if (problems.length > top.length) {
     console.log();
-    console.log(`  ${chalk9.dim("Run /diagnose --segment <name> to drill in")}`);
+    console.log(`  ${chalk10.dim("Run /diagnose --segment <name> to drill in")}`);
   }
   console.log();
 }
 function printFindingCard(finding) {
   const dot = severityPaint(finding.severity)("\u25CF");
-  const dollarTag = finding.dollar_value != null && finding.dollar_value > 0 ? ` ${chalk9.dim("\xB7")} ${paint("success", formatDollarValue(finding.dollar_value))}` : "";
-  console.log(`  ${dot} ${chalk9.bold(finding.segment)}${dollarTag}`);
+  const dollarTag = finding.dollar_value != null && finding.dollar_value > 0 ? ` ${chalk10.dim("\xB7")} ${paint("success", formatDollarValue(finding.dollar_value))}` : "";
+  console.log(`  ${dot} ${chalk10.bold(finding.segment)}${dollarTag}`);
   printMarkdown(finding.finding, { indent: 2 });
   if (finding.recommended_plays && finding.recommended_plays.length > 0) {
     for (const play of finding.recommended_plays) {
       console.log(
-        `  ${chalk9.dim("Consider:")} ${paint("accent", play.play_name)} ${chalk9.dim("\u2192")} ${chalk9.dim("/playbook " + play.play_id)}`
+        `  ${chalk10.dim("Consider:")} ${paint("accent", play.play_name)} ${chalk10.dim("\u2192")} ${chalk10.dim("/playbook " + play.play_id)}`
       );
     }
   }
-  console.log();
+  if (finding.recommended_focus) {
+    printDeepdiveHint(
+      finding.recommended_focus,
+      VITAL_SIGN_LABELS[finding.recommended_focus]
+    );
+  } else {
+    console.log();
+  }
 }
 function printFindings(findings) {
   if (findings.length === 0) {
-    console.log(chalk9.dim("  No findings generated."));
+    console.log(chalk10.dim("  No findings generated."));
     return;
   }
   for (const finding of findings) printFindingCard(finding);
 }
 function printEntityCounts(counts) {
   const table = new Table2({
-    head: [chalk9.dim("Entity"), chalk9.dim("Count")],
+    head: [chalk10.dim("Entity"), chalk10.dim("Count")],
     colWidths: [20, 12],
     style: { head: [], border: [] }
   });
@@ -12727,7 +12911,7 @@ function printSegmentDetail(seg, aggregate) {
   console.log();
   printHeading(seg.segment.name);
   console.log(
-    `  ${statusDot(seg.result.overall_status)} ${color(chalk9.bold(formatScore(seg.result.overall_score)))}${chalk9.dim("/100")}  ${chalk9.dim("Held back by:")} ${paint("accent", VITAL_SIGN_LABELS[seg.result.gating_vital_sign])}`
+    `  ${statusDot(seg.result.overall_status)} ${color(chalk10.bold(formatScore(seg.result.overall_score)))}${chalk10.dim("/100")}  ${chalk10.dim("Held back by:")} ${paint("accent", VITAL_SIGN_LABELS[seg.result.gating_vital_sign])}`
   );
   console.log();
   for (const vs of seg.result.vital_signs) {
@@ -12738,8 +12922,8 @@ function printSegmentDetail(seg, aggregate) {
     const label = VITAL_SIGN_LABELS[vs.vital_sign].padEnd(18);
     const bar = scoreBar(vs.score, vs.status);
     const score = String(Math.round(vs.score)).padStart(4);
-    const impact = vs.dollar_value != null && vs.dollar_value > 0 ? `${paint("success", formatCurrency(vs.dollar_value))}  ${chalk9.dim(vs.dollar_label ?? "")}` : chalk9.dim("\u2014");
-    console.log(`  ${dot} ${label} ${bar}  ${chalk9.bold(score)} ${padLeft(deltaStr, 4)}  ${chalk9.dim("\u2502")}  ${impact}`);
+    const impact = vs.dollar_value != null && vs.dollar_value > 0 ? `${paint("success", formatCurrency(vs.dollar_value))}  ${chalk10.dim(vs.dollar_label ?? "")}` : chalk10.dim("\u2014");
+    console.log(`  ${dot} ${label} ${bar}  ${chalk10.bold(score)} ${padLeft(deltaStr, 4)}  ${chalk10.dim("\u2502")}  ${impact}`);
   }
   console.log();
 }
@@ -12850,12 +13034,12 @@ async function renderDiagnoseStream(options) {
         console.log();
       }
       if (collectedFindings.length === 0) {
-        console.log(chalk9.dim("  No findings generated."));
+        console.log(chalk10.dim("  No findings generated."));
         console.log();
       }
       if (toolCalls > 0) {
         console.log(
-          chalk9.dim(`  Investigated with ${toolCalls} tool call${toolCalls === 1 ? "" : "s"}`)
+          chalk10.dim(`  Investigated with ${toolCalls} tool call${toolCalls === 1 ? "" : "s"}`)
         );
         console.log();
       }
@@ -12876,7 +13060,7 @@ async function renderDiagnoseStream(options) {
       });
     } catch (err) {
       findingsSpinner.fail(deep ? "Agentic investigation failed" : "AI findings failed");
-      console.error(chalk9.dim(String(err)));
+      console.error(chalk10.dim(String(err)));
     }
   }
   return { fullResult, findings: collectedFindings };
@@ -12890,14 +13074,14 @@ function printMetricsTable(metrics, groupOrder) {
     for (const m of groupMetrics) {
       const dot = m.unavailable_reason ? statusDot("neutral") : statusDot(m.status);
       const label = m.label.padEnd(28);
-      const valueStr = m.unavailable_reason ? chalk9.dim("--") : chalk9.bold(m.formatted);
+      const valueStr = m.unavailable_reason ? chalk10.dim("--") : chalk10.bold(m.formatted);
       const confTag = m.confidence != null && m.confidence < 80 && m.confidence_label ? paint("warning", ` ${m.confidence_label} (${m.confidence})`) : "";
-      const note = m.unavailable_reason ? chalk9.dim(m.unavailable_reason) : m.benchmark_note ? chalk9.dim(m.benchmark_note) : "";
+      const note = m.unavailable_reason ? chalk10.dim(m.unavailable_reason) : m.benchmark_note ? chalk10.dim(m.benchmark_note) : "";
       console.log(`  ${dot} ${label} ${valueStr}${confTag}${note ? "  " + note : ""}`);
       if (m.reliability_gate?.requirements?.length && (m.confidence ?? 100) < 80) {
         const gate = m.reliability_gate.requirements[0];
         if (gate) {
-          console.log(chalk9.dim(`              \u2514 Gate: ${gate}`));
+          console.log(chalk10.dim(`              \u2514 Gate: ${gate}`));
         }
       }
     }
@@ -12913,6 +13097,7 @@ var init_terminal = __esm({
     init_theme();
     init_layout();
     init_llm_attribution();
+    init_slides();
   }
 });
 
@@ -12922,15 +13107,30 @@ __export(metrics_report_exports, {
   printMetricsNextSteps: () => printMetricsNextSteps,
   renderMetricsReport: () => renderMetricsReport
 });
-import chalk10 from "chalk";
+import chalk11 from "chalk";
+function pickDeepdiveMetric(metrics) {
+  const rank = (s) => s === "red" ? 0 : s === "yellow" ? 1 : s === "green" ? 2 : 3;
+  const core = ["nrr", "arr", "grr", "pipeline_coverage", "win_rate", "pipeline_velocity"];
+  const coreRank = (id) => {
+    const i = core.indexOf(id);
+    return i === -1 ? 99 : i;
+  };
+  const usable = metrics.filter((m) => m.value != null);
+  if (usable.length === 0) return void 0;
+  return [...usable].sort((a, b) => {
+    const rd = rank(a.status) - rank(b.status);
+    if (rd !== 0) return rd;
+    return coreRank(a.metric) - coreRank(b.metric);
+  })[0];
+}
 function renderMetricsReport(ctx, metrics, coverage, sourceType, options = {}) {
   const title = options.title ?? "SaaS Metrics Analysis";
   const tier = coverageTier(coverage);
   const deterministic = buildDeterministicInsights(metrics, coverage, sourceType);
   const headline = pickHeadlineInsight(deterministic);
   console.log();
-  console.log(chalk10.bold(`  ${title}`));
-  console.log("  " + chalk10.dim(formatCoverageHeader(sourceType, coverage)));
+  console.log(chalk11.bold(`  ${title}`));
+  console.log("  " + chalk11.dim(formatCoverageHeader(sourceType, coverage)));
   console.log();
   printDataQualityPanel(coverage, sourceType, tier);
   if (options.snapshot && coverage.distinct_quarters >= 2) {
@@ -12938,17 +13138,21 @@ function renderMetricsReport(ctx, metrics, coverage, sourceType, options = {}) {
   }
   if (headline) {
     console.log("  " + paint("warning", "\u25B8 Headline"));
-    console.log("  " + chalk10.white(wrapInsight(headline)));
+    console.log("  " + chalk11.white(wrapInsight(headline)));
     console.log();
   }
   printMetricsTable(metrics, GROUP_ORDER);
+  const dive = pickDeepdiveMetric(metrics);
+  if (dive) {
+    printDeepdiveHint(dive.metric, dive.label);
+  }
   if (deterministic.length > 0) {
     console.log("  " + bold("Pattern checks"));
     console.log();
     for (const insight of deterministic.slice(0, 5)) {
       const dot = insight.severity === "warning" ? statusDot("yellow") : insight.severity === "critical" ? statusDot("red") : statusDot("neutral");
       if (insight.headline) continue;
-      console.log(`  ${dot} ${chalk10.dim(wrapInsight(insight.message))}`);
+      console.log(`  ${dot} ${chalk11.dim(wrapInsight(insight.message))}`);
     }
     console.log();
   }
@@ -12977,7 +13181,7 @@ function printDataQualityPanel(coverage, sourceType, tier) {
     rows.push(["Ledger", "not loaded \u2014 retention inferred from CRM"]);
   }
   for (const [label, value] of rows) {
-    console.log(`  ${chalk10.dim(String(label).padEnd(14))} ${value}`);
+    console.log(`  ${chalk11.dim(String(label).padEnd(14))} ${value}`);
   }
   console.log();
 }
@@ -12988,10 +13192,10 @@ function printCloseTrend(snapshot, cadence) {
   console.log("  " + bold(`Close trend (${cadence})`));
   console.log();
   for (const b of recent) {
-    const newStr = b.new_arr > 0 ? chalk10.dim(` new $${formatShort(b.new_arr)}`) : "";
-    const expStr = b.expansion_arr > 0 ? chalk10.dim(` exp $${formatShort(b.expansion_arr)}`) : "";
+    const newStr = b.new_arr > 0 ? chalk11.dim(` new $${formatShort(b.new_arr)}`) : "";
+    const expStr = b.expansion_arr > 0 ? chalk11.dim(` exp $${formatShort(b.expansion_arr)}`) : "";
     console.log(
-      `  ${chalk10.dim(b.period.padEnd(8))} ${chalk10.bold("$" + formatShort(b.closed_won_total))}${newStr}${expStr}  ${chalk10.dim(`(${b.closed_won_count} deals)`)}`
+      `  ${chalk11.dim(b.period.padEnd(8))} ${chalk11.bold("$" + formatShort(b.closed_won_total))}${newStr}${expStr}  ${chalk11.dim(`(${b.closed_won_count} deals)`)}`
     );
   }
   console.log();
@@ -13017,6 +13221,7 @@ var init_metrics_report = __esm({
     init_terminal();
     init_theme();
     init_companion();
+    init_slides();
     GROUP_ORDER = [
       "Revenue",
       "Retention",
@@ -13211,7 +13416,7 @@ var diagnose_exports = {};
 __export(diagnose_exports, {
   handler: () => handler
 });
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 async function handler(args, ctx) {
   await hydrateAnalysisFromPersistedState(ctx);
   const { flags } = parseArgs(args, ["findings", "deep", "compact"]);
@@ -13240,9 +13445,9 @@ async function handler(args, ctx) {
   }
   if (options.findings && !canUseReplAi(ctx)) {
     console.log();
-    console.log("  " + chalk11.red("AI findings run only in the interactive REPL."));
-    console.log("  " + chalk11.dim("Vital signs compute without a key \u2014 omit --findings for numbers only."));
-    console.log("  " + chalk11.dim("Start with ") + paint("accent", "ntrp") + chalk11.dim(", run ") + paint("accent", "/connect") + chalk11.dim(" (any provider key), then /diagnose --findings."));
+    console.log("  " + chalk12.red("AI findings run only in the interactive REPL."));
+    console.log("  " + chalk12.dim("Vital signs compute without a key \u2014 omit --findings for numbers only."));
+    console.log("  " + chalk12.dim("Start with ") + paint("accent", "ntrp") + chalk12.dim(", run ") + paint("accent", "/connect") + chalk12.dim(" (any provider key), then /diagnose --findings."));
     console.log();
     return;
   }
@@ -13274,7 +13479,7 @@ async function handler(args, ctx) {
   }
   ctx.skipTimeBankDiagnoseCredit = false;
   if (ctx.oneShot && options.findings) {
-    console.log(chalk11.dim("  For follow-up questions, run `ntrp` and ask in plain English."));
+    console.log(chalk12.dim("  For follow-up questions, run `ntrp` and ask in plain English."));
     console.log();
   }
   return summary;
@@ -13332,7 +13537,7 @@ async function runDiagnose(options, ctx) {
     });
     return buildDiagnoseSummary(fullResult.aggregate, findings);
   } catch (err) {
-    console.error(chalk11.red(String(err)));
+    console.error(chalk12.red(String(err)));
     process.exit(1);
   }
 }
@@ -13344,7 +13549,7 @@ async function runSegmentDiagnose(options) {
     spinner.succeed("Diagnosis complete");
   } catch (err) {
     spinner.fail("Diagnosis failed");
-    console.error(chalk11.red(String(err)));
+    console.error(chalk12.red(String(err)));
     process.exit(1);
   }
   const needle = options.segment.toLowerCase();
@@ -13353,19 +13558,19 @@ async function runSegmentDiagnose(options) {
     const subs = result.segments.filter((s) => s.segment.name.toLowerCase().includes(needle));
     if (subs.length === 1) match = subs[0];
     else if (subs.length > 1) {
-      console.error(chalk11.yellow(`
+      console.error(chalk12.yellow(`
   "${options.segment}" matches multiple segments:`));
-      for (const s of subs) console.log(chalk11.dim(`    - ${s.segment.name}`));
+      for (const s of subs) console.log(chalk12.dim(`    - ${s.segment.name}`));
       console.log();
       return;
     }
   }
   if (!match) {
-    console.error(chalk11.red(`
+    console.error(chalk12.red(`
   No segment matching "${options.segment}".`));
     if (result.segments.length > 0) {
-      console.log(chalk11.dim("  Available segments:"));
-      for (const s of result.segments) console.log(chalk11.dim(`    - ${s.segment.name}`));
+      console.log(chalk12.dim("  Available segments:"));
+      for (const s of result.segments) console.log(chalk12.dim(`    - ${s.segment.name}`));
     }
     console.log();
     return;
@@ -13419,145 +13624,1089 @@ var init_diagnose = __esm({
   }
 });
 
-// src/services/session-analysis.ts
-async function loadSessionAnalysisBundle() {
-  const [diagnosis, metrics] = await Promise.all([
-    loadLatestDiagnosis(),
-    loadLatestMetricsAnalysis()
-  ]);
-  return { diagnosis, metrics };
+// src/services/session-analysis.ts
+async function loadSessionAnalysisBundle() {
+  const [diagnosis, metrics] = await Promise.all([
+    loadLatestDiagnosis(),
+    loadLatestMetricsAnalysis()
+  ]);
+  return { diagnosis, metrics };
+}
+function hasAnyAnalysis(bundle) {
+  return bundle.diagnosis != null || bundle.metrics != null;
+}
+function formatMetricLine(row) {
+  const label = row.label ?? row.metric;
+  const formatted = row.formatted ?? "--";
+  const conf = row.confidence;
+  const confStr = conf != null && conf < 80 ? ` (${conf}% conf)` : "";
+  return `- ${label}: ${formatted}${confStr}`;
+}
+function buildHandoffContextBlock(bundle, ctx) {
+  const { diagnosis, metrics } = bundle;
+  const profile = loadProfile();
+  const lines = [];
+  if (profile?.company_name) {
+    lines.push(`Company: ${profile.company_name} (${profile.industry})`);
+    lines.push(`Sales motion: ${profile.sales_motion}${profile.average_deal_size ? ` \xB7 avg deal ${profile.average_deal_size}` : ""}`);
+    if (profile.user_scope) lines.push(`My scope: ${profile.user_scope}`);
+  }
+  if (ctx.dataset?.label) {
+    const counts = ctx.dataset.counts ?? {};
+    const countStr = Object.entries(counts).filter(([, n]) => n > 0).map(([k, n]) => `${n} ${k}`).join(", ");
+    lines.push(`Dataset: ${ctx.dataset.label}${countStr ? ` (${countStr})` : ""}`);
+  }
+  const completed = ctx.analysis.completed;
+  if (completed.length > 0) {
+    lines.push(`Analysis lenses completed: ${completed.join(", ")}`);
+  }
+  lines.push("");
+  if (diagnosis) {
+    const { health, findings } = diagnosis;
+    lines.push("## GTM health (vital signs)");
+    lines.push(`Overall score: ${Math.round(health.overall_score)} (${health.overall_status})`);
+    if (health.total_value_at_risk != null && health.total_value_at_risk > 0) {
+      lines.push(`Total value at risk: ${formatCurrency(health.total_value_at_risk)}`);
+    }
+    lines.push("");
+    lines.push("### Vital signs");
+    for (const vs of health.vital_signs) {
+      const label = VITAL_SIGN_LABELS[vs.vital_sign] ?? vs.vital_sign;
+      const dollars = vs.dollar_value != null ? ` \u2014 ${formatCurrency(vs.dollar_value)}${vs.dollar_label ? ` ${vs.dollar_label}` : ""}` : "";
+      lines.push(`- ${label}: ${Math.round(vs.score)} (${vs.status})${dollars}`);
+    }
+    if (findings.length > 0) {
+      lines.push("");
+      lines.push("### GTM findings");
+      appendFindings(lines, findings);
+    }
+    lines.push("");
+  }
+  if (metrics && metrics.metrics.length > 0) {
+    lines.push("## SaaS metrics");
+    const byKey = new Map(metrics.metrics.map((r) => [r.metric, r]));
+    for (const key of KEY_METRICS) {
+      const row = byKey.get(key);
+      if (row) lines.push(formatMetricLine(row));
+    }
+    if (metrics.findings.length > 0) {
+      lines.push("");
+      lines.push("### Metrics findings");
+      appendFindings(lines, metrics.findings);
+    }
+    lines.push("");
+  }
+  if (!diagnosis && metrics) {
+    lines.unshift("Primary analysis: SaaS metrics (no GTM health snapshot on this session yet).", "");
+  } else if (diagnosis && !metrics) {
+    lines.push("(SaaS metrics not run on this session \u2014 run /metrics for the revenue view)");
+  }
+  return lines.join("\n").trim();
+}
+function buildExploreContextBlock(bundle, ctx) {
+  const full = buildHandoffContextBlock(bundle, ctx);
+  if (!full) return "";
+  const lines = full.split("\n");
+  const out = [
+    "COMPLETED ANALYSIS (the user already saw the full report \u2014 cite this, do not re-dump it):",
+    ""
+  ];
+  let inFindings = false;
+  let findingCount = 0;
+  for (const line of lines) {
+    if (line.startsWith("### GTM findings") || line.startsWith("### Metrics findings")) {
+      inFindings = true;
+      out.push(line);
+      continue;
+    }
+    if (inFindings && line.startsWith("- [")) {
+      if (findingCount >= 5) continue;
+      out.push(line);
+      findingCount++;
+      continue;
+    }
+    if (inFindings && line.startsWith("##")) {
+      inFindings = false;
+    }
+    if (line.startsWith("## ") || line.startsWith("### Vital") || line.startsWith("- ") && !inFindings) {
+      if (line.startsWith("(SaaS metrics not run")) continue;
+      out.push(line);
+    }
+    if (line.startsWith("Overall score:") || line.startsWith("Total value at risk:")) {
+      out.push(line);
+    }
+    if (line.startsWith("- ARR:") || line.startsWith("- NRR:") || line.startsWith("- GRR:")) {
+      out.push(line);
+    }
+  }
+  return out.join("\n").trim();
+}
+function appendFindings(lines, findings) {
+  for (const f of findings.slice(0, 12)) {
+    const dollars = f.dollar_value != null ? ` (${formatCurrency(f.dollar_value)})` : "";
+    const plays = f.recommended_plays?.length ? ` \u2192 Plays: ${f.recommended_plays.map((p) => p.play_name).join(", ")}` : "";
+    lines.push(`- [${f.severity}]${dollars} ${f.finding}${plays}`);
+  }
+}
+function handoffInstructionPrefix(primary) {
+  if (primary === "revenue_metrics") {
+    return "the SaaS metrics and pipeline context below";
+  }
+  return "the pipeline diagnosis below";
+}
+var KEY_METRICS;
+var init_session_analysis = __esm({
+  "src/services/session-analysis.ts"() {
+    "use strict";
+    init_queries();
+    init_profile();
+    init_formatters();
+    init_theme();
+    KEY_METRICS = ["arr", "nrr", "grr", "win_rate", "pipeline_coverage"];
+  }
+});
+
+// src/data/metric-definitions.ts
+function pctBand(metric, motion) {
+  const m = motion ?? "mid_market";
+  const t = METRICS_BENCHMARKS[m][metric];
+  return `${motionBenchmarkLabel(m)} green \u2265${t.green}${metric === "pipeline_coverage" ? "x" : "%"}, yellow \u2265${t.yellow}${metric === "pipeline_coverage" ? "x" : "%"}`;
+}
+function monthsBand(motion) {
+  const m = motion ?? "mid_market";
+  const t = METRICS_BENCHMARKS[m].payback_months;
+  return `${motionBenchmarkLabel(m)} green \u2264${t.green}mo, yellow \u2264${t.yellow}mo`;
+}
+function magicBand(motion) {
+  const m = motion ?? "mid_market";
+  const t = METRICS_BENCHMARKS[m].magic_number;
+  return `${motionBenchmarkLabel(m)} green \u2265${t.green}, yellow \u2265${t.yellow}`;
+}
+function getMetricExplainer(id) {
+  return BY_ID.get(id);
+}
+function resolveMetricId(query) {
+  const q = query.trim().toLowerCase().replace(/\s+/g, " ");
+  if (!q) return void 0;
+  if (BY_ID.has(q)) return q;
+  const direct = ALIAS_INDEX.get(q);
+  if (direct) return direct;
+  const norm = q.replace(/[-\s]+/g, "_");
+  if (BY_ID.has(norm)) return norm;
+  return ALIAS_INDEX.get(norm);
+}
+var VITALS, SAAS, METRIC_DEFINITIONS, BY_ID, ALIAS_INDEX, SAAS_METRIC_IDS;
+var init_metric_definitions = __esm({
+  "src/data/metric-definitions.ts"() {
+    "use strict";
+    init_metrics_benchmarks();
+    VITALS = [
+      {
+        id: "freshness",
+        kind: "vital",
+        label: "Freshness",
+        group: "Vital Signs",
+        tagline: "Is your CRM telling the truth about what's alive?",
+        how_computed: "Weighted average of people, organizations, and opportunities with recent activity (and open opps not past-due). Defaults: people/orgs 90-day window, opps 30-day window; weights 35/30/35.",
+        formula_lines: [
+          "freshness = people%\xD70.35 + orgs%\xD70.30 + opps%\xD70.35",
+          "people/orgs fresh if activity within 90d",
+          "opps fresh if activity within 30d AND not past-due"
+        ],
+        meaning: 'Board question: "how much of this pipeline is real vs fiction?" Dollar value = sum of amount on stale opportunities \u2014 pipeline at risk.',
+        expert_read: "Cut by owner and by stage first \u2014 freshness reds concentrate on people or process, rarely evenly. In a long-cycle enterprise motion 30 quiet days can be normal cadence; in a velocity motion it's a dead deal. A sudden cliff usually means a broken integration or a departed rep, not gradual decay. False positive to check: bulk-imported records nobody has touched yet.",
+        deepdive: [
+          "Status: green \u226580, yellow \u226560, red below 60 (motion presets can shift windows).",
+          'Dollar translation: sum of amount on stale open opportunities \u2192 "pipeline at risk".',
+          "Layer 1 of the gating stack \u2014 a red here bounds what you can trust downstream.",
+          "Trigger play: Clean Dead Pipeline (clean-dead-pipeline) when score < 60.",
+          "Levers: stale-deal alert at N quiet days, weekly hygiene scrub, enrichment refresh on quiet records, signal-triggered reactivation for paid-for dormant accounts."
+        ],
+        visual: {
+          kind: "bars",
+          caption: "Exemplar component mix (higher = fresher)",
+          bars: [
+            { label: "People", value: 72, tone: "yellow" },
+            { label: "Organizations", value: 81, tone: "green" },
+            { label: "Opportunities", value: 44, tone: "red" }
+          ]
+        },
+        play_id: "clean-dead-pipeline",
+        dollar_label: "pipeline at risk",
+        audience: {
+          board: "Freshness answers whether the pipeline number is real. Low freshness means forecast risk \u2014 stale deals inflate coverage and hide the true gap.",
+          ops: "Score = weighted recency across people/orgs/opps. Cut by owner and stage; install a stale-deal alert and weekly scrub. Play: Clean Dead Pipeline."
+        },
+        aliases: ["data freshness", "stale", "zombie deals", "crm freshness"]
+      },
+      {
+        id: "flow_rate",
+        kind: "vital",
+        label: "Flow Rate",
+        group: "Vital Signs",
+        tagline: "How fast do deals actually move \u2014 and where do they die?",
+        how_computed: "Base score from average open-deal age vs max_days, then a penalty (up to \u221220) for the share of stuck deals (no update beyond stuck_days, or past-due close). Status is driven by average open age, not the score alone.",
+        formula_lines: [
+          "base = 100 \xD7 (1 \u2212 avgOpenAge / max_days)",
+          "score = base \u2212 stuckSharePenalty (\u226420)",
+          "stuck = no update > stuck_days OR past-due close"
+        ],
+        meaning: 'Board question: "is next quarter slipping because deals are stuck?" Dollar value = amount stuck in pipeline.',
+        expert_read: "Cut by stage-age, not just deal-age \u2014 find the stage where deals go to die (usually one). Compare stuck-deal age to this company's own median cycle, not a generic norm. Stuck + past-due close dates together signal happy-ears forecasting, a credibility problem before it's a revenue problem.",
+        deepdive: [
+          "Status from avg open age: \u226445d green, \u226490d yellow, else red (defaults; max_days 120, stuck_days 60).",
+          'Dollar translation: sum of amount on stuck deals \u2192 "stuck in pipeline".',
+          "Layer 2 of the gating stack (with Drop Rate).",
+          "Trigger play: Unstick the Pipeline (unstick-pipeline) when score is weak.",
+          "Levers: stage-age report, past-due close cleanup, progression plans on stuck deals, forecast hygiene on happy-ears dates."
+        ],
+        visual: {
+          kind: "funnel",
+          caption: "Exemplar stage ages \u2014 find the stage where deals go to die",
+          funnel: [
+            { label: "Discovery", widthPct: 100 },
+            { label: "Qualify", widthPct: 78 },
+            { label: "Propose", widthPct: 55 },
+            { label: "Negotiate", widthPct: 22 },
+            { label: "Closed", widthPct: 12 }
+          ]
+        },
+        play_id: "unstick-pipeline",
+        dollar_label: "stuck in pipeline",
+        audience: {
+          board: "Flow Rate is velocity risk. Stuck pipeline with past-due closes is a credibility problem for the forecast before it is a revenue miss.",
+          ops: "Find the stage with collapsing advancement and age. Clear past-due closes, write progression plans on stuck deals. Play: Unstick the Pipeline."
+        },
+        aliases: ["flow rate", "deal velocity", "stuck deals", "stuck pipeline"]
+      },
+      {
+        id: "drop_rate",
+        kind: "vital",
+        label: "Drop Rate",
+        group: "Vital Signs",
+        tagline: "Where do leads vanish between systems?",
+        how_computed: "Blend of cross-system retention (marketing people also present in sales) and opportunity retention (open opps not abandoned). Defaults weight cross-system 60% / opp retention 40%. Abandoned = open opps with no activity in 30 days.",
+        formula_lines: [
+          "score = crossSystemRetention\xD70.6 + oppRetention\xD70.4",
+          "cross-system = marketing people also in sales CRM",
+          "abandoned = open opps with no activity in 30d"
+        ],
+        meaning: 'Board question: "how much pipeline are we paying for and never working?" Dollar value = droppedCount \xD7 conversionRate \xD7 avgDealSize \u2014 est. lost at handoff.',
+        expert_read: "This is almost always a systems failure \u2014 routing rules, unassigned territories, dead rep queues, or a sync gap between marketing and CRM \u2014 not lazy reps. First cut by lead source; the leak usually concentrates in one or two sources. The cheapest pipeline this business can buy is the leads it already paid for.",
+        deepdive: [
+          "Status: green \u226580, yellow \u226560, red below 60.",
+          'Dollar translation: dropped \xD7 conversion \xD7 avg deal (fallback: drop% \xD7 open pipeline) \u2192 "est. lost at handoff".',
+          "Layer 2 of the gating stack (with Flow Rate).",
+          "Trigger play: Fix the Handoff Gap (fix-handoff-gap) when drop is high.",
+          "Levers: source-level handoff audit, routing + sync repair, time-to-first-touch SLA, weekly marketing-only-leads report."
+        ],
+        visual: {
+          kind: "funnel",
+          caption: "Exemplar handoff funnel \u2014 the leak is usually one or two sources",
+          funnel: [
+            { label: "Marketing leads", widthPct: 100 },
+            { label: "In sales CRM", widthPct: 62 },
+            { label: "Assigned + touched", widthPct: 41 },
+            { label: "Active opportunities", widthPct: 28 }
+          ]
+        },
+        play_id: "fix-handoff-gap",
+        dollar_label: "est. lost at handoff",
+        audience: {
+          board: "Drop Rate prices the handoff leak \u2014 budget already spent on leads that never reach a working rep. Usually a systems failure, not a people failure.",
+          ops: "Audit by source, fix routing/sync/dead queues, instrument time-to-first-touch. Play: Fix the Handoff Gap."
+        },
+        aliases: ["drop rate", "handoff", "handoff gap", "lead leak", "marketing sales handoff"]
+      },
+      {
+        id: "signal_to_noise",
+        kind: "vital",
+        label: "Signal:Noise",
+        group: "Vital Signs",
+        tagline: "How much activity is aimed at deals that can still close?",
+        how_computed: "Over a 90-day lookback: (signal activities / all activities) \xD7 100. Signal = activity linked to an open opportunity, a pipeline person, or a pipeline organization.",
+        formula_lines: [
+          "score = (signalCount / activityCount) \xD7 100",
+          "signal = linked to open opp / pipeline person / pipeline org",
+          "lookback = trailing 90 days"
+        ],
+        meaning: 'Board question: "are we burning capacity on dead water?" Dollar value = noiseCount \xD7 hours_per_activity \xD7 rep_hourly_cost \u2014 misdirected effort.',
+        expert_read: "Cut by rep and by account status \u2014 noise usually means reps fishing in the pond they can see (dead accounts they know) because targeting and account lists are stale. Persistent noise is a coverage-model problem, not a coaching problem. Check whether activity is logged against closed or unlinked records \u2014 often a hygiene artifact.",
+        deepdive: [
+          "Status: green \u226565, yellow \u226540, red below 40.",
+          "Dollar defaults: 0.25 hours/activity \xD7 $75/hr (config: hours_per_activity, rep_hourly_cost).",
+          "Layer 3 of the gating stack \u2014 trust Freshness / Flow / Drop before reading activity efficiency.",
+          "Trigger play: Retarget Misdirected Effort (retarget-effort) when score is low.",
+          "Levers: refresh account lists, signal-based targeting, stop logging against closed/unlinked records, coverage-model redesign."
+        ],
+        visual: {
+          kind: "split",
+          caption: "Exemplar activity mix \u2014 signal vs noise",
+          bars: [
+            { label: "Signal", value: 38, tone: "green" },
+            { label: "Noise", value: 62, tone: "red" }
+          ]
+        },
+        play_id: "retarget-effort",
+        dollar_label: "misdirected effort",
+        audience: {
+          board: "Signal:Noise prices wasted capacity. Persistent noise is usually a coverage-model problem, not a coaching problem \u2014 reps fish in dead ponds they already know.",
+          ops: "Score = % of activities linked to live pipeline. Cut by rep and account status; refresh targeting. Play: Retarget Misdirected Effort."
+        },
+        aliases: ["signal to noise", "signal:noise", "s/n", "activity efficiency", "noise"]
+      },
+      {
+        id: "thread_depth",
+        kind: "vital",
+        label: "Thread Depth",
+        group: "Vital Signs",
+        tagline: "How fragile is the pipeline if one champion goes dark?",
+        how_computed: "Percent of open deals with at least multi_thread_threshold (default 2) distinct people active in the last 90 days (opp-direct contacts + same-org activity).",
+        formula_lines: [
+          "score = % open deals with \u22652 active people (90d)",
+          "people counted via opp contacts + same-org activity",
+          "threshold configurable (default 2)"
+        ],
+        meaning: 'Board question: "how much revenue dies if one contact changes jobs?" Dollar value = sum of amount on single-threaded deals.',
+        expert_read: "Weight by deal size \u2014 one single-threaded mega-deal outweighs ten small ones. Single-threading late in the cycle is far more dangerous than early. In enterprise motions, thread depth is a leading indicator of slipped quarters: champions change jobs, and there's no second door in.",
+        deepdive: [
+          "Status: green \u226565, yellow \u226540, red below 40.",
+          'Dollar translation: sum of amount on single-threaded deals \u2192 "single-threaded".',
+          "Layer 4 of the gating stack \u2014 read last, after the upstream vitals.",
+          "Trigger play: Multi-Thread Your Deals (multi-thread-deals) when depth is low.",
+          "Levers: buying-committee map, warm internal referral first, CRM contact roles, mid-stage single-thread alerts, champion job-change signals."
+        ],
+        visual: {
+          kind: "bars",
+          caption: "Exemplar \u2014 multi-threaded vs single-threaded open deals",
+          bars: [
+            { label: "Multi-threaded", value: 34, tone: "green" },
+            { label: "Single-threaded", value: 66, tone: "red" }
+          ]
+        },
+        play_id: "multi-thread-deals",
+        dollar_label: "single-threaded",
+        audience: {
+          board: "Thread Depth is resilience risk. One single-threaded mega-deal outweighs ten small ones \u2014 late-cycle single-threading is a leading indicator of slipped quarters.",
+          ops: "Score = % of open deals with \u22652 active contacts in 90d. Map the buying committee; alert on mid-stage singles. Play: Multi-Thread Your Deals."
+        },
+        aliases: ["thread depth", "multithreading", "multi-thread", "single-threaded", "buying committee"]
+      }
+    ];
+    SAAS = [
+      // —— Revenue ——
+      {
+        id: "arr",
+        kind: "saas",
+        label: "ARR",
+        group: "Revenue",
+        tagline: "How big is the revenue engine \u2014 and from where?",
+        how_computed: "Sum of amount on closed-won opportunities in the dataset (pipeline-inferred ARR when a pure subscription ledger is unavailable).",
+        formula_lines: [
+          "ARR \u2248 \u03A3 amount on closed-won opportunities",
+          "New + Expansion = growth \xB7 Churned + Contraction = leakage"
+        ],
+        meaning: 'Board question: "how fast are we growing, and from where?" Always decompose growth into new vs expansion \u2014 the mix is the story.',
+        expert_read: "Always decompose growth into new vs expansion \u2014 the mix is the story. Instrument trust: prefer this company's own trailing history over any external prior; a number below its reliability gate is a hypothesis, not a fact.",
+        deepdive: [
+          "Companion metrics: New ARR, Expansion ARR, Churned ARR, Contraction ARR.",
+          "Estimation method may be ledger, pipeline_inferred, or snapshot \u2014 read confidence + reliability_gate.",
+          "Cross-check with Freshness before trusting ARR growth stories built on zombie deals."
+        ],
+        visual: {
+          kind: "waterfall",
+          caption: "Exemplar ARR walk \u2014 growth vs leakage",
+          waterfall: [
+            { label: "Starting", delta: 100, cumulative: 100 },
+            { label: "+ New", delta: 18, cumulative: 118 },
+            { label: "+ Expansion", delta: 12, cumulative: 130 },
+            { label: "\u2212 Contraction", delta: -4, cumulative: 126 },
+            { label: "\u2212 Churned", delta: -8, cumulative: 118 }
+          ]
+        },
+        audience: {
+          board: "ARR is the size of the engine. The story is the mix \u2014 new vs expansion growth, and how much leakage (churn + contraction) ate it.",
+          ops: "Computed as \u03A3 closed-won amounts (pipeline-inferred when no ledger). Decompose into new / expansion / churned / contraction before briefing anyone."
+        },
+        aliases: ["annual recurring revenue", "revenue"]
+      },
+      {
+        id: "new_arr",
+        kind: "saas",
+        label: "New ARR",
+        group: "Revenue",
+        tagline: "How much growth came from brand-new customers?",
+        how_computed: "Closed-won tagged New Business, or first closed-won deal per organization when tags are missing.",
+        formula_lines: [
+          "New ARR = \u03A3 closed-won tagged New Business",
+          "fallback: first closed-won deal per organization"
+        ],
+        meaning: 'Board question: "is growth coming from the top of funnel, or are we farming the base?"',
+        expert_read: "Rising New ARR with falling Expansion usually means land-and-expand is underpowered \u2014 packaging or CS motion, not just sales capacity.",
+        deepdive: [
+          "Pair with Expansion ARR \u2014 the mix tells you which motion is carrying growth.",
+          "Tag quality matters: untagged deals fall into the first-deal-per-org heuristic."
+        ],
+        visual: {
+          kind: "bars",
+          caption: "Exemplar growth mix",
+          bars: [
+            { label: "New ARR", value: 60, tone: "accent" },
+            { label: "Expansion ARR", value: 40, tone: "green" }
+          ]
+        },
+        audience: {
+          board: "New ARR is net-new logos. Read it next to Expansion \u2014 a healthy mix beats a one-sided engine.",
+          ops: "Prefer CRM New Business tags; otherwise first closed-won per org. Watch tag hygiene."
+        },
+        aliases: ["new business arr", "new logo arr"]
+      },
+      {
+        id: "expansion_arr",
+        kind: "saas",
+        label: "Expansion ARR",
+        group: "Revenue",
+        tagline: "How much are existing customers buying more?",
+        how_computed: "Closed-won tagged Expansion, or later closed-won deals per organization after the first win.",
+        formula_lines: [
+          "Expansion ARR = \u03A3 closed-won tagged Expansion",
+          "fallback: later closed-won deals per organization"
+        ],
+        meaning: 'Board question: "is the installed base compounding?"',
+        expert_read: "Expansion is the cheapest growth. Weak Expansion with strong New ARR is a land-only motion \u2014 packaging, CS capacity, or product attach is usually the lever.",
+        deepdive: [
+          "Feeds NRR as the upside term.",
+          "Compare to Contraction \u2014 net expansion = expansion \u2212 contraction."
+        ],
+        visual: {
+          kind: "bars",
+          caption: "Exemplar \u2014 expansion vs contraction",
+          bars: [
+            { label: "Expansion", value: 70, tone: "green" },
+            { label: "Contraction", value: 25, tone: "yellow" }
+          ]
+        },
+        audience: {
+          board: "Expansion ARR is installed-base compounding \u2014 the cheapest growth when it works.",
+          ops: "Tagged Expansion or subsequent wins per org. Pair with Contraction before celebrating net expansion."
+        },
+        aliases: ["upsell", "upsell arr", "cross-sell"]
+      },
+      {
+        id: "churned_arr",
+        kind: "saas",
+        label: "Churned ARR",
+        group: "Revenue",
+        tagline: "How much revenue walked out the door?",
+        how_computed: "Organizations with historical wins, no win in the trailing 12 months, and no active open opportunity \u2014 sum of their historical closed-won amounts.",
+        formula_lines: [
+          "Churned ARR = \u03A3 historical wins for orgs with",
+          "  no win in trailing 12mo AND no active open opp"
+        ],
+        meaning: `Board question: "how leaky is the bucket before expansion papers over it?" (with Contraction, this is GRR's downside).`,
+        expert_read: "Pipeline-inferred churn is a hypothesis \u2014 confirm with billing status when available. A spike often clusters in one segment or cohort.",
+        deepdive: [
+          "Feeds GRR and NRR as the churn term.",
+          "Cut by segment / motion before treating it as a company-wide PMF problem."
+        ],
+        visual: {
+          kind: "bars",
+          caption: "Exemplar leakage mix",
+          bars: [
+            { label: "Churned", value: 55, tone: "red" },
+            { label: "Contraction", value: 30, tone: "yellow" }
+          ]
+        },
+        audience: {
+          board: "Churned ARR is full logo loss. With Contraction it sets the floor of the business (GRR).",
+          ops: "Heuristic: historical winners with no trailing-12 win and no open opp. Validate against billing when you can."
+        },
+        aliases: ["churn", "logo churn", "churned revenue"]
+      },
+      {
+        id: "contraction_arr",
+        kind: "saas",
+        label: "Contraction ARR",
+        group: "Revenue",
+        tagline: "How much did existing customers buy less?",
+        how_computed: "Organizations with \u22652 wins where the latest amount is less than the prior \u2014 sum of the negative deltas.",
+        formula_lines: [
+          "Contraction = \u03A3 (prior \u2212 latest) where latest < prior",
+          "requires \u22652 closed-won deals per organization"
+        ],
+        meaning: 'Board question: "are we quietly shrinking inside the base while logos stay?"',
+        expert_read: "Contraction is often packaging, seat-reduction, or downgrade \u2014 different owner than logo churn. Same NRR can be a churn problem or a no-expansion problem.",
+        deepdive: [
+          "Feeds GRR and NRR.",
+          "Needs multi-deal history per org \u2014 thin history understates contraction."
+        ],
+        visual: {
+          kind: "waterfall",
+          caption: "Exemplar \u2014 contraction digs into the base",
+          waterfall: [
+            { label: "Prior", delta: 100, cumulative: 100 },
+            { label: "Latest", delta: -18, cumulative: 82 }
+          ]
+        },
+        audience: {
+          board: "Contraction is silent shrink inside retained logos \u2014 often packaging or seats, not a cancelled contract.",
+          ops: "Requires \u22652 wins per org with a down-round. Pair with Expansion for net expansion."
+        },
+        aliases: ["downgrade", "seat reduction", "contraction"]
+      },
+      // —— Retention ——
+      {
+        id: "nrr",
+        kind: "saas",
+        label: "Net Revenue Retention",
+        group: "Retention",
+        tagline: "Would this business grow if sales stopped selling?",
+        how_computed: "startingArr = ARR + Churned + Contraction \u2212 Expansion; NRR = ((starting \u2212 Churned \u2212 Contraction + Expansion) / starting) \xD7 100.",
+        formula_lines: [
+          "starting = ARR + churned + contraction \u2212 expansion",
+          "NRR = (starting \u2212 churned \u2212 contraction + expansion) / starting \xD7 100",
+          "NRR = 100% + expansion% \u2212 contraction% \u2212 churn%"
+        ],
+        meaning: 'Board question: "would this business grow if sales stopped selling?" >100% means growing from existing customers.',
+        expert_read: "Decompose before judging: the same 95% can be a churn problem (product/PMF) or a no-expansion problem (packaging/motion) with different owners. Priors by segment: ~97% SMB, ~108% mid-market, ~118% enterprise medians; 110%+ is a strong signal at any stage.",
+        deepdive: [
+          "Always show the waterfall: +expansion \u2212contraction \u2212churn.",
+          "GRR is the floor; NRR adds expansion on top.",
+          "On pipeline-only data, treat as a hypothesis \u2014 check confidence / reliability_gate."
+        ],
+        visual: {
+          kind: "waterfall",
+          caption: "Exemplar NRR walk from 100%",
+          waterfall: [
+            { label: "100%", delta: 100, cumulative: 100 },
+            { label: "+ Expansion", delta: 14, cumulative: 114 },
+            { label: "\u2212 Contraction", delta: -4, cumulative: 110 },
+            { label: "\u2212 Churn", delta: -6, cumulative: 104 }
+          ]
+        },
+        audience: {
+          board: "NRR >100% means the base compounds without new logos. Decompose before judging \u2014 same number, different owners.",
+          ops: "NRR = 100 + expansion \u2212 contraction \u2212 churn. Motion benchmarks calibrate green/yellow bands. Check reliability_gate on pipeline-inferred data."
+        },
+        aliases: ["net revenue retention", "net retention", "ndr"],
+        benchmarkHint: (motion) => pctBand("nrr", motion)
+      },
+      {
+        id: "grr",
+        kind: "saas",
+        label: "Gross Revenue Retention",
+        group: "Retention",
+        tagline: "How leaky is the bucket before expansion papers over it?",
+        how_computed: "GRR = ((startingArr \u2212 Churned \u2212 Contraction) / startingArr) \xD7 100 \u2014 expansion is excluded on purpose.",
+        formula_lines: [
+          "starting = ARR + churned + contraction \u2212 expansion",
+          "GRR = (starting \u2212 churned \u2212 contraction) / starting \xD7 100"
+        ],
+        meaning: 'Board question: "how leaky is the bucket before expansion papers over it?" Prior: >90% healthy, >95% strong for enterprise.',
+        expert_read: "GRR is the honesty metric. Expansion can make NRR look fine while GRR is quietly eroding \u2014 always read both.",
+        deepdive: [
+          "GRR never includes Expansion \u2014 that is the point.",
+          "Owners: product/CS for churn, packaging for contraction."
+        ],
+        visual: {
+          kind: "gauge",
+          caption: "Exemplar GRR \u2014 floor of the business",
+          gauge: 92
+        },
+        audience: {
+          board: "GRR is the floor \u2014 churn + contraction only. Expansion cannot paper over a leaky bucket here.",
+          ops: "Exclude Expansion by design. Pair with NRR; diagnose churn vs contraction separately."
+        },
+        aliases: ["gross revenue retention", "gross retention"],
+        benchmarkHint: (motion) => pctBand("grr", motion)
+      },
+      // —— Pipeline ——
+      {
+        id: "pipeline_coverage",
+        kind: "saas",
+        label: "Pipeline Coverage",
+        group: "Pipeline",
+        tagline: "Is next quarter already at risk?",
+        how_computed: "Open pipeline amount \xF7 trailing-90-day closed-won amount.",
+        formula_lines: [
+          "Coverage = openPipeline / trailing_90d_won",
+          "required \u2248 1 / win_rate (discount for time left)"
+        ],
+        meaning: 'Board question: "is next quarter already at risk?" Priors scale with cycle length: ~3x velocity/SMB, 4\u20135x enterprise.',
+        expert_read: "Coverage means nothing without win rate: required coverage \u2248 1 / win rate, discounted for time left in period. Inflated stages and zombie deals fake coverage \u2014 cross-check with Freshness before trusting it.",
+        deepdive: [
+          "Always pair with Win Rate and Freshness.",
+          "Weighted Pipeline is the credibility-adjusted cousin."
+        ],
+        visual: {
+          kind: "gauge",
+          caption: "Exemplar coverage vs a 3x target",
+          gauge: 72,
+          bars: [
+            { label: "Open pipeline", value: 75, tone: "accent" },
+            { label: "Trailing won (scaled)", value: 25, tone: "neutral" }
+          ]
+        },
+        audience: {
+          board: "Coverage answers whether next quarter is already under-piped. Fake coverage from zombies is worse than an honest gap.",
+          ops: "open / trailing-90d won. Required \u2248 1/win_rate. Cross-check Freshness before briefing."
+        },
+        aliases: ["coverage", "pipeline coverage", "pipe coverage"],
+        benchmarkHint: (motion) => pctBand("pipeline_coverage", motion)
+      },
+      {
+        id: "weighted_pipeline",
+        kind: "saas",
+        label: "Weighted Pipeline",
+        group: "Pipeline",
+        tagline: "What is the pipeline worth after stage probability?",
+        how_computed: "Sum of amount \xD7 stage probability for open deals (CRM Probability when present, else stage defaults).",
+        formula_lines: [
+          "Weighted = \u03A3 (amount \xD7 stageProbability)",
+          "trust \u2264 stage discipline deserves"
+        ],
+        meaning: 'Board question: "what should we actually forecast from open pipe?"',
+        expert_read: "Trust it only as much as stage discipline deserves. Inflated late stages make weighted pipeline a fiction.",
+        deepdive: [
+          "Compare to unweighted open pipeline \u2014 a huge gap means optimistic stages.",
+          "Pair with Flow Rate (stuck late stages)."
+        ],
+        visual: {
+          kind: "bars",
+          caption: "Exemplar \u2014 open vs weighted",
+          bars: [
+            { label: "Open pipeline", value: 100, tone: "neutral" },
+            { label: "Weighted", value: 42, tone: "accent" }
+          ]
+        },
+        audience: {
+          board: "Weighted Pipeline is the credibility-adjusted forecast input \u2014 only as good as stage discipline.",
+          ops: "\u03A3 amount \xD7 probability. Audit stage probabilities when weighted << open."
+        },
+        aliases: ["weighted pipe", "probability-weighted pipeline"]
+      },
+      {
+        id: "pipeline_created",
+        kind: "saas",
+        label: "Pipeline Created (90d)",
+        group: "Pipeline",
+        tagline: "How much new pipe did we generate recently?",
+        how_computed: "Sum of amounts for opportunities created in the last 90 days.",
+        formula_lines: ["Pipeline Created = \u03A3 amount where created_at within 90d"],
+        meaning: 'Board question: "is the top of funnel still filling?"',
+        expert_read: "Falling created pipeline with flat coverage is a future miss \u2014 coverage is lagging; created is leading.",
+        deepdive: [
+          "Leading indicator for next-quarter coverage.",
+          "Cut by source / segment to find where creation stalled."
+        ],
+        visual: {
+          kind: "bars",
+          caption: "Exemplar \u2014 created vs needed",
+          bars: [
+            { label: "Created (90d)", value: 55, tone: "yellow" },
+            { label: "Target pace", value: 80, tone: "green" }
+          ]
+        },
+        audience: {
+          board: "Pipeline Created is a leading indicator \u2014 coverage lagging means the miss is already in motion.",
+          ops: "\u03A3 amounts on opps created in 90d. Cut by source when it dips."
+        },
+        aliases: ["pipe gen", "pipeline generation", "created pipeline"]
+      },
+      {
+        id: "pipeline_velocity",
+        kind: "saas",
+        label: "Pipeline Velocity",
+        group: "Pipeline",
+        tagline: "Revenue throughput per day \u2014 four levers, one number.",
+        how_computed: "(openOpps \xD7 avgDeal \xD7 winRate) / avgCycleDays \u2014 requires \u22653 dated closed-won deals. Unit: $/day.",
+        formula_lines: [
+          "Velocity = (openOpps \xD7 avgDeal \xD7 winRate) / avgCycleDays",
+          "four levers: #opps \xB7 deal size \xB7 win rate \xB7 cycle days"
+        ],
+        meaning: 'Board question: "which lever moved when throughput changed?" The most decision-ready pipeline metric.',
+        expert_read: "When velocity changes, name WHICH lever moved. A win-rate rise on falling opp volume is qualification tightening, not improvement.",
+        deepdive: [
+          "Needs \u22653 dated wins \u2014 otherwise unavailable.",
+          "Pairs with Flow Rate (cycle) and Win Rate (conversion)."
+        ],
+        visual: {
+          kind: "levers",
+          caption: "Four levers \u2014 say which one moved",
+          levers: ["# Open opps", "Avg deal size", "Win rate", "Cycle days"]
+        },
+        audience: {
+          board: "Velocity is throughput. When it moves, demand the lever \u2014 volume, size, win rate, or cycle \u2014 not a shrug.",
+          ops: "(opps \xD7 avgDeal \xD7 winRate) / cycleDays. Diagnose the moved lever before prescribing."
+        },
+        aliases: ["velocity", "pipeline velocity", "throughput"]
+      },
+      // —— Sales efficiency ——
+      {
+        id: "win_rate",
+        kind: "saas",
+        label: "Win Rate",
+        group: "Sales Efficiency",
+        tagline: "Of decided deals, how often do we win?",
+        how_computed: "closed-won / (won + lost) \xD7 100.",
+        formula_lines: ["Win Rate = won / (won + lost) \xD7 100"],
+        meaning: 'Board question: "are we converting the pipe we create?" Priors: 25\u201335% SMB, 18\u201325% mid-market, 12\u201318% enterprise on qualified opps.',
+        expert_read: "A rising win rate on falling opp volume is qualification tightening, not improvement \u2014 check the denominator.",
+        deepdive: [
+          "Required coverage \u2248 1 / win rate.",
+          "Cut by segment / source before company-wide coaching."
+        ],
+        visual: {
+          kind: "split",
+          caption: "Exemplar decided deals",
+          bars: [
+            { label: "Won", value: 28, tone: "green" },
+            { label: "Lost", value: 72, tone: "red" }
+          ]
+        },
+        audience: {
+          board: "Win Rate is conversion of decided deals. Rising win rate with falling volume is often tighter qualification, not better selling.",
+          ops: "won/(won+lost). Check the denominator. Motion benchmarks set green/yellow bands."
+        },
+        aliases: ["close rate", "winrate", "win %"],
+        benchmarkHint: (motion) => pctBand("win_rate", motion)
+      },
+      {
+        id: "avg_deal_size",
+        kind: "saas",
+        label: "Avg Deal Size",
+        group: "Sales Efficiency",
+        tagline: "What does a typical win look like?",
+        how_computed: "Mean amount on closed-won opportunities.",
+        formula_lines: ["Avg Deal = mean(closed-won amount)"],
+        meaning: 'Board question: "are we selling the motion we think we are?"',
+        expert_read: "Deal size drifting down while volume rises often means mix shift into a lower segment \u2014 not always a problem, but it changes coverage math.",
+        deepdive: [
+          "Feeds Pipeline Velocity and LTV proxy.",
+          "Cut by segment \u2014 averages hide bimodal motions."
+        ],
+        visual: {
+          kind: "bars",
+          caption: "Exemplar \u2014 size mix by segment",
+          bars: [
+            { label: "SMB", value: 30, tone: "neutral" },
+            { label: "Mid-market", value: 55, tone: "accent" },
+            { label: "Enterprise", value: 90, tone: "green" }
+          ]
+        },
+        audience: {
+          board: "Avg Deal Size should match the motion you claim. Mix shift changes coverage and capacity math.",
+          ops: "Mean closed-won amount. Segment before coaching on size."
+        },
+        aliases: ["average deal size", "asp", "acv"]
+      },
+      {
+        id: "avg_sales_cycle",
+        kind: "saas",
+        label: "Avg Sales Cycle",
+        group: "Sales Efficiency",
+        tagline: "How long from create to close on wins?",
+        how_computed: "Mean days from created_at to close date on dated closed-won deals.",
+        formula_lines: ["Avg Cycle = mean(close_date \u2212 created_at) on dated wins"],
+        meaning: 'Board question: "is the cycle stretching \u2014 the earliest soft signal of deal-quality decay?"',
+        expert_read: "Cycle stretching past the motion's norm is the earliest soft signal of deal-quality decay. Pair with Flow Rate stuck stages.",
+        deepdive: [
+          "Feeds Pipeline Velocity as the denominator.",
+          "Needs dated wins \u2014 missing close dates understate/omit."
+        ],
+        visual: {
+          kind: "bars",
+          caption: "Exemplar cycle vs motion norm",
+          bars: [
+            { label: "Your cycle", value: 78, tone: "yellow" },
+            { label: "Motion norm", value: 55, tone: "green" }
+          ]
+        },
+        audience: {
+          board: "Cycle stretch is an early soft signal that quality or process is slipping \u2014 before the miss shows in bookings.",
+          ops: "Mean create\u2192close on dated wins. Investigate the stage that aged."
+        },
+        aliases: ["sales cycle", "cycle length", "time to close"]
+      },
+      {
+        id: "stage_conversion",
+        kind: "saas",
+        label: "Stage Conversion",
+        group: "Sales Efficiency",
+        tagline: "Where in the stage model does advancement collapse?",
+        how_computed: "From metadata.stage_history stage advances when present; otherwise a win-rate proxy.",
+        formula_lines: [
+          "Preferred: advancement rates from stage_history",
+          "Fallback: win-rate proxy when history is missing"
+        ],
+        meaning: 'Board question: "which single stage is starving everything downstream?"',
+        expert_read: "Find the one stage where conversion collapses \u2014 that's the process problem; everything downstream is starvation.",
+        deepdive: [
+          "Best with stage_history metadata; otherwise treat as proxy.",
+          "Pairs with Flow Rate stage-age cuts."
+        ],
+        visual: {
+          kind: "funnel",
+          caption: "Exemplar \u2014 find the collapse",
+          funnel: [
+            { label: "Stage 1\u21922", widthPct: 100 },
+            { label: "Stage 2\u21923", widthPct: 72 },
+            { label: "Stage 3\u21924", widthPct: 28 },
+            { label: "Stage 4\u2192Close", widthPct: 18 }
+          ]
+        },
+        audience: {
+          board: "Stage Conversion names the bottleneck stage \u2014 one collapse starves every stage after it.",
+          ops: "Prefer stage_history advances. Fix the collapse stage before coaching downstream reps."
+        },
+        aliases: ["stage conversion", "stage advance", "conversion by stage"]
+      },
+      // —— Unit economics ——
+      {
+        id: "ltv_proxy",
+        kind: "saas",
+        label: "LTV (Proxy)",
+        group: "Unit Economics",
+        tagline: "Rough lifetime value from deal size and GRR.",
+        how_computed: "avgDeal / ((100 \u2212 GRR) / 100) when GRR < 100. Unavailable when GRR is 100%+ or missing.",
+        formula_lines: [
+          "LTV \u2248 avgDeal / churnRate",
+          "churnRate = (100 \u2212 GRR) / 100  (requires GRR < 100)"
+        ],
+        meaning: 'Board question: "what is a customer roughly worth over their life?"',
+        expert_read: "This is a proxy \u2014 not a cohort LTV. Use it for direction, not capital allocation.",
+        deepdive: [
+          "Unavailable when GRR \u2265 100 or missing.",
+          "Pairs with CAC for LTV:CAC when spend data exists."
+        ],
+        visual: {
+          kind: "gauge",
+          caption: "Exemplar LTV proxy (directional)",
+          gauge: 68
+        },
+        audience: {
+          board: "LTV Proxy is directional from deal size and GRR \u2014 not a cohort LTV. Use for orientation, not capital decisions.",
+          ops: "avgDeal / ((100\u2212GRR)/100). Needs GRR < 100. Prefer cohort math when billing data arrives."
+        },
+        aliases: ["ltv", "lifetime value"]
+      },
+      {
+        id: "cac",
+        kind: "saas",
+        label: "CAC",
+        group: "Unit Economics",
+        tagline: "Customer acquisition cost \u2014 needs spend data.",
+        how_computed: "Requires campaign / sales spend data. Currently unavailable on CRM-only datasets.",
+        formula_lines: ["CAC = sales & marketing spend / new customers", "(requires spend data \u2014 not in CRM-only exports)"],
+        meaning: 'Board question: "what does a new logo cost to win?"',
+        expert_read: "Without spend, NTRP cannot invent CAC. Wire campaign spend or finance exports to unlock unit economics.",
+        deepdive: [
+          "Always unavailable on CRM-only demos \u2014 expected.",
+          "Unlocks LTV:CAC, Payback, Magic Number when spend lands."
+        ],
+        visual: { kind: "none", caption: "Needs campaign spend / finance export" },
+        audience: {
+          board: "CAC is locked until spend data is connected \u2014 CRM alone cannot price acquisition.",
+          ops: "Bring campaign or S&M spend. Until then unit-econ metrics stay unavailable by design."
+        },
+        aliases: ["customer acquisition cost", "acquisition cost"]
+      },
+      {
+        id: "ltv_cac_ratio",
+        kind: "saas",
+        label: "LTV:CAC Ratio",
+        group: "Unit Economics",
+        tagline: "Is acquisition spend earning its keep?",
+        how_computed: "LTV proxy \xF7 CAC. Unavailable without spend (CAC).",
+        formula_lines: ["LTV:CAC = LTV_proxy / CAC", "(requires CAC)"],
+        meaning: 'Board question: "do we earn enough lifetime value per dollar spent to acquire?"',
+        expert_read: "Efficiency era: boards weigh LTV:CAC and payback as heavily as growth. Classic rule of thumb \u22653x, but motion and gross margin matter.",
+        deepdive: ["Blocked on CAC. See LTV Proxy and CAC."],
+        visual: { kind: "none", caption: "Needs CAC (spend data)" },
+        audience: {
+          board: "LTV:CAC is the acquisition ROI story \u2014 available once spend is wired.",
+          ops: "LTV_proxy / CAC. Unlocks with spend import."
+        },
+        aliases: ["ltv cac", "ltv/cac", "ltv to cac"]
+      },
+      {
+        id: "payback_months",
+        kind: "saas",
+        label: "Payback Months",
+        group: "Unit Economics",
+        tagline: "How many months to recover CAC?",
+        how_computed: "Requires CAC / spend. Lower is better.",
+        formula_lines: ["Payback \u2248 CAC / (monthly gross profit per customer)", "(requires spend data)"],
+        meaning: 'Board question: "how fast does acquisition spend return?" Efficiency era prior: <18 months often healthy.',
+        expert_read: "Boards now weigh payback (<18mo) as heavily as growth in many motions.",
+        deepdive: ["Blocked on CAC. Benchmarks exist per motion once data lands."],
+        visual: { kind: "none", caption: "Needs CAC (spend data)" },
+        audience: {
+          board: "Payback is how fast CAC returns. Efficiency-era boards often want <18 months.",
+          ops: "Requires CAC. Motion green/yellow bands apply when available."
+        },
+        aliases: ["payback", "cac payback"],
+        benchmarkHint: (motion) => monthsBand(motion)
+      },
+      {
+        id: "magic_number",
+        kind: "saas",
+        label: "Magic Number",
+        group: "Unit Economics",
+        tagline: "Sales efficiency \u2014 net new ARR per sales dollar.",
+        how_computed: "Requires sales spend. Classic form: net new ARR (quarter) / prior-quarter S&M spend.",
+        formula_lines: [
+          "Magic Number \u2248 Net New ARR(q) / S&M spend(q\u22121)",
+          "(requires spend data)"
+        ],
+        meaning: 'Board question: "how efficiently does sales spend produce net new ARR?" Prior: >0.75 often healthy; >1 strong.',
+        expert_read: "Efficiency era: magic number >0.75 is weighed alongside growth. Without spend, NTRP keeps this unavailable rather than inventing it.",
+        deepdive: ["Blocked on spend. Benchmarks per motion ready when data lands."],
+        visual: { kind: "none", caption: "Needs S&M spend data" },
+        audience: {
+          board: "Magic Number prices sales efficiency. Available once S&M spend is connected.",
+          ops: "Net new ARR / prior S&M. Motion benchmarks apply when spend lands."
+        },
+        aliases: ["sales magic number", "sales efficiency magic number"],
+        benchmarkHint: (motion) => magicBand(motion)
+      }
+    ];
+    METRIC_DEFINITIONS = [...VITALS, ...SAAS];
+    BY_ID = new Map(METRIC_DEFINITIONS.map((m) => [m.id, m]));
+    ALIAS_INDEX = (() => {
+      const idx = /* @__PURE__ */ new Map();
+      for (const m of METRIC_DEFINITIONS) {
+        idx.set(m.id.toLowerCase(), m.id);
+        idx.set(m.label.toLowerCase(), m.id);
+        for (const a of m.aliases ?? []) {
+          idx.set(a.toLowerCase(), m.id);
+        }
+      }
+      idx.set("signal-to-noise", "signal_to_noise");
+      idx.set("signal:noise", "signal_to_noise");
+      idx.set("flow-rate", "flow_rate");
+      idx.set("drop-rate", "drop_rate");
+      idx.set("thread-depth", "thread_depth");
+      return idx;
+    })();
+    SAAS_METRIC_IDS = SAAS.map((m) => m.id);
+  }
+});
+
+// src/services/metric-explainers.ts
+function normalizeAudience(audience) {
+  if (!audience) return "board";
+  const a = String(audience).toLowerCase();
+  if (a === "ops" || a === "operations" || a === "operator" || a === "team") {
+    return "ops";
+  }
+  return "board";
 }
-function hasAnyAnalysis(bundle) {
-  return bundle.diagnosis != null || bundle.metrics != null;
+function audienceLabel(audience) {
+  return audience === "ops" ? "ops" : "board / exec";
 }
-function formatMetricLine(row) {
-  const label = row.label ?? row.metric;
-  const formatted = row.formatted ?? "--";
-  const conf = row.confidence;
-  const confStr = conf != null && conf < 80 ? ` (${conf}% conf)` : "";
-  return `- ${label}: ${formatted}${confStr}`;
+function statusRankFrom(status) {
+  if (status === "red") return 0;
+  if (status === "yellow") return 1;
+  if (status === "green") return 2;
+  return 3;
 }
-function buildHandoffContextBlock(bundle, ctx) {
-  const { diagnosis, metrics } = bundle;
-  const profile = loadProfile();
-  const lines = [];
-  if (profile?.company_name) {
-    lines.push(`Company: ${profile.company_name} (${profile.industry})`);
-    lines.push(`Sales motion: ${profile.sales_motion}${profile.average_deal_size ? ` \xB7 avg deal ${profile.average_deal_size}` : ""}`);
-    if (profile.user_scope) lines.push(`My scope: ${profile.user_scope}`);
-  }
-  if (ctx.dataset?.label) {
-    const counts = ctx.dataset.counts ?? {};
-    const countStr = Object.entries(counts).filter(([, n]) => n > 0).map(([k, n]) => `${n} ${k}`).join(", ");
-    lines.push(`Dataset: ${ctx.dataset.label}${countStr ? ` (${countStr})` : ""}`);
-  }
-  const completed = ctx.analysis.completed;
-  if (completed.length > 0) {
-    lines.push(`Analysis lenses completed: ${completed.join(", ")}`);
-  }
-  lines.push("");
-  if (diagnosis) {
-    const { health, findings } = diagnosis;
-    lines.push("## GTM health (vital signs)");
-    lines.push(`Overall score: ${Math.round(health.overall_score)} (${health.overall_status})`);
-    if (health.total_value_at_risk != null && health.total_value_at_risk > 0) {
-      lines.push(`Total value at risk: ${formatCurrency(health.total_value_at_risk)}`);
-    }
-    lines.push("");
-    lines.push("### Vital signs");
-    for (const vs of health.vital_signs) {
-      const label = VITAL_SIGN_LABELS[vs.vital_sign] ?? vs.vital_sign;
-      const dollars = vs.dollar_value != null ? ` \u2014 ${formatCurrency(vs.dollar_value)}${vs.dollar_label ? ` ${vs.dollar_label}` : ""}` : "";
-      lines.push(`- ${label}: ${Math.round(vs.score)} (${vs.status})${dollars}`);
+function collectCandidates(bundle, opts) {
+  const prefer = new Set(opts.prefer ?? []);
+  const map = /* @__PURE__ */ new Map();
+  const upsert = (id, priority, status) => {
+    if (!getMetricExplainer(id)) return;
+    const existing = map.get(id);
+    const rank = statusRankFrom(status);
+    if (!existing) {
+      map.set(id, { id, priority, statusRank: rank });
+      return;
     }
-    if (findings.length > 0) {
-      lines.push("");
-      lines.push("### GTM findings");
-      appendFindings(lines, findings);
+    existing.priority = Math.min(existing.priority, priority);
+    existing.statusRank = Math.min(existing.statusRank, rank);
+  };
+  const health = bundle?.diagnosis?.health;
+  const fromDiag = opts.vitals ?? health?.vital_signs ?? [];
+  const gating = opts.prefer?.[0] ?? health?.gating_vital_sign;
+  if (gating) upsert(String(gating), 0, "red");
+  for (const vs of fromDiag) {
+    const id = vs.vital_sign;
+    upsert(id, prefer.has(id) ? 0 : 1, vs.status);
+  }
+  const rawMetrics = opts.metrics ?? bundle?.metrics?.metrics ?? [];
+  let sawMetrics = rawMetrics.length > 0;
+  for (const row of rawMetrics) {
+    const id = String(row.metric ?? row.metric ?? "");
+    if (!id) continue;
+    const status = String(row.status ?? row.status ?? "");
+    const value = row.value ?? row.value;
+    const unavailable = row.unavailable_reason ?? row.unavailable_reason;
+    if (value == null && unavailable) continue;
+    upsert(id, prefer.has(id) ? 0 : 2, status);
+  }
+  if (sawMetrics || bundle?.metrics) {
+    for (const id of ["arr", "nrr", "pipeline_coverage", "win_rate"]) {
+      if (!map.has(id) && getMetricExplainer(id)) {
+        upsert(id, 3, "neutral");
+      }
     }
-    lines.push("");
   }
-  if (metrics && metrics.metrics.length > 0) {
-    lines.push("## SaaS metrics");
-    const byKey = new Map(metrics.metrics.map((r) => [r.metric, r]));
-    for (const key of KEY_METRICS) {
-      const row = byKey.get(key);
-      if (row) lines.push(formatMetricLine(row));
-    }
-    if (metrics.findings.length > 0) {
-      lines.push("");
-      lines.push("### Metrics findings");
-      appendFindings(lines, metrics.findings);
+  if (map.size === 0) {
+    for (const id of ["freshness", "flow_rate", "drop_rate", "signal_to_noise", "thread_depth"]) {
+      upsert(id, 4, "neutral");
     }
-    lines.push("");
-  }
-  if (!diagnosis && metrics) {
-    lines.unshift("Primary analysis: SaaS metrics (no GTM health snapshot on this session yet).", "");
-  } else if (diagnosis && !metrics) {
-    lines.push("(SaaS metrics not run on this session \u2014 run /metrics for the revenue view)");
   }
-  return lines.join("\n").trim();
+  return [...map.values()].sort((a, b) => {
+    if (a.priority !== b.priority) return a.priority - b.priority;
+    if (a.statusRank !== b.statusRank) return a.statusRank - b.statusRank;
+    return a.id.localeCompare(b.id);
+  });
 }
-function buildExploreContextBlock(bundle, ctx) {
-  const full = buildHandoffContextBlock(bundle, ctx);
-  if (!full) return "";
-  const lines = full.split("\n");
-  const out = [
-    "COMPLETED ANALYSIS (the user already saw the full report \u2014 cite this, do not re-dump it):",
-    ""
-  ];
-  let inFindings = false;
-  let findingCount = 0;
-  for (const line of lines) {
-    if (line.startsWith("### GTM findings") || line.startsWith("### Metrics findings")) {
-      inFindings = true;
-      out.push(line);
-      continue;
-    }
-    if (inFindings && line.startsWith("- [")) {
-      if (findingCount >= 5) continue;
-      out.push(line);
-      findingCount++;
-      continue;
-    }
-    if (inFindings && line.startsWith("##")) {
-      inFindings = false;
-    }
-    if (line.startsWith("## ") || line.startsWith("### Vital") || line.startsWith("- ") && !inFindings) {
-      if (line.startsWith("(SaaS metrics not run")) continue;
-      out.push(line);
-    }
-    if (line.startsWith("Overall score:") || line.startsWith("Total value at risk:")) {
-      out.push(line);
-    }
-    if (line.startsWith("- ARR:") || line.startsWith("- NRR:") || line.startsWith("- GRR:")) {
-      out.push(line);
+function formatEntry(explainer, audience) {
+  const framing = audience === "ops" ? explainer.audience.ops : explainer.audience.board;
+  const lines = [];
+  lines.push(`### ${explainer.label} (\`${explainer.id}\`)`);
+  lines.push("");
+  lines.push(framing);
+  lines.push("");
+  if (audience === "ops") {
+    lines.push("**How it's calculated**");
+    lines.push("");
+    for (const f of explainer.formula_lines) {
+      lines.push(`- \`${f}\``);
     }
+    lines.push("");
+  } else {
+    lines.push(`*${explainer.tagline}*`);
+    lines.push("");
   }
-  return out.join("\n").trim();
-}
-function appendFindings(lines, findings) {
-  for (const f of findings.slice(0, 12)) {
-    const dollars = f.dollar_value != null ? ` (${formatCurrency(f.dollar_value)})` : "";
-    const plays = f.recommended_plays?.length ? ` \u2192 Plays: ${f.recommended_plays.map((p) => p.play_name).join(", ")}` : "";
-    lines.push(`- [${f.severity}]${dollars} ${f.finding}${plays}`);
-  }
+  return lines;
 }
-function handoffInstructionPrefix(primary) {
-  if (primary === "revenue_metrics") {
-    return "the SaaS metrics and pipeline context below";
+function buildDefinitionsAppendix(bundle, opts = {}) {
+  const audience = normalizeAudience(opts.audience);
+  const cap = opts.cap ?? DEFAULT_CAP;
+  const candidates = collectCandidates(bundle, opts).slice(0, cap);
+  if (candidates.length === 0) return "";
+  const lines = [];
+  lines.push(`## Metric definitions (for the ${audienceLabel(audience)})`);
+  lines.push("");
+  lines.push(
+    audience === "ops" ? "Formula-first brief for operators executing the plan. Full slides: `/deepdive <metric>`." : "Meaning-first brief for the room. Full slides: `/deepdive <metric>`."
+  );
+  lines.push("");
+  for (const c of candidates) {
+    const explainer = getMetricExplainer(c.id);
+    if (!explainer) continue;
+    lines.push(...formatEntry(explainer, audience));
   }
-  return "the pipeline diagnosis below";
+  return lines.join("\n");
 }
-var KEY_METRICS;
-var init_session_analysis = __esm({
-  "src/services/session-analysis.ts"() {
+var DEFAULT_CAP;
+var init_metric_explainers = __esm({
+  "src/services/metric-explainers.ts"() {
     "use strict";
-    init_queries();
-    init_profile();
-    init_formatters();
-    init_theme();
-    KEY_METRICS = ["arr", "nrr", "grr", "win_rate", "pipeline_coverage"];
+    init_metric_definitions();
+    DEFAULT_CAP = 8;
   }
 });
 
@@ -13599,16 +14748,24 @@ function buildOpenQuestions(ctx) {
   }
   return lines.length > 0 ? lines.join("\n") : "(No open questions recorded.)";
 }
-function wrapForTarget(target, analysisBlock, conversationBlock, openQuestions, ctx) {
+function audiencePhrase(audience) {
+  if (!audience) return "an executive audience";
+  const a = audience.toLowerCase();
+  if (a === "ops" || a === "operations") return "an ops / operator audience";
+  if (a === "board") return "a board / exec audience";
+  return `a ${audience} audience`;
+}
+function wrapForTarget(target, analysisBlock, conversationBlock, openQuestions, definitionsBlock, ctx) {
   const company = loadProfile()?.company_name ?? "the company";
   const contextLabel = handoffInstructionPrefix(ctx.analysis.primary);
+  const forWhom = audiencePhrase(ctx.scope?.audience);
   const instructions = {
-    deck: `produce an executive review deck outline for ${company}. Structure: (1) Headline number; (2) Pipeline health; (3) Top 3 risks with dollar impact; (4) Recommended plays; (5) Asks / decisions.`,
-    asana: `produce an Asana project plan with sections and tasks tied to findings. Prioritize by dollar impact.`,
-    clay: `produce a Clay table specification to operationalize the highest-impact finding.`,
-    plan: `produce a prioritized action plan with problem, play, first 3 steps, owner, and leading indicator per item.`
+    deck: `produce an executive review deck outline for ${company}, framed for ${forWhom}. Structure: (1) Headline number; (2) Pipeline health; (3) Top 3 risks with dollar impact; (4) Recommended plays; (5) Asks / decisions. Use the Metric definitions appendix so every slide can briefly remind the room what the number means for this audience.`,
+    asana: `produce an Asana project plan with sections and tasks tied to findings for ${forWhom}. Prioritize by dollar impact. Reference metric definitions when a task owner needs to know what "good" looks like.`,
+    clay: `produce a Clay table specification to operationalize the highest-impact finding for ${forWhom}.`,
+    plan: `produce a prioritized action plan for ${forWhom} with problem, play, first 3 steps, owner, and leading indicator per item. Ground indicators in the Metric definitions appendix.`
   };
-  return [
+  const parts = [
     `# NTRP handoff \u2192 ${target}`,
     "",
     `You are an expert GTM operator. Using ${contextLabel}, ${instructions[target]}`,
@@ -13624,25 +14781,35 @@ function wrapForTarget(target, analysisBlock, conversationBlock, openQuestions,
     conversationBlock,
     "",
     "---",
-    "",
-    "## Open questions",
-    "",
-    openQuestions,
-    "",
-    "---",
     ""
-  ].join("\n");
+  ];
+  if (definitionsBlock.trim()) {
+    parts.push(definitionsBlock.trim(), "", "---", "");
+  }
+  parts.push("## Open questions", "", openQuestions, "", "---", "");
+  return parts.join("\n");
 }
 async function buildDeliverableDraft(ctx, target = "plan") {
   const bundle = await loadSessionAnalysisBundle();
   const analysis = buildHandoffContextBlock(bundle, ctx);
   const conversation = buildConversationSection(ctx);
   const open_questions = buildOpenQuestions(ctx);
+  const definitions = buildDefinitionsAppendix(bundle, {
+    audience: ctx.scope?.audience,
+    prefer: bundle.diagnosis?.health.gating_vital_sign ? [bundle.diagnosis.health.gating_vital_sign] : void 0
+  });
   if (!analysis && ctx.messages.length === 0) return null;
-  const markdown = wrapForTarget(target, analysis, conversation, open_questions, ctx);
+  const markdown = wrapForTarget(
+    target,
+    analysis,
+    conversation,
+    open_questions,
+    definitions,
+    ctx
+  );
   return {
     markdown,
-    sections: { analysis, conversation, open_questions }
+    sections: { analysis, conversation, open_questions, definitions }
   };
 }
 function inferHandoffTarget(input) {
@@ -13662,6 +14829,7 @@ var init_handoff_draft = __esm({
     "use strict";
     init_profile();
     init_session_analysis();
+    init_metric_explainers();
     QUESTION_LEAD_RE = /^\s*(what|why|how|when|where|who|which|is|are|was|were|do|does|did|explain|tell me|help me understand)\b/i;
     SHIP_INTENT_RE = /\b(ship|export|deliver|write[- ]?up|board memo|action plan|turn (this|it|that) into|(draft|create|make|build|prepare|generate|send)\s+(me\s+)?(a\s+|the\s+)?hand[- ]?off|hand[- ]?off\s+(prompt|doc|document|plan))\b/i;
   }
@@ -14887,94 +16055,94 @@ var init_strategist2 = __esm({
 });
 
 // src/output/strategy-brief.ts
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 function printWrapped(text, width, prefix = INDENT, style) {
   for (const line of wrapWords(text, width)) {
     console.log(prefix + (style ? style(line) : line));
   }
 }
 function outcomeLine(outcome) {
-  return `${chalk12.bold(outcome.metric)}: ${outcome.baseline} ${chalk12.dim("->")} ${chalk12.bold(outcome.target_range)} ${chalk12.dim(`by ${outcome.check_date} \xB7 ${outcome.measured_by}`)}`;
+  return `${chalk13.bold(outcome.metric)}: ${outcome.baseline} ${chalk13.dim("->")} ${chalk13.bold(outcome.target_range)} ${chalk13.dim(`by ${outcome.check_date} \xB7 ${outcome.measured_by}`)}`;
 }
 function printWorkstream(ws, width) {
-  const plays = ws.play_ids.length > 0 ? chalk12.dim(`  play: ${ws.play_ids.join(", ")}`) : "";
-  console.log(`${INDENT}${paint("accent", `${ws.order}.`)} ${chalk12.bold(ws.title)}${plays}`);
-  printWrapped(ws.problem, width - 5, INDENT + "   ", (s) => chalk12.dim(s));
+  const plays = ws.play_ids.length > 0 ? chalk13.dim(`  play: ${ws.play_ids.join(", ")}`) : "";
+  console.log(`${INDENT}${paint("accent", `${ws.order}.`)} ${chalk13.bold(ws.title)}${plays}`);
+  printWrapped(ws.problem, width - 5, INDENT + "   ", (s) => chalk13.dim(s));
   if (ws.rationale) {
-    printWrapped(`Why now: ${ws.rationale}`, width - 5, INDENT + "   ", (s) => chalk12.dim(s));
+    printWrapped(`Why now: ${ws.rationale}`, width - 5, INDENT + "   ", (s) => chalk13.dim(s));
   }
   console.log(`${INDENT}   ${outcomeLine(ws.expected_outcome)}`);
   for (const li of ws.leading_indicators) {
-    console.log(`${INDENT}   ${chalk12.dim("leads:")} ${outcomeLine(li)}`);
+    console.log(`${INDENT}   ${chalk13.dim("leads:")} ${outcomeLine(li)}`);
   }
   if (ws.milestones.length > 0) {
-    console.log(`${INDENT}   ${chalk12.dim("Milestones")}`);
+    console.log(`${INDENT}   ${chalk13.dim("Milestones")}`);
     for (const m of ws.milestones) {
-      console.log(`${INDENT}     ${paint("accent", m.due)}  ${m.label} ${chalk12.dim(`(verify: ${m.verification})`)}`);
+      console.log(`${INDENT}     ${paint("accent", m.due)}  ${m.label} ${chalk13.dim(`(verify: ${m.verification})`)}`);
     }
   }
   if (ws.deliverables.length > 0) {
-    console.log(`${INDENT}   ${chalk12.dim("Deliverables")}`);
+    console.log(`${INDENT}   ${chalk13.dim("Deliverables")}`);
     for (const d of ws.deliverables) {
-      console.log(`${INDENT}     ${chalk12.dim("[ ]")} ${d.label} ${chalk12.dim(`(${d.kind.replace("_", " ")} \xB7 due ${d.due})`)}`);
+      console.log(`${INDENT}     ${chalk13.dim("[ ]")} ${d.label} ${chalk13.dim(`(${d.kind.replace("_", " ")} \xB7 due ${d.due})`)}`);
     }
   }
   if (ws.actions.length > 0) {
-    console.log(`${INDENT}   ${chalk12.dim("First actions")}`);
+    console.log(`${INDENT}   ${chalk13.dim("First actions")}`);
     for (const action of ws.actions.slice(0, 4)) {
-      printWrapped(`- ${action}`, width - 7, INDENT + "     ", (s) => chalk12.dim(s));
+      printWrapped(`- ${action}`, width - 7, INDENT + "     ", (s) => chalk13.dim(s));
     }
   }
   printWrapped(
     `If ${ws.contingency.trigger} (check ${ws.contingency.trigger_check_date}) -> ${ws.contingency.fallback}`,
     width - 5,
     INDENT + "   ",
-    (s) => chalk12.hex("#eab308")(s)
+    (s) => chalk13.hex("#eab308")(s)
   );
-  console.log(`${INDENT}   ${chalk12.dim(`~${Math.round(ws.effort_hours)} team-hours`)}`);
+  console.log(`${INDENT}   ${chalk13.dim(`~${Math.round(ws.effort_hours)} team-hours`)}`);
   console.log();
 }
 function printStrategyBrief(plan, stats) {
   const width = Math.min(termWidth() - 4, 92);
   console.log();
   console.log(
-    `${INDENT}${chalk12.bold(`Strategy brief \u2014 ${plan.title}`)}  ${chalk12.dim(`confidence ${plan.confidence.toFixed(2)} \xB7 ${plan.priority} priority \xB7 review ${plan.review_cadence.toLowerCase()}`)}`
+    `${INDENT}${chalk13.bold(`Strategy brief \u2014 ${plan.title}`)}  ${chalk13.dim(`confidence ${plan.confidence.toFixed(2)} \xB7 ${plan.priority} priority \xB7 review ${plan.review_cadence.toLowerCase()}`)}`
   );
-  console.log(INDENT + chalk12.dim(hr(width)));
+  console.log(INDENT + chalk13.dim(hr(width)));
   printWrapped(`Objective: ${plan.objective}`, width, INDENT, (s) => paint("accent", s));
   console.log();
-  console.log(`${INDENT}${chalk12.dim("30,000 ft")}`);
+  console.log(`${INDENT}${chalk13.dim("30,000 ft")}`);
   printWrapped(plan.summary_30k, width);
   console.log();
   for (const ws of plan.workstreams) {
     printWorkstream(ws, width);
   }
   if (plan.constraints.length > 0) {
-    console.log(`${INDENT}${chalk12.dim("Constraints")}`);
+    console.log(`${INDENT}${chalk13.dim("Constraints")}`);
     for (const c of plan.constraints) {
-      printWrapped(`- ${c}`, width - 2, INDENT, (s) => chalk12.dim(s));
+      printWrapped(`- ${c}`, width - 2, INDENT, (s) => chalk13.dim(s));
     }
     console.log();
   }
   if (plan.assumptions.length > 0) {
-    console.log(`${INDENT}${chalk12.dim("Assumptions (unverified \u2014 not counted as targets)")}`);
+    console.log(`${INDENT}${chalk13.dim("Assumptions (unverified \u2014 not counted as targets)")}`);
     for (const a of plan.assumptions) {
-      printWrapped(`- ${a}`, width - 2, INDENT, (s) => chalk12.dim(s));
+      printWrapped(`- ${a}`, width - 2, INDENT, (s) => chalk13.dim(s));
     }
     console.log();
   }
   if (plan.risks.length > 0) {
-    console.log(`${INDENT}${chalk12.dim("Risks")}`);
+    console.log(`${INDENT}${chalk13.dim("Risks")}`);
     for (const r of plan.risks) {
-      printWrapped(`- ${r}`, width - 2, INDENT, (s) => chalk12.dim(s));
+      printWrapped(`- ${r}`, width - 2, INDENT, (s) => chalk13.dim(s));
     }
     console.log();
   }
   const totalHours = plan.workstreams.reduce((sum, ws) => sum + ws.effort_hours, 0);
-  console.log(INDENT + chalk12.dim(hr(width)));
+  console.log(INDENT + chalk13.dim(hr(width)));
   const coverage = stats.total_targets > 0 ? `${stats.measurable_targets} of ${stats.total_targets} targets measurable with current data` : "no quantified targets";
-  const coverageStyled = stats.total_targets > 0 && stats.measurable_targets === stats.total_targets ? paint("success", coverage) : chalk12.hex("#eab308")(coverage);
-  console.log(`${INDENT}${coverageStyled}${chalk12.dim(` \xB7 ~${Math.round(totalHours)} total team-hours across ${plan.workstreams.length} workstream${plan.workstreams.length === 1 ? "" : "s"}`)}`);
+  const coverageStyled = stats.total_targets > 0 && stats.measurable_targets === stats.total_targets ? paint("success", coverage) : chalk13.hex("#eab308")(coverage);
+  console.log(`${INDENT}${coverageStyled}${chalk13.dim(` \xB7 ~${Math.round(totalHours)} total team-hours across ${plan.workstreams.length} workstream${plan.workstreams.length === 1 ? "" : "s"}`)}`);
   console.log();
 }
 var INDENT;
@@ -14999,7 +16167,7 @@ __export(strategist_flow_exports, {
   resumeStrategistAfterConnect: () => resumeStrategistAfterConnect,
   startStrategistFlow: () => startStrategistFlow
 });
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 function isStrategistIntent(input) {
   const line = input.trim();
   if (!line) return false;
@@ -15019,11 +16187,11 @@ function queueStrategistForAnalysis(ctx, opts) {
   saveSessionState(ctx);
   console.log();
   console.log(
-    "  " + chalk13.dim("Strategy session queued \u2014 I'll build the plan once your data is analyzed.")
+    "  " + chalk14.dim("Strategy session queued \u2014 I'll build the plan once your data is analyzed.")
   );
   if (opts.origin !== "nl") {
     console.log(
-      "  " + chalk13.dim("Tell me what to look at, paste a CSV path, or say ") + chalk13.cyan("use demo data") + chalk13.dim(".")
+      "  " + chalk14.dim("Tell me what to look at, paste a CSV path, or say ") + chalk14.cyan("use demo data") + chalk14.dim(".")
     );
     console.log();
   }
@@ -15042,7 +16210,7 @@ async function startStrategistFlow(ctx, opts) {
     ctx.strategistState = { step: "objective_input", origin: opts.origin };
     saveSessionState(ctx);
     console.log();
-    console.log("  " + chalk13.dim(`What's the objective? State it like a finish line \u2014 e.g. "cut stale pipeline in half before Q4".`));
+    console.log("  " + chalk14.dim(`What's the objective? State it like a finish line \u2014 e.g. "cut stale pipeline in half before Q4".`));
     console.log();
     recordMessage(ctx, "agent", "Strategist: asked for objective");
     return "Awaiting objective";
@@ -15079,14 +16247,14 @@ async function handleStrategizeFlow(input, ctx) {
     ctx.strategistState = void 0;
     saveSessionState(ctx);
     console.log();
-    console.log("  " + chalk13.dim("Strategy session cancelled \u2014 back to exploring."));
+    console.log("  " + chalk14.dim("Strategy session cancelled \u2014 back to exploring."));
     console.log();
     return "Strategy cancelled";
   }
   if (state2.step === "objective_input") {
     if (line.length < 8) {
       console.log();
-      console.log("  " + chalk13.dim("Give me a bit more \u2014 what outcome are we planning toward?"));
+      console.log("  " + chalk14.dim("Give me a bit more \u2014 what outcome are we planning toward?"));
       console.log();
       return "Awaiting objective";
     }
@@ -15103,17 +16271,17 @@ async function handleStrategizeFlow(input, ctx) {
     state2.step = "objective_input";
     saveSessionState(ctx);
     console.log();
-    console.log("  " + chalk13.dim("What's the objective? State it like a finish line."));
+    console.log("  " + chalk14.dim("What's the objective? State it like a finish line."));
     console.log();
     return "Awaiting objective";
   }
   if (QUESTION_RE.test(line)) {
     console.log();
     console.log(
-      "  " + chalk13.dim("That looks like a question \u2014 I'm holding a strategy objective right now.")
+      "  " + chalk14.dim("That looks like a question \u2014 I'm holding a strategy objective right now.")
     );
     console.log(
-      "  " + chalk13.dim("Say ") + chalk13.cyan("yes") + chalk13.dim(" to build the plan, ") + chalk13.cyan("adjust") + chalk13.dim(" to restate it, or ") + chalk13.cyan("cancel") + chalk13.dim(" to go answer questions first.")
+      "  " + chalk14.dim("Say ") + chalk14.cyan("yes") + chalk14.dim(" to build the plan, ") + chalk14.cyan("adjust") + chalk14.dim(" to restate it, or ") + chalk14.cyan("cancel") + chalk14.dim(" to go answer questions first.")
     );
     console.log();
     return "Awaiting confirm";
@@ -15126,7 +16294,7 @@ async function handleStrategizeFlow(input, ctx) {
   }
   console.log();
   console.log(
-    "  " + chalk13.dim("Say ") + chalk13.cyan("yes") + chalk13.dim(" to plan, ") + chalk13.cyan("adjust") + chalk13.dim(" to restate the objective, or ") + chalk13.cyan("cancel") + chalk13.dim(".")
+    "  " + chalk14.dim("Say ") + chalk14.cyan("yes") + chalk14.dim(" to plan, ") + chalk14.cyan("adjust") + chalk14.dim(" to restate the objective, or ") + chalk14.cyan("cancel") + chalk14.dim(".")
   );
   console.log();
   return "Awaiting confirm";
@@ -15189,7 +16357,7 @@ async function runStrategistSession(ctx) {
           break;
         case "thinking":
           spinner.stop();
-          console.log("  " + chalk13.dim.italic(event.text));
+          console.log("  " + chalk14.dim.italic(event.text));
           spinner.start();
           break;
         case "notice":
@@ -15211,17 +16379,17 @@ async function runStrategistSession(ctx) {
     spinner.stop();
   } catch (err) {
     spinner.fail("Strategy session failed");
-    console.error("  " + chalk13.red(String(err.message ?? err)));
+    console.error("  " + chalk14.red(String(err.message ?? err)));
     ctx.strategistState = void 0;
     saveSessionState(ctx);
     console.log(
-      "  " + chalk13.dim('Strategy session dropped \u2014 say "how should we fix this?" or run ') + paint("accent", "/strategy") + chalk13.dim(" to retry.")
+      "  " + chalk14.dim('Strategy session dropped \u2014 say "how should we fix this?" or run ') + paint("accent", "/strategy") + chalk14.dim(" to retry.")
     );
     console.log();
     return;
   }
   if (!plan) {
-    console.log("  " + chalk13.dim("(no plan produced)"));
+    console.log("  " + chalk14.dim("(no plan produced)"));
     ctx.strategistState = void 0;
     saveSessionState(ctx);
     console.log();
@@ -15229,7 +16397,7 @@ async function runStrategistSession(ctx) {
   }
   printStrategyBrief(plan, stats);
   for (const notice of notices.slice(0, 6)) {
-    console.log("  " + chalk13.dim(notice));
+    console.log("  " + chalk14.dim(notice));
   }
   printLlmAttribution(meta);
   console.log();
@@ -15254,18 +16422,18 @@ async function runStrategistSession(ctx) {
       creditStrategySession(ctx);
       console.log();
       console.log("  " + paint("accent", `Strategy saved: ${persisted.strategy.title}`));
-      console.log("  " + chalk13.dim(persisted.library_path));
+      console.log("  " + chalk14.dim(persisted.library_path));
       console.log(
-        "  " + chalk13.dim("Check progress anytime with ") + paint("accent", `/strategy review ${persisted.strategy.slug}`) + chalk13.dim(" \u2014 future answers will reference this plan.")
+        "  " + chalk14.dim("Check progress anytime with ") + paint("accent", `/strategy review ${persisted.strategy.slug}`) + chalk14.dim(" \u2014 future answers will reference this plan.")
       );
       console.log();
       recordMessage(ctx, "agent", `Strategy saved: ${persisted.strategy.title} (${persisted.strategy.slug})`);
     } catch (err) {
-      console.error("  " + chalk13.red(`Could not save strategy: ${String(err.message ?? err)}`));
+      console.error("  " + chalk14.red(`Could not save strategy: ${String(err.message ?? err)}`));
       console.log();
     }
   } else {
-    console.log("  " + chalk13.dim("Kept as a working draft \u2014 not saved to the library."));
+    console.log("  " + chalk14.dim("Kept as a working draft \u2014 not saved to the library."));
     console.log();
     recordMessage(ctx, "agent", `Strategy drafted (unsaved): ${plan.title}`);
   }
@@ -15294,16 +16462,16 @@ async function ensureSnapshot(ctx) {
 }
 function printObjectiveCard(ctx, objective, proposed) {
   console.log();
-  console.log("  " + chalk13.bold("Strategy session"));
+  console.log("  " + chalk14.bold("Strategy session"));
   console.log(
-    "  " + chalk13.dim(proposed ? "Proposed objective: " : "Objective: ") + paint("accent", objective)
+    "  " + chalk14.dim(proposed ? "Proposed objective: " : "Objective: ") + paint("accent", objective)
   );
   console.log(
-    "  " + chalk13.dim("I'll ground it in your live data, sequence the fixes, set measurable milestones, and stress-test the plan.")
+    "  " + chalk14.dim("I'll ground it in your live data, sequence the fixes, set measurable milestones, and stress-test the plan.")
   );
   console.log();
   console.log(
-    "  " + chalk13.dim("Confirm? ") + chalk13.cyan("\u23CE yes") + chalk13.dim(" \xB7 ") + chalk13.cyan("adjust") + chalk13.dim(" \xB7 ") + chalk13.cyan("cancel")
+    "  " + chalk14.dim("Confirm? ") + chalk14.cyan("\u23CE yes") + chalk14.dim(" \xB7 ") + chalk14.cyan("adjust") + chalk14.dim(" \xB7 ") + chalk14.cyan("cancel")
   );
   console.log();
 }
@@ -15324,35 +16492,35 @@ async function printKeylessSkeletonPlan(ctx, objective) {
       LAYERS2
     );
     if (triggered.length > 0) {
-      console.log("  " + chalk13.bold("Skeleton plan") + chalk13.dim(" \u2014 deterministic, from your computed vitals (no AI)"));
-      console.log("  " + chalk13.dim(`Objective: ${objective}`));
-      console.log("  " + chalk13.dim("Ordered by dependency: clean data gates moving pipeline gates efficient effort."));
+      console.log("  " + chalk14.bold("Skeleton plan") + chalk14.dim(" \u2014 deterministic, from your computed vitals (no AI)"));
+      console.log("  " + chalk14.dim(`Objective: ${objective}`));
+      console.log("  " + chalk14.dim("Ordered by dependency: clean data gates moving pipeline gates efficient effort."));
       console.log();
       triggered.forEach(({ play, vital }, index) => {
         const dollar = vital.dollar_value != null && vital.dollar_value > 0 ? ` \xB7 ${formatCurrency(vital.dollar_value)} ${vital.dollar_label ?? ""}`.trimEnd() : "";
         console.log(
-          `  ${paint("accent", `${index + 1}.`)} ${chalk13.bold(play.name)} ${chalk13.dim(`(${play.id})`)}`
+          `  ${paint("accent", `${index + 1}.`)} ${chalk14.bold(play.name)} ${chalk14.dim(`(${play.id})`)}`
         );
         console.log(
-          "     " + chalk13.dim(`${vital.vital_sign} ${Math.round(vital.score)} (${vital.status})${dollar}`)
+          "     " + chalk14.dim(`${vital.vital_sign} ${Math.round(vital.score)} (${vital.status})${dollar}`)
         );
-        console.log("     " + chalk13.dim(`Why: ${play.why.split(". ")[0]}.`));
+        console.log("     " + chalk14.dim(`Why: ${play.why.split(". ")[0]}.`));
         if (play.steps[0]) {
-          console.log("     " + chalk13.dim(`First step: ${play.steps[0]}`));
+          console.log("     " + chalk14.dim(`First step: ${play.steps[0]}`));
         }
-        console.log("     " + chalk13.dim(`Expected: ${play.expected_outcome}`));
+        console.log("     " + chalk14.dim(`Expected: ${play.expected_outcome}`));
         console.log();
       });
     } else {
-      console.log("  " + chalk13.bold("No plays triggered") + chalk13.dim(" \u2014 every vital sign is above its play threshold."));
+      console.log("  " + chalk14.bold("No plays triggered") + chalk14.dim(" \u2014 every vital sign is above its play threshold."));
       console.log();
     }
   }
   console.log(
-    "  " + chalk13.dim("For the full strategist \u2014 milestones, outcome ranges, contingencies \u2014 press ") + paint("accent", "\u23CE") + chalk13.dim(" to run ") + paint("accent", "/connect") + chalk13.dim(" and paste any provider's key.")
+    "  " + chalk14.dim("For the full strategist \u2014 milestones, outcome ranges, contingencies \u2014 press ") + paint("accent", "\u23CE") + chalk14.dim(" to run ") + paint("accent", "/connect") + chalk14.dim(" and paste any provider's key.")
   );
   console.log(
-    "  " + chalk13.dim("Objective kept \u2014 after ") + paint("accent", "/connect") + chalk13.dim(" I'll bring back the confirm card so you can run the full plan.")
+    "  " + chalk14.dim("Objective kept \u2014 after ") + paint("accent", "/connect") + chalk14.dim(" I'll bring back the confirm card so you can run the full plan.")
   );
   console.log();
 }
@@ -15398,7 +16566,7 @@ __export(keyless_ask_exports, {
   isKeylessVitalsAsk: () => isKeylessVitalsAsk,
   tryKeylessAskAnswer: () => tryKeylessAskAnswer
 });
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 function isKeylessVitalsAsk(input) {
   return KEYLESS_ASK_RE.test(input.trim());
 }
@@ -15447,35 +16615,35 @@ async function tryKeylessAskAnswer(ctx, input, opts = {}) {
   const headline = dollarBit ? `${label} \u2014 ${dollarBit} \u2014 is the most expensive problem to solve right now.` : `${label} (score ${Math.round(primary.score)}, ${primary.status}) is the problem to fix first.`;
   const runners = [...aggregate.vital_signs].filter((v) => v.vital_sign !== primary.vital_sign && (v.dollar_value ?? 0) > 0).sort((a, b) => (b.dollar_value ?? 0) - (a.dollar_value ?? 0)).slice(0, 2);
   console.log();
-  console.log("  " + chalk14.bold(headline));
+  console.log("  " + chalk15.bold(headline));
   if (opts.fromResume) {
     if (runners.length > 0) {
       console.log(
-        "  " + chalk14.dim("Next after that: ") + chalk14.dim(runners.map(formatRunnerBit).join(" \xB7 "))
+        "  " + chalk15.dim("Next after that: ") + chalk15.dim(runners.map(formatRunnerBit).join(" \xB7 "))
       );
     }
   } else {
     console.log();
     if (gating && gating.vital_sign !== primary.vital_sign) {
       console.log(
-        "  " + chalk14.dim("Gating vital: ") + paint("accent", VITAL_SIGN_LABELS[gating.vital_sign]) + chalk14.dim(` (score ${Math.round(gating.score)}) \u2014 it bounds what you can trust downstream.`)
+        "  " + chalk15.dim("Gating vital: ") + paint("accent", VITAL_SIGN_LABELS[gating.vital_sign]) + chalk15.dim(` (score ${Math.round(gating.score)}) \u2014 it bounds what you can trust downstream.`)
       );
     }
     if (runners.length > 0) {
-      console.log("  " + chalk14.dim("Also on the board:"));
+      console.log("  " + chalk15.dim("Also on the board:"));
       for (const vs of runners) {
-        console.log("    " + chalk14.dim("\xB7 ") + formatVitalLine(vs));
+        console.log("    " + chalk15.dim("\xB7 ") + formatVitalLine(vs));
       }
     }
     if (aggregate.total_value_at_risk != null && aggregate.total_value_at_risk > 0) {
       console.log(
-        "  " + chalk14.dim("Total at risk: ") + chalk14.green(formatCurrency(aggregate.total_value_at_risk))
+        "  " + chalk15.dim("Total at risk: ") + chalk15.green(formatCurrency(aggregate.total_value_at_risk))
       );
     }
   }
   console.log();
   console.log(
-    "  " + chalk14.dim("Press ") + paint("accent", "\u23CE") + chalk14.dim(" to connect a key (") + paint("accent", "/connect") + chalk14.dim(") for the why and the plan \u2014 I'll finish this question when you do.")
+    "  " + chalk15.dim("Press ") + paint("accent", "\u23CE") + chalk15.dim(" to connect a key (") + paint("accent", "/connect") + chalk15.dim(") for the why and the plan \u2014 I'll finish this question when you do.")
   );
   console.log();
   if (!opts.fromResume) {
@@ -15497,11 +16665,119 @@ var init_keyless_ask = __esm({
   }
 });
 
+// src/conversation/keyless-definitions.ts
+import chalk16 from "chalk";
+function isPossessiveMetricAsk(input) {
+  return POSSESSIVE_RE.test(input.trim());
+}
+function isDefinitionAsk(input) {
+  const line = input.trim();
+  if (!line) return false;
+  if (isPossessiveMetricAsk(line)) return false;
+  return DEFINITION_RE.test(line) || MEAN_RE.test(line);
+}
+function extractDefinitionQuery(input) {
+  const line = input.trim().replace(/[?.!]+$/, "");
+  const mean = line.match(MEAN_RE);
+  if (mean?.[1]) return cleanQuery(mean[1]);
+  const how = line.match(HOW_CALC_RE);
+  if (how?.[1]) return cleanQuery(how[1]);
+  const what = line.match(WHAT_IS_RE);
+  if (what?.[1]) return cleanQuery(what[1]);
+  return void 0;
+}
+function cleanQuery(raw) {
+  return raw.replace(/^(?:a|an|the|our|my)\s+/i, "").replace(/\b(metric|score|number|vital(?:\s+sign)?|kpi)\b/gi, "").replace(/\s+/g, " ").trim();
+}
+function matchDefinitionExplainer(input) {
+  if (!isDefinitionAsk(input)) return void 0;
+  const query = extractDefinitionQuery(input);
+  if (!query) return void 0;
+  const id = resolveMetricId(query);
+  if (!id) {
+    const tokens = query.split(/\s+/);
+    for (let n = tokens.length; n >= 1; n--) {
+      for (let i = 0; i + n <= tokens.length; i++) {
+        const slice = tokens.slice(i, i + n).join(" ");
+        const hit = resolveMetricId(slice);
+        if (hit) return getMetricExplainer(hit);
+      }
+    }
+    return void 0;
+  }
+  return getMetricExplainer(id);
+}
+function printWrapped2(text, indent = "  ") {
+  for (const line of wrapWords(text, 78)) {
+    console.log(indent + line);
+  }
+}
+function tryKeylessDefinitionAnswer(ctx, input) {
+  const explainer = matchDefinitionExplainer(input);
+  if (!explainer) return false;
+  const motion = loadProfile()?.sales_motion ?? null;
+  const bench = explainer.benchmarkHint?.(motion);
+  console.log();
+  console.log(
+    "  " + sectionHeading(explainer.label) + chalk16.dim(` \xB7 ${explainer.kind === "vital" ? "vital sign" : "SaaS metric"}`)
+  );
+  console.log("  " + chalk16.dim(explainer.tagline));
+  console.log();
+  console.log("  " + bold("What it means"));
+  printWrapped2(explainer.meaning, "    ");
+  console.log();
+  console.log("  " + bold("How NTRP calculates it"));
+  printWrapped2(explainer.how_computed, "    ");
+  for (const f of explainer.formula_lines) {
+    console.log("    " + paint("accent", f));
+  }
+  if (bench) {
+    console.log();
+    console.log("  " + chalk16.dim(`Benchmark \xB7 ${bench}`));
+  }
+  if (explainer.dollar_label) {
+    console.log(
+      "  " + chalk16.dim(`Dollar translation \xB7 ${explainer.dollar_label}`)
+    );
+  }
+  console.log();
+  console.log(
+    "  " + chalk16.dim("More: ") + paint("accent", `/deepdive ${explainer.id}`) + chalk16.dim(" \xB7 full tour: ") + paint("accent", "/deepdive")
+  );
+  console.log();
+  recordMessage(ctx, "user", input);
+  recordMessage(
+    ctx,
+    "agent",
+    `${explainer.label}: ${explainer.tagline} (keyless definition)`
+  );
+  saveSessionState(ctx);
+  return true;
+}
+var POSSESSIVE_RE, DEFINITION_RE, MEAN_RE, HOW_CALC_RE, WHAT_IS_RE;
+var init_keyless_definitions = __esm({
+  "src/conversation/keyless-definitions.ts"() {
+    "use strict";
+    init_context2();
+    init_profile();
+    init_metric_definitions();
+    init_theme();
+    init_layout();
+    POSSESSIVE_RE = /\b(our|my|we|us|the company'?s|this (company|business|org|pipeline)|current|actual|latest)\b/i;
+    DEFINITION_RE = /^(?:(?:please|can you|could you)\s+)?(?:what\s+(?:is|are|does)|what'?s|whats|define|explain|describe|how\s+(?:is|are|do(?:es)?)\s+(?:.+?\s+)?(?:calculated|computed|measured|defined)|how\s+do(?:es)?\s+(?:.+?\s+)?(?:work|get calculated)|tell me about|meaning of)\b/i;
+    MEAN_RE = /\bwhat does\b(.+?)\bmean\b/i;
+    HOW_CALC_RE = /\bhow (?:is|are|do(?:es)?)\b(.+?)\b(?:calculated|computed|measured|defined|work)\b/i;
+    WHAT_IS_RE = /\b(?:what(?:'s|s)?|define|explain|describe|tell me about|meaning of)\s+(.+?)(?:\?|$)/i;
+  }
+});
+
 // src/conversation/orchestrator.ts
-import chalk15 from "chalk";
-import { writeFileSync as writeFileSync13 } from "fs";
-import { join as join19 } from "path";
+import chalk17 from "chalk";
+import { writeFileSync as writeFileSync14 } from "fs";
 async function handleExploreWithoutKey(ctx, input) {
+  if (isDefinitionAsk(input) && tryKeylessDefinitionAnswer(ctx, input)) {
+    return;
+  }
   if (isKeylessVitalsAsk(input)) {
     queuePendingAsk(ctx, input, "explore");
     const answered = await tryKeylessAskAnswer(ctx, input);
@@ -15522,14 +16798,14 @@ async function handleExploreWithoutKey(ctx, input) {
   }
   if (hits === 1) {
     console.log();
-    console.log("  " + chalk15.red("AI interpretation needs an LLM API key saved in config."));
+    console.log("  " + chalk17.red("AI interpretation needs an LLM API key saved in config."));
     console.log(
-      "  " + chalk15.dim("Run ") + paint("accent", "/connect") + chalk15.dim(" and paste any provider's key (Anthropic, OpenAI, Groq, Gemini, ...).")
+      "  " + chalk17.dim("Run ") + paint("accent", "/connect") + chalk17.dim(" and paste any provider's key (Anthropic, OpenAI, Groq, Gemini, ...).")
     );
-    console.log("  " + chalk15.dim("Number crunching works without a key \u2014 only Q&A in the REPL needs one."));
+    console.log("  " + chalk17.dim("Number crunching works without a key \u2014 only Q&A in the REPL needs one."));
     if (ctx.pendingAsk) {
       console.log(
-        "  " + chalk15.dim("Your question is queued \u2014 I'll answer it right after ") + paint("accent", "/connect") + chalk15.dim(".")
+        "  " + chalk17.dim("Your question is queued \u2014 I'll answer it right after ") + paint("accent", "/connect") + chalk17.dim(".")
       );
     }
     if (ctx.gapAudit) {
@@ -15544,16 +16820,17 @@ async function handleExploreWithoutKey(ctx, input) {
     return;
   }
   console.log();
-  console.log("  " + chalk15.yellow("Still no engine connected \u2014 Q&A stays offline until you run ") + paint("accent", "/connect") + chalk15.yellow("."));
-  console.log("  " + chalk15.dim("These work without one:"));
-  console.log("    " + paint("accent", "/playbook") + chalk15.dim("                    recommended plays from your computed vitals"));
-  console.log("    " + chalk15.cyan('"how should we fix this?"') + chalk15.dim("    deterministic skeleton plan"));
-  console.log("    " + paint("accent", "/handoff") + chalk15.dim("                     export this analysis for another tool"));
+  console.log("  " + chalk17.yellow("Still no engine connected \u2014 Q&A stays offline until you run ") + paint("accent", "/connect") + chalk17.yellow("."));
+  console.log("  " + chalk17.dim("These work without one:"));
+  console.log("    " + paint("accent", "/deepdive") + chalk17.dim("                   metric slides \u2014 what each number means"));
+  console.log("    " + paint("accent", "/playbook") + chalk17.dim("                    recommended plays from your computed vitals"));
+  console.log("    " + chalk17.cyan('"how should we fix this?"') + chalk17.dim("    deterministic skeleton plan"));
+  console.log("    " + paint("accent", "/handoff") + chalk17.dim("                     export this analysis for another tool"));
   console.log();
   recordMessage(
     ctx,
     "agent",
-    "No LLM engine connected \u2014 offered keyless paths (/playbook, skeleton plan, /handoff)."
+    "No LLM engine connected \u2014 offered keyless paths (/deepdive, /playbook, skeleton plan, /handoff)."
   );
 }
 var NO_KEY_NUDGES;
@@ -15561,7 +16838,7 @@ var init_orchestrator = __esm({
   "src/conversation/orchestrator.ts"() {
     "use strict";
     init_context2();
-    init_store();
+    init_exports_registry();
     init_theme();
     init_phase();
     init_scope();
@@ -15573,6 +16850,7 @@ var init_orchestrator = __esm({
     init_time_bank();
     init_pending_ask();
     init_keyless_ask();
+    init_keyless_definitions();
     NO_KEY_NUDGES = /* @__PURE__ */ Symbol.for("ntrp.noKeyNudges");
   }
 });
@@ -15738,8 +17016,8 @@ var init_bundle = __esm({
 });
 
 // src/repositories/markdown.ts
-import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync14 } from "fs";
-import { basename as basename3, dirname as dirname2, join as join20, resolve as resolve6 } from "path";
+import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync15 } from "fs";
+import { basename as basename4, dirname as dirname3, join as join20, resolve as resolve8 } from "path";
 import { stringify as stringifyYaml2 } from "yaml";
 function renderMarkdownFiles(pkg) {
   const bundleJson = JSON.stringify(pkg, null, 2) + "\n";
@@ -15926,10 +17204,10 @@ function renderStrategy(entry) {
   ].join("\n");
 }
 function getRootPath(target) {
-  return resolve6(target.directory ?? `ntrp-repository-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`);
+  return resolve8(target.directory ?? `ntrp-repository-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`);
 }
 function safeFilename(value) {
-  return (basename3(value).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "strategy") + ".md";
+  return (basename4(value).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "strategy") + ".md";
 }
 function escapeSummary(value) {
   return value.replace(/[<>]/g, "");
@@ -15942,7 +17220,7 @@ var init_markdown2 = __esm({
     markdownRepositoryAdapter = {
       kind: "markdown",
       describeTarget(target) {
-        return target.directory ? `local markdown folder ${resolve6(target.directory)}` : "local markdown folder";
+        return target.directory ? `local markdown folder ${resolve8(target.directory)}` : "local markdown folder";
       },
       planWrite(pkg) {
         const files = renderMarkdownFiles(pkg);
@@ -15959,12 +17237,12 @@ var init_markdown2 = __esm({
       write(pkg) {
         const root = getRootPath(pkg.target);
         const files = renderMarkdownFiles(pkg);
-        mkdirSync8(root, { recursive: true });
+        mkdirSync9(root, { recursive: true });
         const written = [];
         for (const file of files) {
           const absolutePath = join20(root, file.relativePath);
-          mkdirSync8(dirname2(absolutePath), { recursive: true });
-          writeFileSync14(absolutePath, file.contents, "utf-8");
+          mkdirSync9(dirname3(absolutePath), { recursive: true });
+          writeFileSync15(absolutePath, file.contents, "utf-8");
           written.push(absolutePath);
         }
         return {
@@ -16200,7 +17478,7 @@ var nl_exports = {};
 __export(nl_exports, {
   runNaturalLanguage: () => runNaturalLanguage
 });
-import chalk16 from "chalk";
+import chalk18 from "chalk";
 async function runNaturalLanguage(input, ctx) {
   if (isSmokeProtocolTrigger(input)) {
     recordMessage(ctx, "user", input);
@@ -16215,7 +17493,7 @@ async function runNaturalLanguage(input, ctx) {
       return extractSummary(result.answer);
     } catch (err) {
       spinner2.fail("Smoke protocol failed");
-      console.error("  " + chalk16.red(String(err.message ?? err)));
+      console.error("  " + chalk18.red(String(err.message ?? err)));
       console.log();
       return;
     }
@@ -16245,8 +17523,8 @@ async function runNaturalLanguage(input, ctx) {
       spinner2.succeed(metricsFirst ? "Session context ready" : "Health snapshot ready");
     } catch (err) {
       spinner2.fail("Could not compute health snapshot");
-      console.error("  " + chalk16.red(String(err.message ?? err)));
-      console.log("  " + chalk16.dim("Run ") + paint("accent", "/new") + chalk16.dim(" \u2192 pick Demo to load sample data."));
+      console.error("  " + chalk18.red(String(err.message ?? err)));
+      console.log("  " + chalk18.dim("Run ") + paint("accent", "/new") + chalk18.dim(" \u2192 pick Demo to load sample data."));
       console.log();
       return;
     }
@@ -16284,7 +17562,7 @@ async function runNaturalLanguage(input, ctx) {
           break;
         case "thinking":
           spinner.stop();
-          console.log("  " + chalk16.dim.italic(event.text));
+          console.log("  " + chalk18.dim.italic(event.text));
           spinner.start("Thinking\u2026");
           break;
         case "answer":
@@ -16304,7 +17582,7 @@ async function runNaturalLanguage(input, ctx) {
     }
   } catch (err) {
     spinner.fail("Error while investigating");
-    console.error("  " + chalk16.red(String(err.message ?? err)));
+    console.error("  " + chalk18.red(String(err.message ?? err)));
     console.log();
     return;
   } finally {
@@ -16314,7 +17592,7 @@ async function runNaturalLanguage(input, ctx) {
     ctx.conversation = distillThread(rawHistory);
   }
   if (!lastAnswer) {
-    console.log("  " + chalk16.dim("(no answer returned)"));
+    console.log("  " + chalk18.dim("(no answer returned)"));
   } else {
     recordMessage(ctx, "agent", lastAnswer);
     if (ctx.pendingAsk) {
@@ -16346,10 +17624,15 @@ function extractSummary(text) {
 function printFindingInline(finding) {
   const sev = finding.severity;
   console.log();
-  console.log("  " + severityPaint(sev)(`[${sev}]`) + " " + chalk16.bold(finding.segment));
+  console.log("  " + severityPaint(sev)(`[${sev}]`) + " " + chalk18.bold(finding.segment));
   printMarkdown(finding.finding, { indent: 2 });
   const play = finding.recommended_plays?.[0];
-  if (play) console.log("  " + chalk16.dim("\u2192 " + play.play_name + " \u2014 " + play.rationale));
+  if (play) console.log("  " + chalk18.dim("\u2192 " + play.play_name + " \u2014 " + play.rationale));
+  if (finding.recommended_focus) {
+    console.log(
+      "  " + chalk18.dim("How this works: ") + paint("accent", `/deepdive ${finding.recommended_focus}`)
+    );
+  }
 }
 var init_nl = __esm({
   "src/cli/nl.ts"() {
@@ -16383,12 +17666,12 @@ __export(demo_exports, {
   printDemoDisabled: () => printDemoDisabled,
   setDemoEnabled: () => setDemoEnabled
 });
-import chalk17 from "chalk";
+import chalk19 from "chalk";
 function printDemoDisabled() {
   console.log();
-  console.log("  " + chalk17.red(DEMO_DISABLED_MESSAGE));
+  console.log("  " + chalk19.red(DEMO_DISABLED_MESSAGE));
   console.log(
-    "  " + chalk17.dim("Re-enable with ") + paint("accent", "/config set demo-enabled true") + chalk17.dim(".")
+    "  " + chalk19.dim("Re-enable with ") + paint("accent", "/config set demo-enabled true") + chalk19.dim(".")
   );
   console.log();
 }
@@ -16430,7 +17713,7 @@ __export(pending_ask_exports, {
   queuePendingAsk: () => queuePendingAsk,
   resumePendingAsk: () => resumePendingAsk
 });
-import chalk18 from "chalk";
+import chalk20 from "chalk";
 function looksLikeQuestion(input) {
   const text = input.trim();
   if (!text) return false;
@@ -16466,7 +17749,7 @@ function printFocusChip(ctx) {
   const period = ctx.scope.time_horizon ? ` \xB7 ${ctx.scope.time_horizon}` : "";
   console.log();
   console.log(
-    "  " + chalk18.dim("Focus: ") + paint("accent", lens) + chalk18.dim(period) + chalk18.dim(" \u2014 type ") + chalk18.cyan("adjust") + chalk18.dim(" to change")
+    "  " + chalk20.dim("Focus: ") + paint("accent", lens) + chalk20.dim(period) + chalk20.dim(" \u2014 type ") + chalk20.cyan("adjust") + chalk20.dim(" to change")
   );
   console.log();
 }
@@ -16477,7 +17760,7 @@ async function resumePendingAsk(ctx) {
   if (canUseReplAi(ctx)) {
     console.log();
     console.log(
-      "  " + chalk18.dim(
+      "  " + chalk20.dim(
         pending.keylessAnswered ? "Picking up your question with the connected engine\u2026" : "Picking up your question\u2026"
       )
     );
@@ -16510,7 +17793,7 @@ async function offerDemoToAnswer(ctx) {
     const go = await prompts.confirm("Use demo data to answer this?", true);
     if (!go) {
       console.log(
-        "  " + chalk18.dim("Paste a CSV path when ready, or say ") + chalk18.cyan("use demo data") + chalk18.dim(".")
+        "  " + chalk20.dim("Paste a CSV path when ready, or say ") + chalk20.cyan("use demo data") + chalk20.dim(".")
       );
       console.log();
       return false;
@@ -16542,7 +17825,7 @@ __export(compute_exports2, {
   isComputeIntent: () => isComputeIntent,
   runConversationCompute: () => runConversationCompute
 });
-import chalk19 from "chalk";
+import chalk21 from "chalk";
 async function runConversationCompute(ctx) {
   const lens = ctx.scope?.primary_lens ?? ctx.analysis.primary;
   ctx.computeInProgress = true;
@@ -16597,7 +17880,7 @@ async function runConversationCompute(ctx) {
     creditGapCompute(ctx);
     return typeof summary === "string" ? summary : "Health analysis ready";
   } catch (err) {
-    console.error("  " + chalk19.red(String(err.message ?? err)));
+    console.error("  " + chalk21.red(String(err.message ?? err)));
     return;
   } finally {
     ctx.computeInProgress = false;
@@ -19366,18 +20649,18 @@ var init_generator = __esm({
 });
 
 // src/demo/taxonomy-cache.ts
-import { readFileSync as readFileSync17, writeFileSync as writeFileSync15, existsSync as existsSync18, mkdirSync as mkdirSync9, unlinkSync as unlinkSync3 } from "fs";
-import { homedir as homedir5 } from "os";
+import { readFileSync as readFileSync18, writeFileSync as writeFileSync16, existsSync as existsSync19, mkdirSync as mkdirSync10, unlinkSync as unlinkSync3 } from "fs";
+import { homedir as homedir6 } from "os";
 import { join as join22 } from "path";
 function ensureDir5() {
-  if (!existsSync18(NTRP_DIR4)) {
-    mkdirSync9(NTRP_DIR4, { recursive: true });
+  if (!existsSync19(NTRP_DIR4)) {
+    mkdirSync10(NTRP_DIR4, { recursive: true });
   }
 }
 function loadCachedTaxonomy(profile) {
-  if (!existsSync18(TAXONOMY_PATH)) return null;
+  if (!existsSync19(TAXONOMY_PATH)) return null;
   try {
-    const parsed = JSON.parse(readFileSync17(TAXONOMY_PATH, "utf-8"));
+    const parsed = JSON.parse(readFileSync18(TAXONOMY_PATH, "utf-8"));
     if (!parsed || typeof parsed !== "object") return null;
     if (parsed.profile_updated_at !== profile.updated_at) return null;
     return parsed;
@@ -19387,13 +20670,13 @@ function loadCachedTaxonomy(profile) {
 }
 function saveCachedTaxonomy(taxonomy) {
   ensureDir5();
-  writeFileSync15(TAXONOMY_PATH, JSON.stringify(taxonomy, null, 2) + "\n");
+  writeFileSync16(TAXONOMY_PATH, JSON.stringify(taxonomy, null, 2) + "\n");
 }
 var NTRP_DIR4, TAXONOMY_PATH;
 var init_taxonomy_cache = __esm({
   "src/demo/taxonomy-cache.ts"() {
     "use strict";
-    NTRP_DIR4 = join22(homedir5(), ".ntrp");
+    NTRP_DIR4 = join22(homedir6(), ".ntrp");
     TAXONOMY_PATH = join22(NTRP_DIR4, "demo-taxonomy.json");
   }
 });
@@ -19630,16 +20913,16 @@ var generate_exports = {};
 __export(generate_exports, {
   handler: () => handler2
 });
-import chalk20 from "chalk";
+import chalk22 from "chalk";
 async function handler2(args, ctx) {
   const { flags } = parseArgs(args, ["list-scenarios", "regen-taxonomy", "brief"]);
   const quiet = ctx.execution.quiet;
   const brief = getBool(flags, "brief");
   if (getBool(flags, "list-scenarios")) {
-    console.log(chalk20.bold("\n  Available Scenarios:\n"));
+    console.log(chalk22.bold("\n  Available Scenarios:\n"));
     for (const s of SCENARIO_LIST) {
-      console.log(`  ${chalk20.cyan(s.key.padEnd(20))} ${s.label}`);
-      console.log(`  ${chalk20.dim(" ".repeat(20))} ${s.description}
+      console.log(`  ${chalk22.cyan(s.key.padEnd(20))} ${s.label}`);
+      console.log(`  ${chalk22.dim(" ".repeat(20))} ${s.description}
 `);
     }
     return true;
@@ -19649,9 +20932,9 @@ async function handler2(args, ctx) {
   const skipProfile = getFalse(flags, "profile");
   if (!isProfileConfigured(profile) && !skipProfile) {
     console.error();
-    console.error("  " + chalk20.red("No company profile found."));
-    console.error("  " + chalk20.dim("Run ") + paint("accent", "/onboard") + chalk20.dim(" first for a richer demo,"));
-    console.error("  " + chalk20.dim("or pass ") + paint("accent", "--no-profile") + chalk20.dim(" to skip."));
+    console.error("  " + chalk22.red("No company profile found."));
+    console.error("  " + chalk22.dim("Run ") + paint("accent", "/onboard") + chalk22.dim(" first for a richer demo,"));
+    console.error("  " + chalk22.dim("or pass ") + paint("accent", "--no-profile") + chalk22.dim(" to skip."));
     console.error();
     markFailure(ctx);
     return false;
@@ -19659,8 +20942,8 @@ async function handler2(args, ctx) {
   const explicitScenario = getString(flags, "scenario", "s");
   const resolvedScenario = resolveScenarioInput(explicitScenario);
   if (resolvedScenario === null) {
-    console.error(chalk20.red(`  Unknown scenario: ${explicitScenario}`));
-    console.log(chalk20.dim(`  Valid: ${SCENARIO_LIST.map((s) => s.key).join(", ")}`));
+    console.error(chalk22.red(`  Unknown scenario: ${explicitScenario}`));
+    console.log(chalk22.dim(`  Valid: ${SCENARIO_LIST.map((s) => s.key).join(", ")}`));
     markFailure(ctx);
     return false;
   }
@@ -19674,10 +20957,10 @@ async function handler2(args, ctx) {
     const s = getScenario(scenario);
     console.log();
     if (brief) {
-      console.log("  " + paint("accent", "\u2713 Demo: ") + bold(s.label) + chalk20.dim(" \u2014 " + s.hook));
+      console.log("  " + paint("accent", "\u2713 Demo: ") + bold(s.label) + chalk22.dim(" \u2014 " + s.hook));
     } else {
       console.log("  " + paint("accent", "\u2713 Scenario: ") + bold(s.label));
-      console.log("  " + chalk20.dim(s.story));
+      console.log("  " + chalk22.dim(s.story));
       console.log();
     }
   }
@@ -19707,18 +20990,18 @@ async function handler2(args, ctx) {
         if (brief) {
           spinner.succeed(`Demo loaded \u2014 ${briefCounts(result.counts)}`);
         } else {
-          spinner.succeed(`Generated demo data for "${chalk20.cyan(scenario)}" scenario`);
+          spinner.succeed(`Generated demo data for "${chalk22.cyan(scenario)}" scenario`);
           console.log();
           printEntityCounts(result.counts);
         }
       }
       if (!quiet && !brief && ctx.analysis.primary !== "revenue_metrics") {
-        console.log(chalk20.dim("\n  Run /diagnose to compute vital signs.\n"));
+        console.log(chalk22.dim("\n  Run /diagnose to compute vital signs.\n"));
       }
     }
   } catch (err) {
     if (spinner) spinner.fail("Generation failed");
-    console.error(chalk20.red(String(err)));
+    console.error(chalk22.red(String(err)));
     markFailure(ctx);
     return false;
   }
@@ -19756,7 +21039,7 @@ async function loadOrBuildTaxonomy(profile, forceRegen, ctx) {
     return taxonomy;
   } catch (err) {
     spinner.fail("Couldn't build market taxonomy \u2014 using generic data pools");
-    console.log("  " + chalk20.dim(String(err.message ?? err)));
+    console.log("  " + chalk22.dim(String(err.message ?? err)));
     return void 0;
   }
 }
@@ -19847,9 +21130,9 @@ var ingest_exports = {};
 __export(ingest_exports, {
   handler: () => handler3
 });
-import chalk21 from "chalk";
-import { readFileSync as readFileSync18, existsSync as existsSync19 } from "fs";
-import { basename as basename4 } from "path";
+import chalk23 from "chalk";
+import { readFileSync as readFileSync19, existsSync as existsSync20 } from "fs";
+import { basename as basename5 } from "path";
 async function handler3(args, ctx) {
   const { positional, flags } = parseArgs(args, [
     "skip-resolve",
@@ -19868,21 +21151,21 @@ async function handler3(args, ctx) {
   const source = getString(flags, "source", "s") ?? "salesforce";
   const skipResolve = getBool(flags, "skip-resolve");
   if (!file) {
-    console.error(chalk21.red("  Usage: /ingest <file> [--source salesforce|hubspot|outreach]"));
-    console.error(chalk21.dim("         /ingest --demo [--scenario <name>]"));
+    console.error(chalk23.red("  Usage: /ingest <file> [--source salesforce|hubspot|outreach]"));
+    console.error(chalk23.dim("         /ingest --demo [--scenario <name>]"));
     process.exit(1);
   }
-  if (!existsSync19(file)) {
-    console.error(chalk21.red(`  File not found: ${file}`));
+  if (!existsSync20(file)) {
+    console.error(chalk23.red(`  File not found: ${file}`));
     process.exit(1);
   }
   const profile = loadProfile();
   const skipProfile = getFalse(flags, "profile");
   if (!profile && !skipProfile) {
     console.error();
-    console.error("  " + chalk21.red("No company profile found."));
-    console.error("  " + chalk21.dim("Run ") + paint("accent", "/onboard") + chalk21.dim(" first for better column mapping,"));
-    console.error("  " + chalk21.dim("or pass ") + paint("accent", "--no-profile") + chalk21.dim(" to skip."));
+    console.error("  " + chalk23.red("No company profile found."));
+    console.error("  " + chalk23.dim("Run ") + paint("accent", "/onboard") + chalk23.dim(" first for better column mapping,"));
+    console.error("  " + chalk23.dim("or pass ") + paint("accent", "--no-profile") + chalk23.dim(" to skip."));
     console.error();
     process.exit(1);
   }
@@ -19890,7 +21173,7 @@ async function handler3(args, ctx) {
   try {
     await initSchema();
     spinner.text = "Parsing CSV\u2026";
-    const content = readFileSync18(file, "utf-8");
+    const content = readFileSync19(file, "utf-8");
     const { rows, headers } = parseCSV(content);
     if (rows.length === 0) {
       spinner.fail("CSV is empty");
@@ -19902,7 +21185,7 @@ async function handler3(args, ctx) {
       const { importRevenueRows: importRevenueRows2 } = await Promise.resolve().then(() => (init_revenue_importer(), revenue_importer_exports));
       const uploadId2 = await insertCSVUpload({
         source_system: source,
-        original_filename: basename4(file),
+        original_filename: basename5(file),
         row_count: rows.length,
         column_mappings: { entity_type: "revenue_ledger" },
         status: "processing"
@@ -19914,28 +21197,28 @@ async function handler3(args, ctx) {
         row_count: result2.imported
       });
       spinner.succeed(
-        `Imported ${chalk21.bold(result2.imported.toString())} revenue events from ${chalk21.dim(basename4(file))}`
+        `Imported ${chalk23.bold(result2.imported.toString())} revenue events from ${chalk23.dim(basename5(file))}`
       );
       if (result2.errors.length > 0) {
-        console.log(chalk21.yellow(`  ${result2.errors.length} rows skipped`));
+        console.log(chalk23.yellow(`  ${result2.errors.length} rows skipped`));
       }
       if (ctx.analysis) {
         ctx.analysis.data_source_type = "revenue_ledger";
       }
-      console.log(chalk21.dim("  Run ") + chalk21.cyan("/metrics") + chalk21.dim(" for SaaS metrics with ledger-backed retention."));
-      return `${result2.imported} revenue events from ${basename4(file)}`;
+      console.log(chalk23.dim("  Run ") + chalk23.cyan("/metrics") + chalk23.dim(" for SaaS metrics with ledger-backed retention."));
+      return `${result2.imported} revenue events from ${basename5(file)}`;
     }
     spinner.text = "Detecting entity type\u2026";
     const detection = detectEntityType(headers, source);
     if (!detection) {
       spinner.fail(`Could not auto-detect entity type for source: ${source}`);
-      console.log(chalk21.dim("  Headers found: " + headers.join(", ")));
+      console.log(chalk23.dim("  Headers found: " + headers.join(", ")));
       process.exit(1);
     }
     spinner.text = `Importing ${rows.length} ${detection.entityType} rows...`;
     const uploadId = await insertCSVUpload({
       source_system: source,
-      original_filename: basename4(file),
+      original_filename: basename5(file),
       row_count: rows.length,
       column_mappings: detection.mappings,
       status: "processing"
@@ -19952,15 +21235,15 @@ async function handler3(args, ctx) {
       row_count: result.imported
     });
     spinner.succeed(
-      `Imported ${chalk21.bold(result.imported.toString())} ${detection.entityType} from ${chalk21.dim(basename4(file))} (${source})`
+      `Imported ${chalk23.bold(result.imported.toString())} ${detection.entityType} from ${chalk23.dim(basename5(file))} (${source})`
     );
     if (result.errors.length > 0) {
-      console.log(chalk21.yellow(`  ${result.errors.length} rows skipped`));
+      console.log(chalk23.yellow(`  ${result.errors.length} rows skipped`));
       for (const err of result.errors.slice(0, 3)) {
-        console.log(chalk21.dim(`    - ${err}`));
+        console.log(chalk23.dim(`    - ${err}`));
       }
       if (result.errors.length > 3) {
-        console.log(chalk21.dim(`    ... and ${result.errors.length - 3} more`));
+        console.log(chalk23.dim(`    ... and ${result.errors.length - 3} more`));
       }
     }
     if (!skipResolve) {
@@ -19974,10 +21257,10 @@ async function handler3(args, ctx) {
         resolveSpinner.succeed("No duplicates found");
       }
     }
-    return `${result.imported} ${detection.entityType} from ${basename4(file)}`;
+    return `${result.imported} ${detection.entityType} from ${basename5(file)}`;
   } catch (err) {
     spinner.fail("Import failed");
-    console.error(chalk21.red(String(err)));
+    console.error(chalk23.red(String(err)));
     process.exit(1);
   }
 }
@@ -20007,10 +21290,10 @@ __export(ingest_chat_exports, {
   loadDemoFromChat: () => loadDemoFromChat,
   looksLikeFilePath: () => looksLikeFilePath
 });
-import { existsSync as existsSync20 } from "fs";
-import { basename as basename5, resolve as resolve7 } from "path";
-import { homedir as homedir6 } from "os";
-import chalk22 from "chalk";
+import { existsSync as existsSync21 } from "fs";
+import { basename as basename6, resolve as resolve9 } from "path";
+import { homedir as homedir7 } from "os";
+import chalk24 from "chalk";
 function extractFilePath(input) {
   const trimmed = input.trim();
   const patterns = [
@@ -20027,33 +21310,33 @@ function extractFilePath(input) {
     const m = trimmed.match(re);
     if (m?.[1]) {
       const p = expandPath(m[1]);
-      if (existsSync20(p)) return p;
+      if (existsSync21(p)) return p;
     }
     if (!m?.[1] && re.test(trimmed) && trimmed.toLowerCase().endsWith(".csv")) {
       const p = expandPath(trimmed.replace(/^["']|["']$/g, ""));
-      if (existsSync20(p)) return p;
+      if (existsSync21(p)) return p;
     }
   }
   return null;
 }
 function expandPath(p) {
-  if (p.startsWith("~/")) return resolve7(homedir6(), p.slice(2));
-  return resolve7(p);
+  if (p.startsWith("~/")) return resolve9(homedir7(), p.slice(2));
+  return resolve9(p);
 }
 function looksLikeFilePath(input) {
   return extractFilePath(input) !== null;
 }
 async function ingestFromChat(ctx, filePath) {
   if (!ctx.rl) {
-    console.log("  " + chalk22.red("Ingest confirm requires interactive mode."));
+    console.log("  " + chalk24.red("Ingest confirm requires interactive mode."));
     return false;
   }
-  const name = basename5(filePath);
+  const name = basename6(filePath);
   const prompts = createPromptSession(ctx.rl, ctx);
   try {
     const ok = await prompts.confirm(`Ingest ${name} as CRM export?`, true);
     if (!ok) {
-      console.log("  " + chalk22.dim("Ingest cancelled."));
+      console.log("  " + chalk24.dim("Ingest cancelled."));
       return false;
     }
   } finally {
@@ -20061,12 +21344,12 @@ async function ingestFromChat(ctx, filePath) {
   }
   const { handler: ingest } = await Promise.resolve().then(() => (init_ingest(), ingest_exports));
   const { detectEntityType: detectEntityType2 } = await Promise.resolve().then(() => (init_csv_detect(), csv_detect_exports));
-  const { readFileSync: readFileSync21 } = await import("fs");
+  const { readFileSync: readFileSync22 } = await import("fs");
   const { parseCSV: parseCSV2 } = await Promise.resolve().then(() => (init_csv_parse(), csv_parse_exports));
   const { getStoredApiKey } = await Promise.resolve().then(() => (init_repl_api(), repl_api_exports));
   let headerCheckFailed = false;
   try {
-    const raw = readFileSync21(filePath, "utf-8");
+    const raw = readFileSync22(filePath, "utf-8");
     const { headers } = parseCSV2(raw);
     const detected = detectEntityType2(headers, "unknown");
     if (!detected) headerCheckFailed = true;
@@ -20081,7 +21364,7 @@ async function ingestFromChat(ctx, filePath) {
         false
       );
       if (useAi) {
-        console.log("  " + chalk22.dim("AI column mapping is not wired to ingest yet \u2014 trying standard ingest."));
+        console.log("  " + chalk24.dim("AI column mapping is not wired to ingest yet \u2014 trying standard ingest."));
       }
     } finally {
       prompts2.close();
@@ -20108,7 +21391,7 @@ async function ingestFromChat(ctx, filePath) {
   invalidateGapAudit(ctx);
   saveSessionState(ctx);
   console.log();
-  console.log("  " + paint("accent", "\u2713 Data loaded") + chalk22.dim(` \u2014 ${name}`));
+  console.log("  " + paint("accent", "\u2713 Data loaded") + chalk24.dim(` \u2014 ${name}`));
   recordMessage(ctx, "user", `[ingested ${name}]`);
   recordMessage(ctx, "agent", `Loaded ${name}. Checking what we can analyze\u2026`);
   const audit = await refreshGapAudit(ctx);
@@ -20116,7 +21399,7 @@ async function ingestFromChat(ctx, filePath) {
   if (audit.can_compute && ctx.scope?.confirmed_at) {
     if (ctx.pendingAsk) {
       console.log();
-      console.log("  " + chalk22.dim("Computing so I can answer\u2026"));
+      console.log("  " + chalk24.dim("Computing so I can answer\u2026"));
       await runConversationCompute(ctx);
       return true;
     }
@@ -20178,7 +21461,7 @@ async function loadDemoFromChat(ctx, scenario, opts = {}) {
   const shouldAuto = opts.autoCompute || Boolean(ctx.pendingAsk && audit.can_compute && ctx.scope?.confirmed_at);
   if (shouldAuto && audit.can_compute) {
     console.log();
-    console.log("  " + chalk22.dim("Computing so I can answer\u2026"));
+    console.log("  " + chalk24.dim("Computing so I can answer\u2026"));
     await runConversationCompute(ctx);
     return true;
   }
@@ -20667,9 +21950,9 @@ async function handleGetSessionBrief(input) {
   if (!target) {
     return { error: `No session matching "${raw}".` };
   }
-  const { existsSync: existsSync23, readFileSync: readFileSync21 } = await import("fs");
+  const { existsSync: existsSync24, readFileSync: readFileSync22 } = await import("fs");
   const briefPath = contextDocPathForSession2(target.id);
-  if (!existsSync23(briefPath)) {
+  if (!existsSync24(briefPath)) {
     return {
       session_id: target.id,
       error: "No context brief on disk for this session (created before brief storage existed).",
@@ -20677,7 +21960,7 @@ async function handleGetSessionBrief(input) {
       stage: target.stage ?? null
     };
   }
-  return { session_id: target.id, brief: readFileSync21(briefPath, "utf-8") };
+  return { session_id: target.id, brief: readFileSync22(briefPath, "utf-8") };
 }
 function auditDenied(name, input, resultJson, start) {
   logToolCall({
@@ -21659,15 +22942,15 @@ var init_verify = __esm({
 });
 
 // src/services/setup.ts
-import { existsSync as existsSync21, mkdirSync as mkdirSync10, readFileSync as readFileSync19, writeFileSync as writeFileSync16 } from "fs";
+import { existsSync as existsSync22, mkdirSync as mkdirSync11, readFileSync as readFileSync20, writeFileSync as writeFileSync17 } from "fs";
 import { join as join23 } from "path";
 function setupCheck() {
   const home = ntrpHome();
   let writable = false;
   try {
-    mkdirSync10(home, { recursive: true });
+    mkdirSync11(home, { recursive: true });
     const probe = join23(home, ".write-check");
-    writeFileSync16(probe, "ok\n");
+    writeFileSync17(probe, "ok\n");
     writable = true;
   } catch {
     writable = false;
@@ -21685,6 +22968,7 @@ function setupCheck() {
       api_key_env_hint: hasEnvApiKeyHint(),
       default_format: getConfigValue("default-format"),
       export_dir: getConfigValue("export-dir"),
+      ai_inbox_dir: getConfigValue("ai-inbox-dir"),
       llm: {
         configured: hasAnyLlmProvider(),
         primary: llmCfg.primary,
@@ -21717,17 +23001,17 @@ var init_setup = __esm({
 });
 
 // src/version.ts
-import { existsSync as existsSync22, readFileSync as readFileSync20 } from "fs";
-import { dirname as dirname3, join as join24 } from "path";
+import { existsSync as existsSync23, readFileSync as readFileSync21 } from "fs";
+import { dirname as dirname4, join as join24 } from "path";
 import { fileURLToPath } from "url";
 function getInstalledVersion() {
   if (cachedVersion) return cachedVersion;
-  const start = dirname3(fileURLToPath(import.meta.url));
+  const start = dirname4(fileURLToPath(import.meta.url));
   for (const rel of ["../package.json", "../../package.json"]) {
     const path = join24(start, rel);
-    if (!existsSync22(path)) continue;
+    if (!existsSync23(path)) continue;
     try {
-      const pkg = JSON.parse(readFileSync20(path, "utf-8"));
+      const pkg = JSON.parse(readFileSync21(path, "utf-8"));
       if (typeof pkg.version === "string" && pkg.version.length > 0) {
         cachedVersion = pkg.version;
         return cachedVersion;