@sonnechasser/ntrp 0.1.4 → 0.1.7

package/dist/investigation/verbosity-cli.js

@@ -1268,6 +1268,1168 @@ 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, writeFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { homedir } from "os";
+import { join as join2, resolve as resolve2 } from "path";
+function ntrpHome() {
+  return NTRP_DIR2;
+}
+function ensureDir2() {
+  if (!existsSync2(NTRP_DIR2)) {
+    mkdirSync2(NTRP_DIR2, { recursive: true });
+  }
+}
+function loadConfig() {
+  if (cachedConfig) return cachedConfig;
+  ensureDir2();
+  if (!existsSync2(CONFIG_PATH)) {
+    cachedConfig = {};
+    return cachedConfig;
+  }
+  try {
+    cachedConfig = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+  } catch {
+    cachedConfig = {};
+  }
+  return cachedConfig;
+}
+function saveConfig(config) {
+  ensureDir2();
+  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 = resolve2(config["export-dir"] ?? join2(NTRP_DIR2, "exports"));
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  return dir;
+}
+function getStrategiesDir() {
+  const dir = join2(NTRP_DIR2, "strategies");
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+    writeFileSync(join2(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 = join2(NTRP_DIR2, "memory");
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  return dir;
+}
+function getKnowledgeDir() {
+  const dir = join2(NTRP_DIR2, "knowledge");
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+    writeFileSync(join2(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 = join2(NTRP_DIR2, "wins");
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+    writeFileSync(join2(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) : join2(homedir(), ".ntrp");
+    CONFIG_PATH = join2(NTRP_DIR2, "config.json");
+    cachedConfig = null;
+  }
+});
+
+// src/config/install.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
+function installPath() {
+  return join3(ntrpHome(), "install.json");
+}
+function ensureDir3() {
+  const dir = ntrpHome();
+  if (!existsSync3(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 (existsSync3(path)) {
+    try {
+      const parsed = JSON.parse(readFileSync2(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();
+  writeFileSync2(path, JSON.stringify(record, null, 2) + "\n");
+  cachedInstall = record;
+  return record;
+}
+function getInstallId() {
+  return ensureInstall().install_id;
+}
+var cachedInstall;
+var init_install = __esm({
+  "src/config/install.ts"() {
+    "use strict";
+    init_store();
+    cachedInstall = null;
+  }
+});
+
+// src/config/progress-migrate.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3, renameSync, writeFileSync as writeFileSync3 } from "fs";
+import { join as join4 } from "path";
+function legacyStatePath() {
+  return join4(ntrpHome(), "state.json");
+}
+function legacyStateBackupPath() {
+  return join4(ntrpHome(), "state.json.bak");
+}
+function progressPath() {
+  return join4(ntrpHome(), "progress.json");
+}
+function isValidLegacyState(value) {
+  if (!value || typeof value !== "object") return false;
+  const s = 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 (existsSync4(progressPath())) return null;
+  const legacyPath = legacyStatePath();
+  if (!existsSync4(legacyPath)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync3(legacyPath, "utf-8"));
+    if (!isValidLegacyState(parsed)) return null;
+    const { schema_version: _v, ...rest } = parsed;
+    const progress = {
+      ...rest,
+      schema_version: 2,
+      install_id: installId
+    };
+    writeFileSync3(progressPath(), JSON.stringify(progress, null, 2) + "\n");
+    try {
+      renameSync(legacyPath, legacyStateBackupPath());
+    } catch {
+    }
+    return progress;
+  } catch {
+    return null;
+  }
+}
+var init_progress_migrate = __esm({
+  "src/config/progress-migrate.ts"() {
+    "use strict";
+    init_store();
+  }
+});
+
+// src/whimsy/usage-backfill.ts
+function isoWeekKey(d) {
+  const date = new Date(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()));
+  const day = date.getUTCDay() || 7;
+  date.setUTCDate(date.getUTCDate() + 4 - day);
+  const yearStart = new Date(Date.UTC(date.getUTCFullYear(), 0, 1));
+  const weekNo = Math.ceil(((date.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+  return `${date.getUTCFullYear()}-W${String(weekNo).padStart(2, "0")}`;
+}
+function actionBase(action) {
+  return action.split(":")[0] ?? action;
+}
+function bumpWeekly(weekly, week, patch) {
+  const idx = weekly.findIndex((w) => w.week === week);
+  const row = idx >= 0 ? { ...weekly[idx] } : { week, minutes_saved: 0, llm_calls: 0, actions: 0 };
+  if (patch.minutes_saved) row.minutes_saved += patch.minutes_saved;
+  if (patch.actions) row.actions += patch.actions;
+  return idx >= 0 ? weekly.map((w, i) => i === idx ? row : w) : [...weekly, row];
+}
+function rebuildFromCredits(credits) {
+  let diagnoses = 0;
+  let metrics_runs = 0;
+  let deliverables = 0;
+  let nl_exchanges = 0;
+  let weekly = [];
+  let first_active_at;
+  let last_active_at;
+  for (const credit of credits) {
+    if (!first_active_at || credit.at < first_active_at) first_active_at = credit.at;
+    if (!last_active_at || credit.at > last_active_at) last_active_at = credit.at;
+    const base = actionBase(credit.action);
+    if (base === "diagnose" || base === "diagnose_findings") diagnoses++;
+    if (base === "metrics" || base === "metrics_findings") metrics_runs++;
+    if (base === "deliverable" || base === "deliverable_deck") deliverables++;
+    if (base === "nl_answer") nl_exchanges++;
+    const week = isoWeekKey(new Date(credit.at));
+    weekly = bumpWeekly(weekly, week, { minutes_saved: credit.minutes, actions: 1 });
+  }
+  return {
+    first_active_at,
+    last_active_at,
+    diagnoses,
+    metrics_runs,
+    deliverables,
+    nl_exchanges,
+    weekly
+  };
+}
+function mergeWeekly(existing, fromCredits) {
+  const byWeek = /* @__PURE__ */ new Map();
+  for (const row of fromCredits) {
+    byWeek.set(row.week, { ...row });
+  }
+  for (const row of existing) {
+    const prior = byWeek.get(row.week);
+    if (prior) {
+      byWeek.set(row.week, {
+        week: row.week,
+        minutes_saved: Math.max(prior.minutes_saved, row.minutes_saved),
+        actions: Math.max(prior.actions, row.actions),
+        llm_calls: row.llm_calls
+      });
+    } else {
+      byWeek.set(row.week, { ...row });
+    }
+  }
+  return [...byWeek.values()].sort((a, b) => a.week.localeCompare(b.week));
+}
+function migrateUsageIfNeeded(state) {
+  if (state.credits.length === 0) return { state, changed: false };
+  if (state.usage?.first_active_at) return { state, changed: false };
+  const fromCredits = rebuildFromCredits(state.credits);
+  const prior = state.usage;
+  const usage = {
+    sessions_closed: prior?.sessions_closed ?? 0,
+    llm_calls: prior?.llm_calls ?? 0,
+    input_tokens: prior?.input_tokens ?? 0,
+    output_tokens: prior?.output_tokens ?? 0,
+    ...fromCredits,
+    weekly: mergeWeekly(prior?.weekly ?? [], fromCredits.weekly)
+  };
+  return { state: { ...state, usage }, changed: true };
+}
+var init_usage_backfill = __esm({
+  "src/whimsy/usage-backfill.ts"() {
+    "use strict";
+  }
+});
+
+// src/config/progress.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "fs";
+import { join as join5 } from "path";
+function progressPath2() {
+  return join5(ntrpHome(), "progress.json");
+}
+function ensureDir4() {
+  const dir = ntrpHome();
+  if (!existsSync5(dir)) {
+    mkdirSync4(dir, { recursive: true });
+  }
+}
+function emptyProgress(installId) {
+  return {
+    schema_version: 2,
+    install_id: installId,
+    total_minutes_saved: 0,
+    credits: [],
+    milestones_unlocked: []
+  };
+}
+function isValidProgress(value) {
+  if (!value || typeof value !== "object") return false;
+  const s = value;
+  return s.schema_version === 2 && typeof s.install_id === "string" && typeof s.total_minutes_saved === "number" && Array.isArray(s.credits) && Array.isArray(s.milestones_unlocked);
+}
+function reconcileInstallId(state) {
+  const localId = getInstallId();
+  if (state.install_id === localId) return { state, changed: false };
+  if (!installMismatchWarned) {
+    installMismatchWarned = true;
+    console.warn(
+      "  progress.json install_id did not match this machine \u2014 rebound to local install."
+    );
+  }
+  return { state: { ...state, install_id: localId }, changed: true };
+}
+function readProgressFile() {
+  const path = progressPath2();
+  if (!existsSync5(path)) return { state: null, changed: false };
+  try {
+    const parsed = JSON.parse(readFileSync4(path, "utf-8"));
+    if (!isValidProgress(parsed)) return { state: null, changed: false };
+    return reconcileInstallId(parsed);
+  } catch {
+    return { state: null, changed: false };
+  }
+}
+function loadProgress() {
+  ensureInstall();
+  const installId = getInstallId();
+  let state = null;
+  let changed = false;
+  const fromFile = readProgressFile();
+  if (fromFile.state) {
+    state = fromFile.state;
+    changed = fromFile.changed;
+  }
+  if (!state) {
+    const migrated2 = migrateLegacyStateIfNeeded(installId);
+    if (migrated2) {
+      state = migrated2;
+      changed = true;
+    }
+  }
+  if (!state) {
+    state = emptyProgress(installId);
+    changed = true;
+  }
+  const { state: usageMigrated, changed: usageChanged } = migrateUsageIfNeeded(state);
+  state = usageMigrated;
+  if (usageChanged) changed = true;
+  if (changed) saveProgress(state);
+  return state;
+}
+function saveProgress(state) {
+  ensureDir4();
+  const next = {
+    ...state,
+    schema_version: 2,
+    install_id: getInstallId()
+  };
+  writeFileSync4(progressPath2(), JSON.stringify(next, null, 2) + "\n");
+}
+function appendCredit(state, credit) {
+  const credits = [...state.credits, credit];
+  if (credits.length > CREDIT_HISTORY_CAP) {
+    credits.splice(0, credits.length - CREDIT_HISTORY_CAP);
+  }
+  return {
+    ...state,
+    total_minutes_saved: state.total_minutes_saved + credit.minutes,
+    credits
+  };
+}
+function hasCreditAction(state, action) {
+  return state.credits.some((c) => c.action === action);
+}
+var CREDIT_HISTORY_CAP, installMismatchWarned;
+var init_progress = __esm({
+  "src/config/progress.ts"() {
+    "use strict";
+    init_install();
+    init_progress_migrate();
+    init_store();
+    init_usage_backfill();
+    CREDIT_HISTORY_CAP = 100;
+    installMismatchWarned = false;
+  }
+});
+
+// src/ui/theme.ts
+import chalk from "chalk";
+function paint(token, text) {
+  if (token === "dim") return chalk.dim(text);
+  return chalk.hex(TOKENS[token])(text);
+}
+function bold(text) {
+  return chalk.bold(text);
+}
+function badge(label, tone = "muted") {
+  const normalized = ` ${label.toUpperCase()} `;
+  switch (tone) {
+    case "success":
+      return chalk.hex(TOKENS.success)(normalized);
+    case "warning":
+      return chalk.hex(TOKENS.warning)(normalized);
+    case "error":
+      return chalk.hex(TOKENS.error)(normalized);
+    case "info":
+      return chalk.hex(TOKENS.info)(normalized);
+    case "accent":
+      return chalk.hex(TOKENS.accent)(normalized);
+    case "muted":
+      return chalk.dim(normalized);
+  }
+}
+function sectionHeading(label) {
+  return `${paint("accent", "\u25B8")} ${paint("accent", bold(label))}`;
+}
+function actionHint(label, command, detail) {
+  const suffix = detail ? chalk.dim(` ${detail}`) : "";
+  return `${chalk.dim(label)} ${paint("accent", command)}${suffix}`;
+}
+function scoreBar(score, status, width = 14) {
+  const filled = Math.round(score / 100 * width);
+  const color = chalk.hex(STATUS_COLORS[status]);
+  let filledPart = "";
+  for (let i = 0; i < filled; i++) {
+    filledPart += i % 2 === 0 ? "\u2588" : "\u2593";
+  }
+  const emptyPart = "\u2591".repeat(width - filled);
+  return color(filledPart) + chalk.dim(emptyPart);
+}
+var STATUS_COLORS, TOKENS;
+var init_theme = __esm({
+  "src/ui/theme.ts"() {
+    "use strict";
+    init_formatters();
+    STATUS_COLORS = {
+      green: "#22c55e",
+      yellow: "#eab308",
+      red: "#ef4444"
+    };
+    TOKENS = {
+      accent: "#14b8a6",
+      accentBright: "#2dd4bf",
+      border: "#334155",
+      borderMuted: "#1e293b",
+      dim: "#64748b",
+      text: "#e2e8f0",
+      error: "#ef4444",
+      warning: "#eab308",
+      success: "#22c55e",
+      info: "#3b82f6"
+    };
+  }
+});
+
+// src/whimsy/time-milestones.ts
+function getMilestoneById(id) {
+  return TIME_MILESTONES.find((m) => m.id === id);
+}
+function nextMilestone(totalHours, unlocked) {
+  for (const m of TIME_MILESTONES) {
+    if (!unlocked.includes(m.id) && totalHours < m.hours) {
+      return m;
+    }
+  }
+  return null;
+}
+function newlyUnlockedMilestones(previousMinutes, newMinutes, unlocked) {
+  const prevHours = previousMinutes / 60;
+  const newHours = newMinutes / 60;
+  return TIME_MILESTONES.filter(
+    (m) => !unlocked.includes(m.id) && newHours >= m.hours && prevHours < m.hours
+  );
+}
+var TIME_MILESTONES;
+var init_time_milestones = __esm({
+  "src/whimsy/time-milestones.ts"() {
+    "use strict";
+    TIME_MILESTONES = [
+      {
+        id: "first_hour",
+        hours: 1,
+        title: "First hour back",
+        message: "First hour back. That's one pipeline standup you didn't have to sit through."
+      },
+      {
+        id: "half_day",
+        hours: 4,
+        title: "Half day",
+        message: "4 hours saved \u2014 a half-day an analyst would've billed you for."
+      },
+      {
+        id: "analyst_day",
+        hours: 8,
+        title: "Analyst day",
+        message: "A full analyst day, reclaimed."
+      },
+      {
+        id: "long_weekend",
+        hours: 24,
+        title: "Three days",
+        message: "Three analyst days. You could've been in spreadsheets."
+      },
+      {
+        id: "analyst_week",
+        hours: 40,
+        title: "Analyst week",
+        message: "A week of analyst time. Your calendar thanks you."
+      },
+      {
+        id: "analyst_fortnight",
+        hours: 80,
+        title: "Two weeks",
+        message: "Two weeks of manual pipeline archaeology \u2014 skipped."
+      },
+      {
+        id: "analyst_month",
+        hours: 160,
+        title: "Analyst month",
+        message: "A month of analyst hours. That's a hiring conversation you didn't need."
+      },
+      {
+        id: "quarter_fte",
+        hours: 500,
+        title: "Quarter FTE",
+        message: "500 hours. That's a quarter of a full-time analyst year."
+      },
+      {
+        id: "two_quarters",
+        hours: 600,
+        title: "Two quarters",
+        message: "600 hours \u2014 half a fiscal year of analyst time, back in your calendar."
+      },
+      {
+        id: "nine_months",
+        hours: 720,
+        title: "Nine months",
+        message: "720 hours. Three quarters of a year \u2014 most teams never get this much outside help."
+      },
+      {
+        id: "eleven_months",
+        hours: 840,
+        title: "Eleven months",
+        message: "840 hours saved. You're one month shy of a full annual arc."
+      },
+      {
+        id: "annual_arc",
+        hours: 960,
+        title: "Annual arc",
+        message: "960 hours \u2014 a year of normal use, banked. The subscription paid for itself."
+      },
+      {
+        id: "subscription_year",
+        hours: 1100,
+        title: "Subscription year",
+        message: "1,100 hours. A full year plus wiggle room \u2014 even power users rarely climb higher."
+      }
+    ];
+  }
+});
+
+// src/whimsy/time-perspectives.ts
+function getPerspectiveById(id) {
+  return TIME_PERSPECTIVES.find((p) => p.id === id);
+}
+function ratioInBand(perspective, totalHours) {
+  const ratio = totalHours / perspective.reference_hours;
+  const min = perspective.min_ratio ?? 0.3;
+  const max = perspective.max_ratio ?? 300;
+  return ratio >= min && ratio <= max;
+}
+function pickPerspective(totalHours, options = {}) {
+  if (totalHours <= 0) return null;
+  const exclude = new Set(options.excludeIds ?? []);
+  let candidates = TIME_PERSPECTIVES.filter((p) => !exclude.has(p.id) && ratioInBand(p, totalHours));
+  if (candidates.length === 0) {
+    candidates = TIME_PERSPECTIVES.filter((p) => !exclude.has(p.id));
+  }
+  if (candidates.length === 0) return TIME_PERSPECTIVES[0] ?? null;
+  const otherCategories = candidates.filter((p) => p.category !== options.lastCategory);
+  const pool = otherCategories.length > 0 ? otherCategories : candidates;
+  const seed = options.seed ?? Date.now();
+  return pool[Math.abs(seed) % pool.length] ?? null;
+}
+function formatRatio(ratio) {
+  if (ratio >= 100) return Math.round(ratio).toString();
+  if (ratio >= 10) return ratio.toFixed(0);
+  if (ratio >= 1) return ratio.toFixed(1);
+  return ratio.toFixed(2);
+}
+function formatPct(pct) {
+  if (pct >= 10) return Math.round(pct).toString();
+  if (pct >= 1) return pct.toFixed(1);
+  return pct.toFixed(2);
+}
+function formatPerspectiveLine(perspective, totalHours) {
+  const ratio = totalHours / perspective.reference_hours;
+  const pct = ratio * 100;
+  return perspective.template.replace("{ratio}", formatRatio(ratio)).replace("{pct}", formatPct(pct)).replace("{label}", perspective.label);
+}
+var TIME_PERSPECTIVES;
+var init_time_perspectives = __esm({
+  "src/whimsy/time-perspectives.ts"() {
+    "use strict";
+    TIME_PERSPECTIVES = [
+      { id: "dsotm", category: "music", reference_hours: 0.74, label: "Dark Side of the Moon", template: "\u2248 {ratio}\xD7 through {label}", min_ratio: 1, max_ratio: 200 },
+      { id: "rush_2112", category: "music", reference_hours: 0.33, label: "2112", template: "\u2248 {ratio}\xD7 through {label}", min_ratio: 2, max_ratio: 200 },
+      { id: "bohemian_rhapsody", category: "music", reference_hours: 0.1, label: "Bohemian Rhapsody", template: "\u2248 {ratio}\xD7 through {label}", min_ratio: 5, max_ratio: 500 },
+      { id: "stairway", category: "music", reference_hours: 0.13, label: "Stairway to Heaven", template: "\u2248 {ratio}\xD7 through {label}", min_ratio: 5, max_ratio: 400 },
+      { id: "podcast_binge", category: "music", reference_hours: 0.75, label: "hour-long podcast episodes", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 2, max_ratio: 300 },
+      { id: "abbey_road", category: "music", reference_hours: 0.8, label: "Abbey Road", template: "\u2248 {ratio}\xD7 through {label}", min_ratio: 1, max_ratio: 200 },
+      { id: "iron_maiden_set", category: "music", reference_hours: 2, label: "an Iron Maiden marathon set", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.5, max_ratio: 50 },
+      { id: "festival_set", category: "music", reference_hours: 1.5, label: "main-stage festival sets", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 1, max_ratio: 100 },
+      { id: "jazz_club", category: "music", reference_hours: 3, label: "late-night jazz sets", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.5, max_ratio: 80 },
+      { id: "ring_cycle", category: "music", reference_hours: 15, label: "Wagner's Ring Cycle", template: "\u2248 {pct}% of {label}", min_ratio: 0.1, max_ratio: 2 },
+      { id: "shrek", category: "film", reference_hours: 1.5, label: "Shrek (the first one)", template: "\u2248 {ratio}\xD7 watching {label}", min_ratio: 1, max_ratio: 150 },
+      { id: "blockbuster", category: "film", reference_hours: 2.1, label: "average blockbusters", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 1, max_ratio: 100 },
+      { id: "dune_two", category: "film", reference_hours: 2.75, label: "Dune: Part Two", template: "\u2248 {ratio}\xD7 in theater for {label}", min_ratio: 1, max_ratio: 100 },
+      { id: "scorsese", category: "film", reference_hours: 3.5, label: "Goodfellas", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 1, max_ratio: 80 },
+      { id: "godfather", category: "film", reference_hours: 6.5, label: "the Godfather saga", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.5, max_ratio: 20 },
+      { id: "lotr_extended", category: "film", reference_hours: 11.4, label: "the LOTR extended trilogy", template: "Longer than all of {label}", min_ratio: 1, max_ratio: 50 },
+      { id: "cooking_brisket", category: "film", reference_hours: 12, label: "low-and-slow brisket cooks", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.3, max_ratio: 30 },
+      { id: "the_office", category: "film", reference_hours: 68, label: "The Office (full series)", template: "\u2248 {ratio}\xD7 bingeing {label}", min_ratio: 5, max_ratio: 200 },
+      { id: "marvel_marathon", category: "film", reference_hours: 50, label: "an MCU Phase One marathon", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.3, max_ratio: 30 },
+      { id: "around_world", category: "film", reference_hours: 1920, label: "Around the World in 80 Days (fictionally)", template: "\u2248 {pct}% of {label}", min_ratio: 0.3, max_ratio: 1 },
+      { id: "soccer_match", category: "sports", reference_hours: 1.75, label: "Premier League matches", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 1, max_ratio: 150 },
+      { id: "marathon", category: "sports", reference_hours: 2, label: "marathons at world-record pace", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 1, max_ratio: 80 },
+      { id: "baseball_game", category: "sports", reference_hours: 3, label: "nine-inning baseball games", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.5, max_ratio: 80 },
+      { id: "superbowl", category: "sports", reference_hours: 3.5, label: "Super Bowls", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.5, max_ratio: 80 },
+      { id: "nfl_game", category: "sports", reference_hours: 3.25, label: "NFL games (with commercials)", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.5, max_ratio: 50 },
+      { id: "wimbledon", category: "sports", reference_hours: 5, label: "Wimbledon finals", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.3, max_ratio: 30 },
+      { id: "tour_stage", category: "sports", reference_hours: 4.5, label: "Tour de France stages", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.5, max_ratio: 60 },
+      { id: "olympics", category: "sports", reference_hours: 250, label: "Summer Olympics broadcast hours", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 2, max_ratio: 10 },
+      { id: "moon_light", category: "cosmos", reference_hours: 1.3 / 3600, label: "a beam of light Earth \u2192 Moon", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 1e3, max_ratio: 1e6 },
+      { id: "iss_orbit", category: "cosmos", reference_hours: 1.5, label: "ISS orbits", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 2, max_ratio: 200 },
+      { id: "light_sun", category: "cosmos", reference_hours: 8.3, label: "solar light crossing to Earth", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.5, max_ratio: 200 },
+      { id: "sleep_cycle", category: "cosmos", reference_hours: 8, label: "full nights of sleep", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.5, max_ratio: 150 },
+      { id: "red_eye", category: "cosmos", reference_hours: 5.5, label: "transcontinental red-eyes", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.5, max_ratio: 100 },
+      { id: "mayfly", category: "cosmos", reference_hours: 24, label: "a mayfly's entire adult life", template: "\u2248 {pct}% of {label}", min_ratio: 0.1, max_ratio: 2 },
+      { id: "earth_rotation", category: "cosmos", reference_hours: 24, label: "Earth rotations", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.1, max_ratio: 50 },
+      { id: "jupiter_storm", category: "cosmos", reference_hours: 150, label: "Jupiter's Great Red Spot rotation", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.3, max_ratio: 15 },
+      { id: "lunar_month", category: "cosmos", reference_hours: 708, label: "a lunar cycle", template: "\u2248 {pct}% of {label}", min_ratio: 0.05, max_ratio: 2 },
+      { id: "mars_transit", category: "cosmos", reference_hours: 5110, label: "a one-way Mars transit (optimistic)", template: "\u2248 {pct}% of {label}", min_ratio: 1e-3, max_ratio: 5 },
+      { id: "calendar_year", category: "cosmos", reference_hours: 8760, label: "all the hours in a calendar year", template: "\u2248 {pct}% of {label}", min_ratio: 0.05, max_ratio: 0.2 },
+      { id: "standup", category: "gtm", reference_hours: 0.25, label: "daily standups", template: "\u2248 {ratio}\xD7 skipped {label}", min_ratio: 4, max_ratio: 500 },
+      { id: "quick_sync", category: "gtm", reference_hours: 0.5, label: "avoided 'quick syncs'", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 2, max_ratio: 200 },
+      { id: "pipeline_review", category: "gtm", reference_hours: 1, label: "weekly pipeline reviews", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 1, max_ratio: 200 },
+      { id: "forecast_call", category: "gtm", reference_hours: 1.5, label: "forecast calls", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 1, max_ratio: 150 },
+      { id: "pivot_spiral", category: "gtm", reference_hours: 2, label: "spreadsheet pivot-table spirals", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 1, max_ratio: 100 },
+      { id: "win_loss", category: "gtm", reference_hours: 4, label: "win/loss interview blocks", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.5, max_ratio: 50 },
+      { id: "crm_cleanup", category: "gtm", reference_hours: 6, label: "CRM hygiene sprints", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.5, max_ratio: 40 },
+      { id: "qbr_prep", category: "gtm", reference_hours: 8, label: "QBR prep blocks", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.3, max_ratio: 20 },
+      { id: "board_deck", category: "gtm", reference_hours: 12, label: "board deck builds", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 0.3, max_ratio: 30 },
+      { id: "semester", category: "gtm", reference_hours: 400, label: "a college semester of analyst coverage", template: "\u2248 {ratio}\xD7 {label}", min_ratio: 1, max_ratio: 5 },
+      { id: "business_year", category: "gtm", reference_hours: 2e3, label: "a full-time analyst year", template: "\u2248 {pct}% of {label}", min_ratio: 0.2, max_ratio: 1 }
+    ];
+  }
+});
+
+// src/whimsy/time-bank-whimsy.ts
+function formatHours(h) {
+  if (h < 1) return `${Math.round(h * 60)}m`;
+  if (h < 10) return `${h.toFixed(1)}h`;
+  return `${Math.round(h)}h`;
+}
+function randomNearMilestoneGoodbye(hoursSaved, hoursToNext, nextTitle) {
+  const pool = NEAR_MILESTONE_GOODBYES;
+  const fn = pool[Math.floor(Math.random() * pool.length)] ?? pool[0];
+  return fn(hoursSaved, hoursToNext, nextTitle);
+}
+var NEAR_MILESTONE_GOODBYES;
+var init_time_bank_whimsy = __esm({
+  "src/whimsy/time-bank-whimsy.ts"() {
+    "use strict";
+    NEAR_MILESTONE_GOODBYES = [
+      (saved, toGo, next) => `${formatHours(saved)} saved \u2014 ${formatHours(toGo)} from ${next}. Almost there.`,
+      (saved, toGo, next) => `${formatHours(saved)} in the bank. One more push hits ${next}.`,
+      (saved, _toGo, next) => `You're at ${formatHours(saved)}. ${next} is right around the corner.`,
+      (saved, toGo, next) => `${formatHours(toGo)} to ${next}. You've already banked ${formatHours(saved)}.`,
+      (saved, _toGo, next) => `Close \u2014 ${formatHours(saved)} saved and ${next} is within reach.`
+    ];
+  }
+});
+
+// src/whimsy/perspective-rotation.ts
+function perspectiveRotationDue(state, now2 = Date.now()) {
+  const perspectiveId = state.perspective_id ?? state.last_perspective_id;
+  if (!perspectiveId) return true;
+  const rotatedAt = state.perspective_rotated_at ? Date.parse(state.perspective_rotated_at) : 0;
+  const minutesAtRotation = state.perspective_minutes_at_rotation ?? 0;
+  const creditedSince = state.total_minutes_saved - minutesAtRotation;
+  const msSince = rotatedAt > 0 ? now2 - rotatedAt : PERSPECTIVE_ROTATE_CALENDAR_MS;
+  return creditedSince >= PERSPECTIVE_ROTATE_CREDIT_MINUTES || msSince >= PERSPECTIVE_ROTATE_CALENDAR_MS;
+}
+function rotationSeed(state) {
+  const epoch = state.perspective_minutes_at_rotation ?? state.total_minutes_saved;
+  const count = state.perspective_rotation_count ?? 0;
+  return epoch * 31 + count * 17;
+}
+function bumpRecentPerspectiveIds(recent, id) {
+  const next = [...(recent ?? []).filter((x) => x !== id), id];
+  if (next.length > PERSPECTIVE_EXCLUDE_RECENT) {
+    next.splice(0, next.length - PERSPECTIVE_EXCLUDE_RECENT);
+  }
+  return next;
+}
+var PERSPECTIVE_ROTATE_CREDIT_MINUTES, PERSPECTIVE_ROTATE_CALENDAR_MS, PERSPECTIVE_EXCLUDE_RECENT;
+var init_perspective_rotation = __esm({
+  "src/whimsy/perspective-rotation.ts"() {
+    "use strict";
+    PERSPECTIVE_ROTATE_CREDIT_MINUTES = 180;
+    PERSPECTIVE_ROTATE_CALENDAR_MS = 7 * 24 * 60 * 60 * 1e3;
+    PERSPECTIVE_EXCLUDE_RECENT = 6;
+  }
+});
+
+// src/whimsy/usage-stats.ts
+var usage_stats_exports = {};
+__export(usage_stats_exports, {
+  buildUsageSummary: () => buildUsageSummary,
+  getUsageStats: () => getUsageStats,
+  isoWeekKey: () => isoWeekKey2,
+  recordLlmUsage: () => recordLlmUsage,
+  recordSessionClosed: () => recordSessionClosed,
+  recordUsageFromCredit: () => recordUsageFromCredit
+});
+function emptyUsage() {
+  return {
+    sessions_closed: 0,
+    diagnoses: 0,
+    metrics_runs: 0,
+    deliverables: 0,
+    nl_exchanges: 0,
+    llm_calls: 0,
+    input_tokens: 0,
+    output_tokens: 0,
+    weekly: []
+  };
+}
+function ensureUsage(state) {
+  return state.usage ?? emptyUsage();
+}
+function isoWeekKey2(d = /* @__PURE__ */ new Date()) {
+  const date = new Date(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()));
+  const day = date.getUTCDay() || 7;
+  date.setUTCDate(date.getUTCDate() + 4 - day);
+  const yearStart = new Date(Date.UTC(date.getUTCFullYear(), 0, 1));
+  const weekNo = Math.ceil(((date.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+  return `${date.getUTCFullYear()}-W${String(weekNo).padStart(2, "0")}`;
+}
+function bumpWeekly2(weekly, patch) {
+  const week = patch.week ?? isoWeekKey2();
+  const idx = weekly.findIndex((w) => w.week === week);
+  const row = idx >= 0 ? { ...weekly[idx] } : { week, minutes_saved: 0, llm_calls: 0, actions: 0 };
+  if (patch.minutes_saved) row.minutes_saved += patch.minutes_saved;
+  if (patch.llm_calls) row.llm_calls += patch.llm_calls;
+  if (patch.actions) row.actions += patch.actions;
+  const next = idx >= 0 ? weekly.map((w, i) => i === idx ? row : w) : [...weekly, row];
+  if (next.length > WEEKLY_CAP) next.splice(0, next.length - WEEKLY_CAP);
+  return next;
+}
+function touchUsage(state, patch) {
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const usage = ensureUsage(state);
+  return {
+    ...state,
+    usage: {
+      ...usage,
+      ...patch,
+      first_active_at: usage.first_active_at ?? now2,
+      last_active_at: now2,
+      weekly: patch.weekly ?? usage.weekly
+    }
+  };
+}
+function recordUsageFromCredit(action, minutes) {
+  if (minutes <= 0) return;
+  let state = loadProgress();
+  const usage = ensureUsage(state);
+  const weekly = bumpWeekly2(usage.weekly, { minutes_saved: minutes, actions: 1 });
+  const counters = { weekly };
+  if (action === "diagnose" || action === "diagnose_findings") counters.diagnoses = usage.diagnoses + 1;
+  if (action === "metrics" || action === "metrics_findings") counters.metrics_runs = usage.metrics_runs + 1;
+  if (action === "deliverable" || action === "deliverable_deck") counters.deliverables = usage.deliverables + 1;
+  if (action === "nl_answer") counters.nl_exchanges = usage.nl_exchanges + 1;
+  state = touchUsage(state, counters);
+  saveProgress(state);
+}
+function recordSessionClosed() {
+  let state = loadProgress();
+  const usage = ensureUsage(state);
+  state = touchUsage(state, {
+    sessions_closed: usage.sessions_closed + 1,
+    weekly: bumpWeekly2(usage.weekly, { actions: 1 })
+  });
+  saveProgress(state);
+}
+function recordLlmUsage(tokenUsage) {
+  let state = loadProgress();
+  const usage = ensureUsage(state);
+  const weekly = bumpWeekly2(usage.weekly, { llm_calls: 1 });
+  state = touchUsage(state, {
+    llm_calls: usage.llm_calls + 1,
+    input_tokens: usage.input_tokens + (tokenUsage?.input_tokens ?? 0),
+    output_tokens: usage.output_tokens + (tokenUsage?.output_tokens ?? 0),
+    weekly
+  });
+  saveProgress(state);
+}
+function getUsageStats() {
+  return ensureUsage(loadProgress());
+}
+function buildUsageSummary(sessionCounts, totalHours, milestonesUnlocked, milestoneTotal) {
+  return {
+    usage: getUsageStats(),
+    total_sessions_on_disk: sessionCounts.total,
+    sessions_with_work: sessionCounts.withWork,
+    total_hours_saved: totalHours,
+    milestones_unlocked: milestonesUnlocked,
+    milestone_total: milestoneTotal
+  };
+}
+var WEEKLY_CAP;
+var init_usage_stats = __esm({
+  "src/whimsy/usage-stats.ts"() {
+    "use strict";
+    init_progress();
+    WEEKLY_CAP = 52;
+  }
+});
+
+// src/whimsy/time-bank.ts
+var time_bank_exports = {};
+__export(time_bank_exports, {
+  creditDeliverable: () => creditDeliverable,
+  creditDiagnoseComplete: () => creditDiagnoseComplete,
+  creditGapCompute: () => creditGapCompute,
+  creditMetricsComplete: () => creditMetricsComplete,
+  creditNlAnswer: () => creditNlAnswer,
+  creditOnboardComplete: () => creditOnboardComplete,
+  creditSessionDeliverableWrapup: () => creditSessionDeliverableWrapup,
+  formatHoursLabel: () => formatHoursLabel,
+  getTimeBankSummary: () => getTimeBankSummary,
+  isNearNextMilestone: () => isNearNextMilestone,
+  loadTimeBankState: () => loadTimeBankState,
+  pickGoodbyeWithTimeBank: () => pickGoodbyeWithTimeBank,
+  printTimeBankCelebration: () => printTimeBankCelebration,
+  recordTimeCredit: () => recordTimeCredit
+});
+import chalk2 from "chalk";
+function actionKey(action, ctx, suffix) {
+  const sessionScoped = /* @__PURE__ */ new Set([
+    "gap_compute",
+    "diagnose",
+    "diagnose_findings",
+    "metrics",
+    "metrics_findings",
+    "deliverable",
+    "deliverable_deck",
+    "session_deliverable_wrapup",
+    "nl_answer"
+  ]);
+  if (sessionScoped.has(action) && ctx?.sessionId) {
+    return suffix ? `${action}:${ctx.sessionId}:${suffix}` : `${action}:${ctx.sessionId}`;
+  }
+  return action;
+}
+function shouldSkip(ctx) {
+  return !ctx || ctx.oneShot;
+}
+function recordTimeCredit(action, ctx, opts) {
+  if (shouldSkip(ctx)) return null;
+  const minutes = ACTION_MINUTES[action];
+  if (!minutes || minutes <= 0) return null;
+  const key = actionKey(action, ctx, opts?.suffix);
+  let state = loadProgress();
+  if (hasCreditAction(state, key)) {
+    return { credited_minutes: 0, new_milestones: [], total_minutes: state.total_minutes_saved };
+  }
+  const previousMinutes = state.total_minutes_saved;
+  const credit = {
+    action: key,
+    minutes,
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    session_id: ctx?.sessionId
+  };
+  state = appendCredit(state, credit);
+  const unlocked = newlyUnlockedMilestones(
+    previousMinutes,
+    state.total_minutes_saved,
+    state.milestones_unlocked
+  );
+  if (unlocked.length > 0) {
+    state = {
+      ...state,
+      milestones_unlocked: [...state.milestones_unlocked, ...unlocked.map((m) => m.id)]
+    };
+  }
+  saveProgress(state);
+  if (minutes > 0) {
+    recordUsageFromCredit(action, minutes);
+    state = maybeRotatePerspective(state, state.total_minutes_saved / 60);
+    saveProgress(state);
+  }
+  if (!opts?.silent && unlocked.length > 0) {
+    for (const m of unlocked) {
+      printTimeBankCelebration(m, state.total_minutes_saved);
+    }
+  }
+  return {
+    credited_minutes: minutes,
+    new_milestones: unlocked,
+    total_minutes: state.total_minutes_saved
+  };
+}
+function creditGapCompute(ctx) {
+  recordTimeCredit("gap_compute", ctx);
+  if (!hasCreditAction(loadProgress(), "gap_compute_first_ever")) {
+    recordTimeCredit("gap_compute_first_ever", ctx);
+  }
+}
+function creditDiagnoseComplete(ctx, withFindings) {
+  recordTimeCredit("diagnose", ctx);
+  if (withFindings) {
+    recordTimeCredit("diagnose_findings", ctx);
+  }
+}
+function creditMetricsComplete(ctx, withFindings) {
+  recordTimeCredit("metrics", ctx);
+  if (withFindings) {
+    recordTimeCredit("metrics_findings", ctx);
+  }
+}
+function creditDeliverable(ctx, target) {
+  recordTimeCredit("deliverable", ctx);
+  if (target === "deck") {
+    recordTimeCredit("deliverable_deck", ctx);
+  }
+}
+function creditNlAnswer(ctx, exchangeIndex) {
+  recordTimeCredit("nl_answer", ctx, { suffix: String(exchangeIndex) });
+}
+function creditOnboardComplete(ctx) {
+  recordTimeCredit("onboard", ctx);
+}
+function creditSessionDeliverableWrapup(ctx) {
+  recordTimeCredit("session_deliverable_wrapup", ctx);
+}
+function activePerspectiveId(state) {
+  return state.perspective_id ?? state.last_perspective_id;
+}
+function maybeRotatePerspective(state, totalHours) {
+  const currentId = activePerspectiveId(state);
+  const current = currentId ? getPerspectiveById(currentId) : void 0;
+  const staleBand = current && !ratioInBand2(current, totalHours);
+  if (!perspectiveRotationDue(state) && current && !staleBand) {
+    return state;
+  }
+  const lastCategory = current?.category;
+  const picked = pickPerspective(totalHours, {
+    excludeIds: state.recent_perspective_ids ?? [],
+    lastCategory,
+    seed: rotationSeed(state)
+  });
+  if (!picked) return state;
+  return {
+    ...state,
+    perspective_id: picked.id,
+    last_perspective_id: picked.id,
+    perspective_rotated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    perspective_minutes_at_rotation: state.total_minutes_saved,
+    perspective_rotation_count: (state.perspective_rotation_count ?? 0) + 1,
+    recent_perspective_ids: bumpRecentPerspectiveIds(state.recent_perspective_ids, picked.id)
+  };
+}
+function ratioInBand2(perspective, totalHours) {
+  const ratio = totalHours / perspective.reference_hours;
+  const min = perspective.min_ratio ?? 0.3;
+  const max = perspective.max_ratio ?? 300;
+  return ratio >= min && ratio <= max;
+}
+function getTimeBankSummary() {
+  let state = loadProgress();
+  const total_minutes = state.total_minutes_saved;
+  const total_hours = total_minutes / 60;
+  if (total_minutes > 0) {
+    state = maybeRotatePerspective(state, total_hours);
+    saveProgress(state);
+  }
+  const next = nextMilestone(total_hours, state.milestones_unlocked);
+  let progress_pct = 100;
+  if (next) {
+    const prevMilestone = state.milestones_unlocked.length > 0 ? getMilestoneById(state.milestones_unlocked[state.milestones_unlocked.length - 1]) : void 0;
+    const prevHours = prevMilestone?.hours ?? 0;
+    const span = next.hours - prevHours;
+    progress_pct = span > 0 ? Math.min(100, (total_hours - prevHours) / span * 100) : 0;
+  }
+  const perspectiveId = activePerspectiveId(state);
+  const perspective = perspectiveId ? getPerspectiveById(perspectiveId) : null;
+  const perspective_line = perspective ? formatPerspectiveLine(perspective, total_hours) : null;
+  return {
+    total_hours,
+    total_minutes,
+    next_milestone: next,
+    progress_pct,
+    perspective_line
+  };
+}
+function printTimeBankCelebration(milestone, totalMinutes) {
+  const totalHours = totalMinutes / 60;
+  const state = loadProgress();
+  const perspective = pickPerspective(totalHours, {
+    excludeIds: state.recent_perspective_ids ?? [],
+    seed: rotationSeed(state) + 1
+  });
+  console.log();
+  console.log("  " + paint("accent", `\u2726 ${milestone.title}`) + chalk2.dim(` \u2014 ${formatHoursLabel(totalHours)} saved`));
+  console.log("  " + chalk2.dim(milestone.message));
+  if (perspective) {
+    console.log("  " + chalk2.dim.italic(formatPerspectiveLine(perspective, totalHours)));
+  }
+  console.log();
+}
+function formatHoursLabel(hours) {
+  if (hours < 1) return `${Math.round(hours * 60)}m`;
+  if (hours < 10) return `${hours.toFixed(1)}h`;
+  if (hours >= 1e3) return `${Math.round(hours).toLocaleString("en-US")}h`;
+  return `${Math.round(hours)}h`;
+}
+function isNearNextMilestone(threshold = 0.15) {
+  const state = loadProgress();
+  if (state.total_minutes_saved <= 0) return false;
+  const totalHours = state.total_minutes_saved / 60;
+  const next = nextMilestone(totalHours, state.milestones_unlocked);
+  if (!next) return false;
+  const prev = state.milestones_unlocked.map((id) => getMilestoneById(id)).filter((m) => !!m).sort((a, b) => b.hours - a.hours)[0];
+  const prevHours = prev?.hours ?? 0;
+  const span = next.hours - prevHours;
+  if (span <= 0) return false;
+  const progress = (totalHours - prevHours) / span;
+  return progress >= 1 - threshold;
+}
+function pickGoodbyeWithTimeBank() {
+  if (Math.random() > 0.25) return null;
+  if (!isNearNextMilestone()) return null;
+  const state = loadProgress();
+  const totalHours = state.total_minutes_saved / 60;
+  const next = nextMilestone(totalHours, state.milestones_unlocked);
+  if (!next) return null;
+  const hoursToNext = Math.max(0, next.hours - totalHours);
+  return randomNearMilestoneGoodbye(totalHours, hoursToNext, next.title);
+}
+function loadTimeBankState() {
+  return loadProgress();
+}
+var ACTION_MINUTES;
+var init_time_bank = __esm({
+  "src/whimsy/time-bank.ts"() {
+    "use strict";
+    init_progress();
+    init_theme();
+    init_time_milestones();
+    init_time_perspectives();
+    init_time_bank_whimsy();
+    init_perspective_rotation();
+    init_usage_stats();
+    ACTION_MINUTES = {
+      gap_compute: 30,
+      gap_compute_first_ever: 30,
+      diagnose: 180,
+      diagnose_findings: 60,
+      metrics: 120,
+      metrics_findings: 60,
+      deliverable: 240,
+      deliverable_deck: 120,
+      nl_answer: 15,
+      onboard: 30,
+      session_deliverable_wrapup: 30
+    };
+  }
+});
+
 // src/cli/context.ts
 var context_exports = {};
 __export(context_exports, {
@@ -1304,10 +2466,10 @@ __export(context_exports, {
   saveSessionState: () => saveSessionState,
   setPrimaryLens: () => setPrimaryLens
 });
-import { basename, join as join2, resolve as resolve2, sep } from "path";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync, readFileSync, readdirSync, statSync, rmSync as rmSync2 } from "fs";
-import { homedir } from "os";
-import { randomUUID as randomUUID2 } from "crypto";
+import { basename, join as join6, resolve as resolve3, sep } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5, readFileSync as readFileSync5, readdirSync, statSync, rmSync as rmSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { randomUUID as randomUUID3 } from "crypto";
 function isAnalysisReady(ctx) {
   if (ctx.stage !== "analyzed" || ctx.analysis.completed.length === 0) return false;
   if (!ctx.dataset) return false;
@@ -1315,29 +2477,29 @@ function isAnalysisReady(ctx) {
   return Object.values(counts).some((n) => n > 0);
 }
 function ntrpHomeDir() {
-  return process.env.NTRP_HOME ? resolve2(process.env.NTRP_HOME) : join2(homedir(), ".ntrp");
+  return process.env.NTRP_HOME ? resolve3(process.env.NTRP_HOME) : join6(homedir2(), ".ntrp");
 }
 function getSessionsDir() {
-  const dir = join2(ntrpHomeDir(), "sessions");
-  if (!existsSync2(dir)) {
-    mkdirSync2(dir, { recursive: true });
+  const dir = join6(ntrpHomeDir(), "sessions");
+  if (!existsSync6(dir)) {
+    mkdirSync5(dir, { recursive: true });
   }
   return dir;
 }
 function getDatasetsDir() {
-  const dir = join2(ntrpHomeDir(), "datasets");
-  if (!existsSync2(dir)) {
-    mkdirSync2(dir, { recursive: true });
+  const dir = join6(ntrpHomeDir(), "datasets");
+  if (!existsSync6(dir)) {
+    mkdirSync5(dir, { recursive: true });
   }
   return dir;
 }
 function datasetPathForSession(id) {
-  return join2(getDatasetsDir(), `${id}.duckdb`);
+  return join6(getDatasetsDir(), `${id}.duckdb`);
 }
 function makeSessionId() {
   const now2 = /* @__PURE__ */ new Date();
   const date = now2.toISOString().slice(0, 10);
-  const uuid2 = randomUUID2().slice(0, 4);
+  const uuid2 = randomUUID3().slice(0, 4);
   return `${date}-${uuid2}`;
 }
 function isValidSessionId(id) {
@@ -1345,14 +2507,14 @@ function isValidSessionId(id) {
 }
 function sessionPathForId(id) {
   if (!isValidSessionId(id)) return null;
-  const dir = resolve2(getSessionsDir());
-  const filePath = resolve2(dir, `${id}.json`);
+  const dir = resolve3(getSessionsDir());
+  const filePath = resolve3(dir, `${id}.json`);
   if (filePath !== dir && !filePath.startsWith(dir + sep)) return null;
   return filePath;
 }
 function initContext(oneShot, execution) {
   const sessionId = makeSessionId();
-  const sessionFile = join2(getSessionsDir(), `${sessionId}.json`);
+  const sessionFile = join6(getSessionsDir(), `${sessionId}.json`);
   return {
     sessionId,
     sessionFile,
@@ -1464,14 +2626,14 @@ function recordMessage(ctx, role, content) {
   ctx.messages.push(msg);
   if (ctx.oneShot) return;
   try {
-    writeFileSync(ctx.sessionFile, JSON.stringify(buildSessionFile(ctx), null, 2) + "\n");
+    writeFileSync5(ctx.sessionFile, JSON.stringify(buildSessionFile(ctx), null, 2) + "\n");
   } catch {
   }
 }
 function saveSessionState(ctx) {
   if (ctx.oneShot) return;
   try {
-    writeFileSync(ctx.sessionFile, JSON.stringify(buildSessionFile(ctx), null, 2) + "\n");
+    writeFileSync5(ctx.sessionFile, JSON.stringify(buildSessionFile(ctx), null, 2) + "\n");
   } catch {
   }
 }
@@ -1481,7 +2643,7 @@ function getLastActivityRelative() {
   try {
     for (const name of readdirSync(dir)) {
       if (!name.endsWith(".json")) continue;
-      const m = statSync(join2(dir, name)).mtimeMs;
+      const m = statSync(join6(dir, name)).mtimeMs;
       if (m > mostRecent) mostRecent = m;
     }
   } catch {
@@ -1507,7 +2669,7 @@ function loadSessionFile(id) {
   const filePath = sessionPathForId(id);
   if (!filePath) return null;
   try {
-    const raw = readFileSync(filePath, "utf-8");
+    const raw = readFileSync5(filePath, "utf-8");
     const session = JSON.parse(raw);
     if (session.thread?.length) {
       session.thread = normalizeThread(session.thread);
@@ -1522,7 +2684,7 @@ function listSessions(opts) {
   const entries = [];
   try {
     const files = readdirSync(dir).filter((name) => name.endsWith(".json")).map((name) => {
-      const filePath = join2(dir, name);
+      const filePath = join6(dir, name);
       return { name, filePath, mtime: statSync(filePath).mtimeMs };
     }).sort((a, b) => b.mtime - a.mtime);
     const filesToRead = opts?.limit ? files.slice(0, opts.limit) : files;
@@ -1530,7 +2692,7 @@ function listSessions(opts) {
       const id = basename(name, ".json");
       if (!isValidSessionId(id)) continue;
       try {
-        const raw = readFileSync(filePath, "utf-8");
+        const raw = readFileSync5(filePath, "utf-8");
         const session = JSON.parse(raw);
         entries.push({
           id,
@@ -1591,7 +2753,7 @@ async function closeAllActiveSessions(ctx) {
       skipped.push(s.id);
       continue;
     }
-    writeFileSync(filePath, JSON.stringify(file, null, 2) + "\n");
+    writeFileSync5(filePath, JSON.stringify(file, null, 2) + "\n");
     closed.push(s.id);
   }
   const currentActive = active.some((s) => s.id === ctx.sessionId);
@@ -1630,7 +2792,7 @@ async function rotateToFreshSession(ctx) {
   const newId = makeSessionId();
   resetContextForSwitch(ctx, {
     sessionId: newId,
-    sessionFile: join2(getSessionsDir(), `${newId}.json`),
+    sessionFile: join6(getSessionsDir(), `${newId}.json`),
     messages: [],
     stage: "new",
     analysis: defaultSessionAnalysis(),
@@ -1659,6 +2821,12 @@ async function finalizeSession(ctx, stage) {
     }
     return void 0;
   }
+  if (ctx.deliverables.length > 0) {
+    const { creditSessionDeliverableWrapup: creditSessionDeliverableWrapup2 } = await Promise.resolve().then(() => (init_time_bank(), time_bank_exports));
+    creditSessionDeliverableWrapup2(ctx);
+  }
+  const { recordSessionClosed: recordSessionClosed2 } = await Promise.resolve().then(() => (init_usage_stats(), usage_stats_exports));
+  recordSessionClosed2();
   const file = {
     id: ctx.sessionId,
     created_at: ctx.messages[0]?.at ?? endedAt,
@@ -1695,7 +2863,7 @@ async function finalizeSession(ctx, stage) {
     file.llm = ctx.llm;
   }
   try {
-    writeFileSync(ctx.sessionFile, JSON.stringify(file, null, 2) + "\n");
+    writeFileSync5(ctx.sessionFile, JSON.stringify(file, null, 2) + "\n");
   } catch {
   }
   return void 0;
@@ -1923,7 +3091,14 @@ async function anthropicComplete(apiKey, model, req) {
       ...req.tools && req.tools.length > 0 ? { tools: toAnthropicTools(req.tools) } : {},
       messages: toAnthropicMessages(req.messages)
     });
-    return parseResponse(response.content);
+    const parsed = parseResponse(response.content);
+    if (response.usage) {
+      parsed.token_usage = {
+        input_tokens: response.usage.input_tokens,
+        output_tokens: response.usage.output_tokens
+      };
+    }
+    return parsed;
   } catch (err) {
     throw mapAnthropicError(err, provider);
   }
@@ -2038,7 +3213,14 @@ async function openaiComplete(apiKey, model, req) {
     if (!choice?.message) {
       throw new Error("OpenAI returned no message");
     }
-    return parseResponse2(choice.message);
+    const parsed = parseResponse2(choice.message);
+    if (response.usage) {
+      parsed.token_usage = {
+        input_tokens: response.usage.prompt_tokens ?? 0,
+        output_tokens: response.usage.completion_tokens ?? 0
+      };
+    }
+    return parsed;
   } catch (err) {
     if (err instanceof OpenAI.APIError) {
       throw mapOpenAiError(err, provider);
@@ -2098,270 +3280,103 @@ function resolveRetiredModel(id) {
 function cheapestActiveInTier(provider, tier) {
   const candidates = ENTRIES.filter(
     (e) => e.provider === provider && e.tier === tier && e.status === "active"
-  );
-  if (candidates.length === 0) return void 0;
-  return candidates.sort((a, b) => a.relative_cost - b.relative_cost)[0];
-}
-function getTierDefault(provider, tier) {
-  const entry = cheapestActiveInTier(provider, tier);
-  if (!entry) {
-    throw new Error(`No active ${tier}-tier model for provider ${provider} in catalog`);
-  }
-  return entry;
-}
-function resolveModel(provider, tier, override) {
-  if (override) {
-    const entry = byId.get(override);
-    if (!entry) return resolveRetiredModel(override);
-    if (entry.status === "retired") return resolveRetiredModel(override);
-    return entry.id;
-  }
-  return getTierDefault(provider, tier).id;
-}
-function formatModelLabel(provider, modelId) {
-  const entry = byId.get(modelId);
-  return entry ? `${provider}/${entry.display_name}` : `${provider}/${modelId}`;
-}
-var ENTRIES, byId;
-var init_catalog = __esm({
-  "src/ai/llm/catalog.ts"() {
-    "use strict";
-    ENTRIES = [
-      {
-        id: "claude-opus-4-6",
-        provider: "anthropic",
-        tier: "high",
-        status: "active",
-        successor_id: null,
-        supports_tools: true,
-        max_context_tokens: 2e5,
-        display_name: "Claude Opus 4.6",
-        relative_cost: 3
-      },
-      {
-        id: "claude-sonnet-4-5-20250929",
-        provider: "anthropic",
-        tier: "medium",
-        status: "active",
-        successor_id: null,
-        supports_tools: true,
-        max_context_tokens: 2e5,
-        display_name: "Claude Sonnet 4.5",
-        relative_cost: 2
-      },
-      {
-        id: "claude-haiku-4-5-20251001",
-        provider: "anthropic",
-        tier: "low",
-        status: "active",
-        successor_id: null,
-        supports_tools: true,
-        max_context_tokens: 2e5,
-        display_name: "Claude Haiku 4.5",
-        relative_cost: 1
-      },
-      {
-        id: "gpt-4.1",
-        provider: "openai",
-        tier: "high",
-        status: "active",
-        successor_id: null,
-        supports_tools: true,
-        max_context_tokens: 1047576,
-        display_name: "GPT-4.1",
-        relative_cost: 3
-      },
-      {
-        id: "gpt-4.1-mini",
-        provider: "openai",
-        tier: "medium",
-        status: "active",
-        successor_id: null,
-        supports_tools: true,
-        max_context_tokens: 1047576,
-        display_name: "GPT-4.1 Mini",
-        relative_cost: 2
-      },
-      {
-        id: "gpt-4.1-nano",
-        provider: "openai",
-        tier: "low",
-        status: "active",
-        successor_id: null,
-        supports_tools: true,
-        max_context_tokens: 1047576,
-        display_name: "GPT-4.1 Nano",
-        relative_cost: 1
-      }
-    ];
-    byId = new Map(ENTRIES.map((e) => [e.id, e]));
-  }
-});
-
-// 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 writeFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync3 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join3, resolve as resolve3 } from "path";
-function ntrpHome() {
-  return NTRP_DIR2;
-}
-function ensureDir2() {
-  if (!existsSync3(NTRP_DIR2)) {
-    mkdirSync3(NTRP_DIR2, { 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 saveConfig(config) {
-  ensureDir2();
-  writeFileSync2(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 = resolve3(config["export-dir"] ?? join3(NTRP_DIR2, "exports"));
-  if (!existsSync3(dir)) {
-    mkdirSync3(dir, { recursive: true });
-  }
-  return dir;
-}
-function getStrategiesDir() {
-  const dir = join3(NTRP_DIR2, "strategies");
-  if (!existsSync3(dir)) {
-    mkdirSync3(dir, { recursive: true });
-    writeFileSync2(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;
+  );
+  if (candidates.length === 0) return void 0;
+  return candidates.sort((a, b) => a.relative_cost - b.relative_cost)[0];
 }
-function getMemoryDir() {
-  const dir = join3(NTRP_DIR2, "memory");
-  if (!existsSync3(dir)) {
-    mkdirSync3(dir, { recursive: true });
+function getTierDefault(provider, tier) {
+  const entry = cheapestActiveInTier(provider, tier);
+  if (!entry) {
+    throw new Error(`No active ${tier}-tier model for provider ${provider} in catalog`);
   }
-  return dir;
+  return entry;
 }
-function getKnowledgeDir() {
-  const dir = join3(NTRP_DIR2, "knowledge");
-  if (!existsSync3(dir)) {
-    mkdirSync3(dir, { recursive: true });
-    writeFileSync2(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.
-`);
+function resolveModel(provider, tier, override) {
+  if (override) {
+    const entry = byId.get(override);
+    if (!entry) return resolveRetiredModel(override);
+    if (entry.status === "retired") return resolveRetiredModel(override);
+    return entry.id;
   }
-  return dir;
+  return getTierDefault(provider, tier).id;
 }
-function getWinsDir() {
-  const dir = join3(NTRP_DIR2, "wins");
-  if (!existsSync3(dir)) {
-    mkdirSync3(dir, { recursive: true });
-    writeFileSync2(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;
+function formatModelLabel(provider, modelId) {
+  const entry = byId.get(modelId);
+  return entry ? `${provider}/${entry.display_name}` : `${provider}/${modelId}`;
 }
-var NTRP_DIR2, CONFIG_PATH, cachedConfig;
-var init_store = __esm({
-  "src/config/store.ts"() {
+var ENTRIES, byId;
+var init_catalog = __esm({
+  "src/ai/llm/catalog.ts"() {
     "use strict";
-    NTRP_DIR2 = process.env.NTRP_HOME ? resolve3(process.env.NTRP_HOME) : join3(homedir2(), ".ntrp");
-    CONFIG_PATH = join3(NTRP_DIR2, "config.json");
-    cachedConfig = null;
+    ENTRIES = [
+      {
+        id: "claude-opus-4-6",
+        provider: "anthropic",
+        tier: "high",
+        status: "active",
+        successor_id: null,
+        supports_tools: true,
+        max_context_tokens: 2e5,
+        display_name: "Claude Opus 4.6",
+        relative_cost: 3
+      },
+      {
+        id: "claude-sonnet-4-5-20250929",
+        provider: "anthropic",
+        tier: "medium",
+        status: "active",
+        successor_id: null,
+        supports_tools: true,
+        max_context_tokens: 2e5,
+        display_name: "Claude Sonnet 4.5",
+        relative_cost: 2
+      },
+      {
+        id: "claude-haiku-4-5-20251001",
+        provider: "anthropic",
+        tier: "low",
+        status: "active",
+        successor_id: null,
+        supports_tools: true,
+        max_context_tokens: 2e5,
+        display_name: "Claude Haiku 4.5",
+        relative_cost: 1
+      },
+      {
+        id: "gpt-4.1",
+        provider: "openai",
+        tier: "high",
+        status: "active",
+        successor_id: null,
+        supports_tools: true,
+        max_context_tokens: 1047576,
+        display_name: "GPT-4.1",
+        relative_cost: 3
+      },
+      {
+        id: "gpt-4.1-mini",
+        provider: "openai",
+        tier: "medium",
+        status: "active",
+        successor_id: null,
+        supports_tools: true,
+        max_context_tokens: 1047576,
+        display_name: "GPT-4.1 Mini",
+        relative_cost: 2
+      },
+      {
+        id: "gpt-4.1-nano",
+        provider: "openai",
+        tier: "low",
+        status: "active",
+        successor_id: null,
+        supports_tools: true,
+        max_context_tokens: 1047576,
+        display_name: "GPT-4.1 Nano",
+        relative_cost: 1
+      }
+    ];
+    byId = new Map(ENTRIES.map((e) => [e.id, e]));
   }
 });
 
@@ -2626,8 +3641,10 @@ async function completeWithFailover(req, opts = {}) {
       const meta = {
         provider_used: provider,
         model_used: model,
+        ...response.token_usage ?? {},
         ...failoverFrom ? { failover: true, failover_from: failoverFrom } : {}
       };
+      recordLlmUsage(response.token_usage);
       return { response, meta };
     } catch (err) {
       const llmErr = err;
@@ -2640,8 +3657,10 @@ async function completeWithFailover(req, opts = {}) {
           const meta = {
             provider_used: provider,
             model_used: model,
+            ...response.token_usage ?? {},
             ...failoverFrom ? { failover: true, failover_from: failoverFrom } : {}
           };
+          recordLlmUsage(response.token_usage);
           return { response, meta };
         } catch (retryErr) {
           const retryLlm = retryErr;
@@ -2688,9 +3707,13 @@ async function* streamWithFailover(req, opts = {}) {
           yield event;
         }
       }
+      const estimatedOut = Math.ceil(fullText.length / 4);
+      recordLlmUsage({ input_tokens: 0, output_tokens: estimatedOut });
       const meta = {
         provider_used: provider,
         model_used: model,
+        input_tokens: 0,
+        output_tokens: estimatedOut,
         ...failoverFrom ? { failover: true, failover_from: failoverFrom } : {}
       };
       yield {
@@ -2723,6 +3746,7 @@ async function* streamWithFailover(req, opts = {}) {
 var init_failover = __esm({
   "src/ai/llm/failover.ts"() {
     "use strict";
+    init_usage_stats();
     init_anthropic();
     init_openai();
     init_catalog();
@@ -3135,9 +4159,9 @@ var init_tool_schemas = __esm({
 });
 
 // src/ai/privacy.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, appendFileSync } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync6, appendFileSync } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
+import { join as join7 } from "path";
 function stripPII(obj) {
   if (obj === null || obj === void 0) return obj;
   if (typeof obj !== "object") return obj;
@@ -3152,14 +4176,14 @@ function stripPII(obj) {
   return out;
 }
 function ensureAuditDir() {
-  if (!existsSync4(AUDIT_DIR)) {
-    mkdirSync4(AUDIT_DIR, { recursive: true });
+  if (!existsSync7(AUDIT_DIR)) {
+    mkdirSync6(AUDIT_DIR, { recursive: true });
   }
 }
 function logToolCall(entry) {
   ensureAuditDir();
   const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const path = join4(AUDIT_DIR, `agentic-${date}.jsonl`);
+  const path = join7(AUDIT_DIR, `agentic-${date}.jsonl`);
   appendFileSync(path, JSON.stringify(entry) + "\n");
 }
 var PII_FIELDS, AUDIT_DIR;
@@ -3183,7 +4207,7 @@ var init_privacy = __esm({
       "raw_data",
       "metadata"
     ]);
-    AUDIT_DIR = join4(homedir3(), ".ntrp", "audit");
+    AUDIT_DIR = join7(homedir3(), ".ntrp", "audit");
   }
 });
 
@@ -3410,16 +4434,16 @@ var init_metrics_benchmarks = __esm({
 });
 
 // src/config/profile.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync5, mkdirSync as mkdirSync5 } from "fs";
-import { join as join5 } from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, existsSync as existsSync8, mkdirSync as mkdirSync7 } from "fs";
+import { join as join8 } from "path";
 function isProfileConfigured(profile = loadProfile()) {
   if (!profile) return false;
   return profile.company_name.trim().length > 0;
 }
 function loadProfile() {
-  if (!existsSync5(PROFILE_PATH)) return null;
+  if (!existsSync8(PROFILE_PATH)) return null;
   try {
-    const parsed = JSON.parse(readFileSync3(PROFILE_PATH, "utf-8"));
+    const parsed = JSON.parse(readFileSync6(PROFILE_PATH, "utf-8"));
     if (!parsed || typeof parsed !== "object") return null;
     return parsed;
   } catch {
@@ -3432,7 +4456,7 @@ var init_profile = __esm({
     "use strict";
     init_store();
     NTRP_DIR3 = ntrpHome();
-    PROFILE_PATH = join5(NTRP_DIR3, "profile.json");
+    PROFILE_PATH = join8(NTRP_DIR3, "profile.json");
   }
 });
 
@@ -5673,76 +6697,8 @@ var init_insights = __esm({
   }
 });
 
-// src/ui/theme.ts
-import chalk from "chalk";
-function paint(token, text) {
-  if (token === "dim") return chalk.dim(text);
-  return chalk.hex(TOKENS[token])(text);
-}
-function bold(text) {
-  return chalk.bold(text);
-}
-function badge(label, tone = "muted") {
-  const normalized = ` ${label.toUpperCase()} `;
-  switch (tone) {
-    case "success":
-      return chalk.hex(TOKENS.success)(normalized);
-    case "warning":
-      return chalk.hex(TOKENS.warning)(normalized);
-    case "error":
-      return chalk.hex(TOKENS.error)(normalized);
-    case "info":
-      return chalk.hex(TOKENS.info)(normalized);
-    case "accent":
-      return chalk.hex(TOKENS.accent)(normalized);
-    case "muted":
-      return chalk.dim(normalized);
-  }
-}
-function sectionHeading(label) {
-  return `${paint("accent", "\u25B8")} ${paint("accent", bold(label))}`;
-}
-function actionHint(label, command, detail) {
-  const suffix = detail ? chalk.dim(` ${detail}`) : "";
-  return `${chalk.dim(label)} ${paint("accent", command)}${suffix}`;
-}
-function scoreBar(score, status, width = 14) {
-  const filled = Math.round(score / 100 * width);
-  const color = chalk.hex(STATUS_COLORS[status]);
-  let filledPart = "";
-  for (let i = 0; i < filled; i++) {
-    filledPart += i % 2 === 0 ? "\u2588" : "\u2593";
-  }
-  const emptyPart = "\u2591".repeat(width - filled);
-  return color(filledPart) + chalk.dim(emptyPart);
-}
-var STATUS_COLORS, TOKENS;
-var init_theme = __esm({
-  "src/ui/theme.ts"() {
-    "use strict";
-    init_formatters();
-    STATUS_COLORS = {
-      green: "#22c55e",
-      yellow: "#eab308",
-      red: "#ef4444"
-    };
-    TOKENS = {
-      accent: "#14b8a6",
-      accentBright: "#2dd4bf",
-      border: "#334155",
-      borderMuted: "#1e293b",
-      dim: "#64748b",
-      text: "#e2e8f0",
-      error: "#ef4444",
-      warning: "#eab308",
-      success: "#22c55e",
-      info: "#3b82f6"
-    };
-  }
-});
-
 // src/conversation/phase.ts
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 function sessionHasData(ctx) {
   const counts = ctx.dataset?.counts ?? {};
   return Object.values(counts).some((n) => (n ?? 0) > 0);
@@ -6037,12 +6993,12 @@ var init_repl_globals = __esm({
 // src/cli/prompts.ts
 import { createInterface } from "readline/promises";
 import { clearLine, cursorTo } from "readline";
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 function marker() {
   return paint("accent", "ntrp \u203A ");
 }
 function secretPromptLine(question) {
-  return `  ${paint("accent", "\u25B8")} ${bold(question)} ${chalk3.dim("(hidden \u2014 paste once, Enter)")} `;
+  return `  ${paint("accent", "\u25B8")} ${bold(question)} ${chalk4.dim("(hidden \u2014 paste once, Enter)")} `;
 }
 function stripTerminalArtifacts(input) {
   return input.replace(/\x1b\[[0-9;]*[a-zA-Z~]/g, "").replace(/\x1b\][^\x07]*(\x07|\x1b\\)/g, "").replace(/\x1b\[200~/g, "").replace(/\x1b\[201~/g, "");
@@ -6050,7 +7006,7 @@ function stripTerminalArtifacts(input) {
 function renderQuestion(question, defaultValue) {
   const base = `  ${marker()}${bold(question)}`;
   if (defaultValue !== void 0 && defaultValue !== "") {
-    return `${base} ${chalk3.dim(`[${defaultValue}]`)} `;
+    return `${base} ${chalk4.dim(`[${defaultValue}]`)} `;
   }
   return `${base} `;
 }
@@ -6075,7 +7031,7 @@ function createPromptSession(existing, ctx) {
       const raw = (await rl.question(renderQuestion(question))).trim();
       assertNotGlobalReplCommand(raw);
       if (raw) return raw;
-      console.log("  " + chalk3.red("This one is required."));
+      console.log("  " + chalk4.red("This one is required."));
     }
   }
   async function confirm(question, defaultYes = false) {
@@ -6093,13 +7049,13 @@ function createPromptSession(existing, ctx) {
     const defaultIdx = opts.default ? choices.findIndex((c) => c.value === opts.default) : -1;
     choices.forEach((c, i) => {
       const num = paint("accent", `${i + 1}.`);
-      const active = i === defaultIdx ? chalk3.dim("  \u2190 default") : "";
+      const active = i === defaultIdx ? chalk4.dim("  \u2190 default") : "";
       console.log(`    ${num} ${c.label}${active}`);
-      if (c.description) console.log(`       ${chalk3.dim(c.description)}`);
+      if (c.description) console.log(`       ${chalk4.dim(c.description)}`);
     });
     const defaultLabel = defaultIdx >= 0 ? String(defaultIdx + 1) : void 0;
     console.log();
-    console.log("  " + chalk3.dim("\u2500".repeat(40)));
+    console.log("  " + chalk4.dim("\u2500".repeat(40)));
     for (; ; ) {
       const raw = (await rl.question(renderQuestion(`Your pick [1-${choices.length}]`, defaultLabel))).trim();
       assertNotGlobalReplCommand(raw);
@@ -6108,7 +7064,7 @@ function createPromptSession(existing, ctx) {
       if (Number.isInteger(n) && n >= 1 && n <= choices.length) {
         return choices[n - 1].value;
       }
-      console.log("  " + chalk3.red(`Enter a number from 1 to ${choices.length}.`));
+      console.log("  " + chalk4.red(`Enter a number from 1 to ${choices.length}.`));
     }
   }
   async function askMulti(question, options) {
@@ -6118,7 +7074,7 @@ function createPromptSession(existing, ctx) {
     options.forEach((o, i) => {
       const num = paint("accent", `${i + 1}.`);
       console.log(`    ${num} ${o.label}`);
-      if (o.description) console.log(`       ${chalk3.dim(o.description)}`);
+      if (o.description) console.log(`       ${chalk4.dim(o.description)}`);
     });
     const hint = `Choose [1-${options.length}], type your own, or enter to skip`;
     const raw = (await rl.question(renderQuestion(hint))).trim();
@@ -6221,20 +7177,20 @@ function createPromptSession(existing, ctx) {
     for (; ; ) {
       const value = await readMaskedLine(secretPromptLine(question), maskChar);
       if (!value) {
-        console.log("  " + chalk3.red("This one is required."));
+        console.log("  " + chalk4.red("This one is required."));
         continue;
       }
       if (opts.confirm === false) return value;
       const preview = value.length <= 14 ? `${value.slice(0, 4)}\u2026` : `${value.slice(0, 10)}\u2026`;
-      console.log("  " + chalk3.dim(`Captured ${value.length} characters (${preview})`));
+      console.log("  " + chalk4.dim(`Captured ${value.length} characters (${preview})`));
       const ok = await confirm("Save this key?", false);
       if (ok) return value;
-      console.log("  " + chalk3.dim("Try again \u2014 paste the key once, then Enter."));
+      console.log("  " + chalk4.dim("Try again \u2014 paste the key once, then Enter."));
     }
   }
   async function askPressEnter(message) {
     await rl.question(
-      `  ${paint("accent", "\u25B8")} ${bold(message)} ${chalk3.dim("(Enter)")} `
+      `  ${paint("accent", "\u25B8")} ${bold(message)} ${chalk4.dim("(Enter)")} `
     );
   }
   return {
@@ -6262,30 +7218,30 @@ var init_prompts = __esm({
 });
 
 // src/conversation/gap-card.ts
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 function printGapCard(audit) {
   console.log();
-  console.log("  " + chalk4.bold("Data check"));
+  console.log("  " + chalk5.bold("Data check"));
   if (audit.satisfied.length > 0) {
     for (const item of audit.satisfied) {
-      console.log("  " + chalk4.green("\u2713") + " " + chalk4.dim(`${item.label}: ${item.detail}`));
+      console.log("  " + chalk5.green("\u2713") + " " + chalk5.dim(`${item.label}: ${item.detail}`));
     }
   }
   for (const item of audit.missing) {
-    console.log("  " + chalk4.red("\u2717") + " " + item.label + chalk4.dim(` \u2014 ${item.why}`));
-    console.log("    " + chalk4.dim(item.suggestion));
+    console.log("  " + chalk5.red("\u2717") + " " + item.label + chalk5.dim(` \u2014 ${item.why}`));
+    console.log("    " + chalk5.dim(item.suggestion));
   }
   for (const item of audit.optional) {
-    console.log("  " + chalk4.yellow("~") + " " + chalk4.dim(`${item.label}: ${item.detail}`));
+    console.log("  " + chalk5.yellow("~") + " " + chalk5.dim(`${item.label}: ${item.detail}`));
   }
   console.log();
   if (audit.can_compute) {
     console.log(
-      "  " + chalk4.dim("Ready to compute \u2014 say ") + chalk4.cyan('"go ahead"') + chalk4.dim(" or ") + chalk4.cyan('"run analysis"')
+      "  " + chalk5.dim("Ready to compute \u2014 say ") + chalk5.cyan('"go ahead"') + chalk5.dim(" or ") + chalk5.cyan('"run analysis"')
     );
   } else if (audit.missing.length > 0) {
     console.log(
-      "  " + chalk4.dim("Load data (paste a CSV path or say ") + chalk4.cyan("use demo data") + chalk4.dim(")")
+      "  " + chalk5.dim("Load data (paste a CSV path or say ") + chalk5.cyan("use demo data") + chalk5.dim(")")
     );
   }
   console.log();
@@ -6297,7 +7253,7 @@ var init_gap_card = __esm({
 });
 
 // src/metrics/companion.ts
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 function getCompanionRecommendation(input) {
   const { analysis, coverage, opportunityCount, activityCount, sourceType } = input;
   const completed = new Set(analysis.completed);
@@ -6317,14 +7273,14 @@ function getCompanionRecommendation(input) {
 function printAnalysisComplete(lens) {
   const label = lens === "revenue_metrics" ? "SaaS metrics" : "Pipeline health";
   console.log(
-    "  " + chalk5.green(`\u2713 ${label} ready`) + chalk5.dim(" \u2014 type a question below ") + paint("accent", "(no slash needed)")
+    "  " + chalk6.green(`\u2713 ${label} ready`) + chalk6.dim(" \u2014 type a question below ") + paint("accent", "(no slash needed)")
   );
 }
 function printCompanionBanner(invoked, primary) {
   if (invoked === "diagnose" && primary === "revenue_metrics") {
     console.log();
     console.log(
-      "  " + chalk5.dim("Other view \u2014 ") + chalk5.bold("pipeline health") + chalk5.dim(" (this session started with SaaS metrics)")
+      "  " + chalk6.dim("Other view \u2014 ") + chalk6.bold("pipeline health") + chalk6.dim(" (this session started with SaaS metrics)")
     );
     console.log();
     return;
@@ -6332,7 +7288,7 @@ function printCompanionBanner(invoked, primary) {
   if (invoked === "metrics" && primary === "gtm_health") {
     console.log();
     console.log(
-      "  " + chalk5.dim("Other view \u2014 ") + chalk5.bold("SaaS metrics") + chalk5.dim(" (this session started with pipeline health)")
+      "  " + chalk6.dim("Other view \u2014 ") + chalk6.bold("SaaS metrics") + chalk6.dim(" (this session started with pipeline health)")
     );
     console.log();
   }
@@ -6342,7 +7298,7 @@ function printCompanionFooter(ctx, companion, options = { justCompleted: "gtm_he
   const completed = new Set(ctx.analysis.completed);
   printAnalysisComplete(justCompleted);
   console.log();
-  console.log("  " + chalk5.bold("Try asking"));
+  console.log("  " + chalk6.bold("Try asking"));
   const defaults = justCompleted === "revenue_metrics" ? [
     "Why is NRR showing 100%?",
     "Which deals drove ARR this quarter?",
@@ -6354,7 +7310,7 @@ function printCompanionFooter(ctx, companion, options = { justCompleted: "gtm_he
   ];
   const asks = (suggestedAsks?.length ? suggestedAsks : defaults).slice(0, 3);
   for (const q of asks) {
-    console.log(chalk5.dim(`    "${q}"`));
+    console.log(chalk6.dim(`    "${q}"`));
   }
   console.log();
   const extras = [];
@@ -6369,7 +7325,7 @@ function printCompanionFooter(ctx, companion, options = { justCompleted: "gtm_he
   } else {
     extras.push(`${paint("accent", "/diagnose --findings")} for AI depth`);
   }
-  console.log("  " + chalk5.dim("Also: ") + chalk5.dim(extras.join(" \xB7 ")));
+  console.log("  " + chalk6.dim("Also: ") + chalk6.dim(extras.join(" \xB7 ")));
   console.log();
 }
 async function resolveCompanionRecommendation(ctx) {
@@ -6413,16 +7369,16 @@ var init_complete = __esm({
 });
 
 // src/data/playbook.ts
-import { existsSync as existsSync6, readFileSync as readFileSync4, appendFileSync as appendFileSync2 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync7, appendFileSync as appendFileSync2 } from "fs";
+import { join as join9 } from "path";
 function playsPath() {
-  return join6(getMemoryDir(), PLAYS_FILE);
+  return join9(getMemoryDir(), PLAYS_FILE);
 }
 function getCustomPlays() {
   const path = playsPath();
-  if (!existsSync6(path)) return [];
+  if (!existsSync9(path)) return [];
   const out = [];
-  for (const line of readFileSync4(path, "utf-8").split("\n")) {
+  for (const line of readFileSync7(path, "utf-8").split("\n")) {
     const trimmed = line.trim();
     if (!trimmed) continue;
     try {
@@ -6974,7 +7930,7 @@ var init_layout = __esm({
 });
 
 // src/ui/markdown.ts
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 import Table from "cli-table3";
 function renderMarkdown(text, opts = {}) {
   const indent = opts.indent ?? 2;
@@ -7110,13 +8066,13 @@ function renderBlock(block, width) {
     case "paragraph":
       return wrapWords(inline(block.text), width).join("\n");
     case "heading": {
-      const styled = chalk6.bold(inline(block.text));
+      const styled = chalk7.bold(inline(block.text));
       const barWidth = Math.min(width, Math.max(8, visibleWidth(styled)));
       return `${styled}
-${chalk6.dim(hr(barWidth))}`;
+${chalk7.dim(hr(barWidth))}`;
     }
     case "hr":
-      return chalk6.dim(hr(width));
+      return chalk7.dim(hr(width));
     case "ul":
       return block.items.map((item) => {
         const lines = wrapWords(inline(item), Math.max(1, width - 4));
@@ -7134,10 +8090,10 @@ ${chalk6.dim(hr(barWidth))}`;
     }
     case "blockquote": {
       const lines = wrapWords(inline(block.text), Math.max(1, width - 2));
-      return lines.map((l) => chalk6.dim("\u2502 ") + chalk6.italic(l)).join("\n");
+      return lines.map((l) => chalk7.dim("\u2502 ") + chalk7.italic(l)).join("\n");
     }
     case "code":
-      return block.lines.map((l) => chalk6.cyan(`  ${l}`)).join("\n");
+      return block.lines.map((l) => chalk7.cyan(`  ${l}`)).join("\n");
     case "table":
       return renderTable(block.header, block.rows, width);
   }
@@ -7178,11 +8134,11 @@ function inline(text) {
     codeSpans.push(code);
     return `\0CODE${idx}\0`;
   });
-  out = out.replace(/\*\*([^*\n]+?)\*\*/g, (_m, inner) => chalk6.bold(inner));
-  out = out.replace(/(^|[^*\w])\*([^*\n]+?)\*(?!\*)/g, (_m, pre, inner) => `${pre}${chalk6.italic(inner)}`);
-  out = out.replace(/(^|[^_\w])_([^_\n]+?)_(?!\w)/g, (_m, pre, inner) => `${pre}${chalk6.italic(inner)}`);
+  out = out.replace(/\*\*([^*\n]+?)\*\*/g, (_m, inner) => chalk7.bold(inner));
+  out = out.replace(/(^|[^*\w])\*([^*\n]+?)\*(?!\*)/g, (_m, pre, inner) => `${pre}${chalk7.italic(inner)}`);
+  out = out.replace(/(^|[^_\w])_([^_\n]+?)_(?!\w)/g, (_m, pre, inner) => `${pre}${chalk7.italic(inner)}`);
   out = out.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
-  out = out.replace(/\u0000CODE(\d+)\u0000/g, (_m, idx) => chalk6.cyan(codeSpans[Number(idx)]));
+  out = out.replace(/\u0000CODE(\d+)\u0000/g, (_m, idx) => chalk7.cyan(codeSpans[Number(idx)]));
   return out;
 }
 var init_markdown = __esm({
@@ -7193,7 +8149,7 @@ var init_markdown = __esm({
 });
 
 // src/output/llm-attribution.ts
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 function formatLlmAttribution(meta) {
   if (!meta.model_used) return null;
   const provider = meta.provider_used ?? "anthropic";
@@ -7205,7 +8161,7 @@ function formatLlmAttribution(meta) {
 }
 function printLlmAttribution(meta) {
   const line = formatLlmAttribution(meta);
-  if (line) console.log(chalk7.dim(`  ${line}`));
+  if (line) console.log(chalk8.dim(`  ${line}`));
 }
 var init_llm_attribution = __esm({
   "src/output/llm-attribution.ts"() {
@@ -7215,7 +8171,7 @@ var init_llm_attribution = __esm({
 });
 
 // src/output/terminal.ts
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 import ora from "ora";
 import Table2 from "cli-table3";
 function centerPad(text, width) {
@@ -7227,11 +8183,11 @@ function centerPad(text, width) {
 function statusColor(status) {
   switch (status) {
     case "green":
-      return chalk8.green;
+      return chalk9.green;
     case "yellow":
-      return chalk8.yellow;
+      return chalk9.yellow;
     case "red":
-      return chalk8.red;
+      return chalk9.red;
   }
 }
 function statusDot(status) {
@@ -7248,12 +8204,12 @@ function statusBadge(status) {
   }
 }
 function printHeading(label, detail) {
-  console.log(`  ${sectionHeading(label)}${detail ? chalk8.dim(` ${detail}`) : ""}`);
+  console.log(`  ${sectionHeading(label)}${detail ? chalk9.dim(` ${detail}`) : ""}`);
 }
 function printResultCard(title, rows) {
   const width = 70;
   const inner = width - 4;
-  const border = chalk8.dim;
+  const border = chalk9.dim;
   console.log();
   console.log(`  ${border(`\u256D${"\u2500".repeat(width - 2)}\u256E`)}`);
   console.log(`  ${border("\u2502 ")}${padRight(sectionHeading(title), inner)}${border(" \u2502")}`);
@@ -7269,17 +8225,17 @@ 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 ? `${chalk8.green(formatCurrency(vs.dollar_value))} ${chalk8.dim(vs.dollar_label ?? "")}` : chalk8.dim("\u2014");
-  console.log(`  ${dot} ${label} ${bar}  ${chalk8.bold(score)}  ${chalk8.dim("\u2502")}  ${impact}`);
+  const impact = vs.dollar_value != null && vs.dollar_value > 0 ? `${chalk9.green(formatCurrency(vs.dollar_value))} ${chalk9.dim(vs.dollar_label ?? "")}` : chalk9.dim("\u2014");
+  console.log(`  ${dot} ${label} ${bar}  ${chalk9.bold(score)}  ${chalk9.dim("\u2502")}  ${impact}`);
 }
 function printHealthSummary(result, _pipelineMetrics) {
-  const scoreStr = `${chalk8.bold(String(Math.round(result.overall_score)))}${chalk8.dim("/100")}`;
-  const impact = result.total_value_at_risk != null && result.total_value_at_risk > 0 ? `${chalk8.green(formatCurrency(result.total_value_at_risk))} ${chalk8.dim("total at risk")}` : chalk8.dim("No dollar-weighted risk detected");
+  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 ? `${chalk9.green(formatCurrency(result.total_value_at_risk))} ${chalk9.dim("total at risk")}` : chalk9.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", [
-    `${chalk8.dim("Score")}        ${scoreStr}  ${statusBadge(result.overall_status)}`,
-    `${chalk8.dim("Gated by")}     ${paint("accent", VITAL_SIGN_LABELS[result.gating_vital_sign])}`,
-    `${chalk8.dim("Revenue")}      ${impact}`,
+    `${chalk9.dim("Score")}        ${scoreStr}  ${statusBadge(result.overall_status)}`,
+    `${chalk9.dim("Gated by")}     ${paint("accent", VITAL_SIGN_LABELS[result.gating_vital_sign])}`,
+    `${chalk9.dim("Revenue")}      ${impact}`,
     next
   ]);
 }
@@ -7300,8 +8256,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 = chalk8.dim(VITAL_SIGN_LABELS[seg.result.gating_vital_sign]);
-    console.log(`  ${dot} ${name} ${chalk8.bold(score)}  ${chalk8.dim("\u2502")}  ${gating}`);
+    const gating = chalk9.dim(VITAL_SIGN_LABELS[seg.result.gating_vital_sign]);
+    console.log(`  ${dot} ${name} ${chalk9.bold(score)}  ${chalk9.dim("\u2502")}  ${gating}`);
   }
   console.log();
 }
@@ -7325,7 +8281,7 @@ function printTopProblems(segments, limit = 7) {
   if (problems.length === 0) {
     printHeading("Top Problems");
     console.log();
-    console.log("  " + chalk8.dim("No dollar-weighted problems found across segments."));
+    console.log("  " + chalk9.dim("No dollar-weighted problems found across segments."));
     console.log();
     return;
   }
@@ -7338,45 +8294,45 @@ function printTopProblems(segments, limit = 7) {
   const labelW = Math.max("".length, ...top.map((p) => p.dollarLabel.length));
   const impactW = dollarW + 2 + labelW;
   console.log(
-    `  ${sectionHeading("Top Problems")}` + chalk8.dim(` (${top.length} of ${problems.length})`)
+    `  ${sectionHeading("Top Problems")}` + chalk9.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(`  ${chalk8.dim(hSeg)}  ${chalk8.dim(hVital)}  ${chalk8.dim(hImpact)}`);
+  console.log(`  ${chalk9.dim(hSeg)}  ${chalk9.dim(hVital)}  ${chalk9.dim(hImpact)}`);
   console.log();
   for (let i = 0; i < top.length; i++) {
     const p = top[i];
     const dot = statusDot(p.status);
     const seg = p.segment.padEnd(segW);
     const vital = p.vitalSignLabel.padEnd(vitalW);
-    const dollar = chalk8.green(dollarStrs[i].padStart(dollarW));
-    const label = chalk8.dim(p.dollarLabel);
+    const dollar = chalk9.green(dollarStrs[i].padStart(dollarW));
+    const label = chalk9.dim(p.dollarLabel);
     console.log(`  ${dot} ${seg}  ${vital}  ${dollar}  ${label}`);
   }
   if (problems.length > top.length) {
     console.log();
-    console.log(`  ${chalk8.dim("Run /diagnose --segment <name> to drill in")}`);
+    console.log(`  ${chalk9.dim("Run /diagnose --segment <name> to drill in")}`);
   }
   console.log();
 }
 function printFindings(findings) {
   if (findings.length === 0) {
-    console.log(chalk8.dim("  No findings generated."));
+    console.log(chalk9.dim("  No findings generated."));
     return;
   }
   for (const finding of findings) {
-    const sevColor = finding.severity === "critical" ? chalk8.red : finding.severity === "warning" ? chalk8.yellow : chalk8.blue;
+    const sevColor = finding.severity === "critical" ? chalk9.red : finding.severity === "warning" ? chalk9.yellow : chalk9.blue;
     const dot = sevColor("\u25CF");
-    const dollarTag = finding.dollar_value != null && finding.dollar_value > 0 ? ` ${chalk8.dim("\xB7")} ${chalk8.green(formatDollarValue(finding.dollar_value))}` : "";
-    console.log(`  ${dot} ${chalk8.bold(finding.segment)}${dollarTag}`);
+    const dollarTag = finding.dollar_value != null && finding.dollar_value > 0 ? ` ${chalk9.dim("\xB7")} ${chalk9.green(formatDollarValue(finding.dollar_value))}` : "";
+    console.log(`  ${dot} ${chalk9.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(
-          `  ${chalk8.dim("Consider:")} ${paint("accent", play.play_name)} ${chalk8.dim("\u2192")} ${chalk8.dim("/playbook " + play.play_id)}`
+          `  ${chalk9.dim("Consider:")} ${paint("accent", play.play_name)} ${chalk9.dim("\u2192")} ${chalk9.dim("/playbook " + play.play_id)}`
         );
       }
     }
@@ -7385,7 +8341,7 @@ function printFindings(findings) {
 }
 function printEntityCounts(counts) {
   const table = new Table2({
-    head: [chalk8.dim("Entity"), chalk8.dim("Count")],
+    head: [chalk9.dim("Entity"), chalk9.dim("Count")],
     colWidths: [20, 12],
     style: { head: [], border: [] }
   });
@@ -7400,19 +8356,19 @@ function printSegmentDetail(seg, aggregate) {
   console.log();
   printHeading(seg.segment.name);
   console.log(
-    `  ${statusDot(seg.result.overall_status)} ${color(chalk8.bold(formatScore(seg.result.overall_score)))}${chalk8.dim("/100")}  ${chalk8.dim("Gated by:")} ${paint("accent", VITAL_SIGN_LABELS[seg.result.gating_vital_sign])}`
+    `  ${statusDot(seg.result.overall_status)} ${color(chalk9.bold(formatScore(seg.result.overall_score)))}${chalk9.dim("/100")}  ${chalk9.dim("Gated by:")} ${paint("accent", VITAL_SIGN_LABELS[seg.result.gating_vital_sign])}`
   );
   console.log();
   for (const vs of seg.result.vital_signs) {
     const aggVs = aggregate.vital_signs.find((a) => a.vital_sign === vs.vital_sign);
     const delta = aggVs ? vs.score - aggVs.score : 0;
-    const deltaStr = delta >= 0 ? chalk8.green(`+${Math.round(delta)}`) : chalk8.red(`${Math.round(delta)}`);
+    const deltaStr = delta >= 0 ? chalk9.green(`+${Math.round(delta)}`) : chalk9.red(`${Math.round(delta)}`);
     const dot = statusDot(vs.status);
     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 ? `${chalk8.green(formatCurrency(vs.dollar_value))}  ${chalk8.dim(vs.dollar_label ?? "")}` : chalk8.dim("\u2014");
-    console.log(`  ${dot} ${label} ${bar}  ${chalk8.bold(score)} ${deltaStr.padStart(12)}  ${chalk8.dim("\u2502")}  ${impact}`);
+    const impact = vs.dollar_value != null && vs.dollar_value > 0 ? `${chalk9.green(formatCurrency(vs.dollar_value))}  ${chalk9.dim(vs.dollar_label ?? "")}` : chalk9.dim("\u2014");
+    console.log(`  ${dot} ${label} ${bar}  ${chalk9.bold(score)} ${deltaStr.padStart(12)}  ${chalk9.dim("\u2502")}  ${impact}`);
   }
   console.log();
 }
@@ -7496,7 +8452,7 @@ async function renderDiagnoseStream(options) {
       }
       findingsSpinner.stop();
       console.log(
-        chalk8.dim(`  Investigating... called ${toolCalls} tools across ${iterations} iterations`)
+        chalk9.dim(`  Investigating... called ${toolCalls} tools across ${iterations} iterations`)
       );
       console.log();
       if (storeFindings) {
@@ -7518,7 +8474,7 @@ async function renderDiagnoseStream(options) {
       });
     } catch (err) {
       findingsSpinner.fail(deep ? "Agentic investigation failed" : "AI findings failed");
-      console.error(chalk8.dim(String(err)));
+      console.error(chalk9.dim(String(err)));
     }
   }
   return { fullResult, findings: collectedFindings };
@@ -7526,13 +8482,13 @@ async function renderDiagnoseStream(options) {
 function metricStatusDot(status) {
   switch (status) {
     case "green":
-      return chalk8.green("\u25CF");
+      return chalk9.green("\u25CF");
     case "yellow":
-      return chalk8.yellow("\u25CF");
+      return chalk9.yellow("\u25CF");
     case "red":
-      return chalk8.red("\u25CF");
+      return chalk9.red("\u25CF");
     case "neutral":
-      return chalk8.dim("\u25CB");
+      return chalk9.dim("\u25CB");
   }
 }
 function printMetricsTable(metrics, groupOrder) {
@@ -7542,16 +8498,16 @@ function printMetricsTable(metrics, groupOrder) {
     printHeading(group);
     console.log();
     for (const m of groupMetrics) {
-      const dot = m.unavailable_reason ? chalk8.dim("\u25CB") : metricStatusDot(m.status);
+      const dot = m.unavailable_reason ? chalk9.dim("\u25CB") : metricStatusDot(m.status);
       const label = m.label.padEnd(28);
-      const valueStr = m.unavailable_reason ? chalk8.dim("--") : chalk8.bold(m.formatted);
-      const confTag = m.confidence != null && m.confidence < 80 && m.confidence_label ? chalk8.yellow(` ${m.confidence_label} (${m.confidence})`) : m.confidence != null && m.confidence_label === "high" ? chalk8.dim(" \u2713") : "";
-      const note = m.unavailable_reason ? chalk8.dim(m.unavailable_reason) : m.benchmark_note ? chalk8.dim(m.benchmark_note) : "";
+      const valueStr = m.unavailable_reason ? chalk9.dim("--") : chalk9.bold(m.formatted);
+      const confTag = m.confidence != null && m.confidence < 80 && m.confidence_label ? chalk9.yellow(` ${m.confidence_label} (${m.confidence})`) : m.confidence != null && m.confidence_label === "high" ? chalk9.dim(" \u2713") : "";
+      const note = m.unavailable_reason ? chalk9.dim(m.unavailable_reason) : m.benchmark_note ? chalk9.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(chalk8.dim(`              \u2514 Gate: ${gate}`));
+          console.log(chalk9.dim(`              \u2514 Gate: ${gate}`));
         }
       }
     }
@@ -7575,15 +8531,15 @@ __export(metrics_report_exports, {
   printMetricsNextSteps: () => printMetricsNextSteps,
   renderMetricsReport: () => renderMetricsReport
 });
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 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(chalk9.bold(`  ${title}`));
-  console.log("  " + chalk9.dim(formatCoverageHeader(sourceType, coverage)));
+  console.log(chalk10.bold(`  ${title}`));
+  console.log("  " + chalk10.dim(formatCoverageHeader(sourceType, coverage)));
   console.log();
   printDataQualityPanel(coverage, sourceType, tier);
   if (options.snapshot && coverage.distinct_quarters >= 2) {
@@ -7591,7 +8547,7 @@ function renderMetricsReport(ctx, metrics, coverage, sourceType, options = {}) {
   }
   if (headline) {
     console.log("  " + paint("warning", "\u25B8 Headline"));
-    console.log("  " + chalk9.white(wrapInsight(headline)));
+    console.log("  " + chalk10.white(wrapInsight(headline)));
     console.log();
   }
   printMetricsTable(metrics, GROUP_ORDER);
@@ -7599,9 +8555,9 @@ function renderMetricsReport(ctx, metrics, coverage, sourceType, options = {}) {
     console.log("  " + bold("Pattern checks"));
     console.log();
     for (const insight of deterministic.slice(0, 5)) {
-      const dot = insight.severity === "warning" ? chalk9.yellow("\u25CF") : insight.severity === "critical" ? chalk9.red("\u25CF") : chalk9.dim("\u25CB");
+      const dot = insight.severity === "warning" ? chalk10.yellow("\u25CF") : insight.severity === "critical" ? chalk10.red("\u25CF") : chalk10.dim("\u25CB");
       if (insight.headline) continue;
-      console.log(`  ${dot} ${chalk9.dim(wrapInsight(insight.message))}`);
+      console.log(`  ${dot} ${chalk10.dim(wrapInsight(insight.message))}`);
     }
     console.log();
   }
@@ -7630,7 +8586,7 @@ function printDataQualityPanel(coverage, sourceType, tier) {
     rows.push(["Ledger", "not loaded \u2014 retention inferred from CRM"]);
   }
   for (const [label, value] of rows) {
-    console.log(`  ${chalk9.dim(String(label).padEnd(14))} ${value}`);
+    console.log(`  ${chalk10.dim(String(label).padEnd(14))} ${value}`);
   }
   console.log();
 }
@@ -7641,10 +8597,10 @@ function printCloseTrend(snapshot, cadence) {
   console.log("  " + bold(`Close trend (${cadence})`));
   console.log();
   for (const b of recent) {
-    const newStr = b.new_arr > 0 ? chalk9.dim(` new $${formatShort(b.new_arr)}`) : "";
-    const expStr = b.expansion_arr > 0 ? chalk9.dim(` exp $${formatShort(b.expansion_arr)}`) : "";
+    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)}`) : "";
     console.log(
-      `  ${chalk9.dim(b.period.padEnd(8))} ${chalk9.bold("$" + formatShort(b.closed_won_total))}${newStr}${expStr}  ${chalk9.dim(`(${b.closed_won_count} deals)`)}`
+      `  ${chalk10.dim(b.period.padEnd(8))} ${chalk10.bold("$" + formatShort(b.closed_won_total))}${newStr}${expStr}  ${chalk10.dim(`(${b.closed_won_count} deals)`)}`
     );
   }
   console.log();
@@ -8156,7 +9112,7 @@ var diagnose_exports = {};
 __export(diagnose_exports, {
   handler: () => handler
 });
-import chalk10 from "chalk";
+import chalk11 from "chalk";
 import ora2 from "ora";
 async function handler(args, ctx) {
   await hydrateAnalysisFromPersistedState(ctx);
@@ -8185,9 +9141,9 @@ async function handler(args, ctx) {
   }
   if (options.findings && !canUseReplAi(ctx)) {
     console.log();
-    console.log("  " + chalk10.red("AI findings run only in the interactive REPL."));
-    console.log("  " + chalk10.dim("Vital signs compute without a key \u2014 omit --findings for numbers only."));
-    console.log("  " + chalk10.dim("Start with ") + paint("accent", "ntrp") + chalk10.dim(", set ") + paint("accent", "/config set api-key") + chalk10.dim(" or openai-api-key, then /diagnose --findings."));
+    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(", set ") + paint("accent", "/config set api-key") + chalk11.dim(" or openai-api-key, then /diagnose --findings."));
     console.log();
     return;
   }
@@ -8213,8 +9169,12 @@ async function handler(args, ctx) {
     const companion = await resolveCompanionRecommendation(ctx);
     printCompanionFooter(ctx, companion, { justCompleted: "gtm_health" });
   }
+  if (!ctx.skipTimeBankDiagnoseCredit) {
+    creditDiagnoseComplete(ctx, options.findings);
+  }
+  ctx.skipTimeBankDiagnoseCredit = false;
   if (ctx.oneShot && options.findings) {
-    console.log(chalk10.dim("  For follow-up questions, run `ntrp` and ask in plain English."));
+    console.log(chalk11.dim("  For follow-up questions, run `ntrp` and ask in plain English."));
     console.log();
   }
   return summary;
@@ -8271,7 +9231,7 @@ async function runDiagnose(options, ctx) {
     });
     return buildDiagnoseSummary(fullResult.aggregate, findings);
   } catch (err) {
-    console.error(chalk10.red(String(err)));
+    console.error(chalk11.red(String(err)));
     process.exit(1);
   }
 }
@@ -8283,7 +9243,7 @@ async function runSegmentDiagnose(options) {
     spinner.succeed("Diagnosis complete");
   } catch (err) {
     spinner.fail("Diagnosis failed");
-    console.error(chalk10.red(String(err)));
+    console.error(chalk11.red(String(err)));
     process.exit(1);
   }
   const needle = options.segment.toLowerCase();
@@ -8292,19 +9252,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(chalk10.yellow(`
+      console.error(chalk11.yellow(`
   "${options.segment}" matches multiple segments:`));
-      for (const s of subs) console.log(chalk10.dim(`    - ${s.segment.name}`));
+      for (const s of subs) console.log(chalk11.dim(`    - ${s.segment.name}`));
       console.log();
       return;
     }
   }
   if (!match) {
-    console.error(chalk10.red(`
+    console.error(chalk11.red(`
   No segment matching "${options.segment}".`));
     if (result.segments.length > 0) {
-      console.log(chalk10.dim("  Available segments:"));
-      for (const s of result.segments) console.log(chalk10.dim(`    - ${s.segment.name}`));
+      console.log(chalk11.dim("  Available segments:"));
+      for (const s of result.segments) console.log(chalk11.dim(`    - ${s.segment.name}`));
     }
     console.log();
     return;
@@ -8353,6 +9313,7 @@ var init_diagnose = __esm({
     init_serialize();
     init_theme();
     init_companion();
+    init_time_bank();
   }
 });
 
@@ -8363,7 +9324,7 @@ __export(compute_exports2, {
   runConversationCompute: () => runConversationCompute
 });
 import ora3 from "ora";
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 async function runConversationCompute(ctx) {
   const lens = ctx.scope?.primary_lens ?? ctx.analysis.primary;
   ctx.computeInProgress = true;
@@ -8386,6 +9347,8 @@ async function runConversationCompute(ctx) {
         ctx.snapshot.computeResult = null;
         invalidateGapAudit(ctx);
         saveSessionState(ctx);
+        creditGapCompute(ctx);
+        creditMetricsComplete(ctx, false);
         renderMetricsReport2(ctx, result.metrics.aggregate.metrics, result.coverage, result.data_source_type, {
           snapshot: result.snapshot,
           findings: result.findings,
@@ -8399,6 +9362,8 @@ async function runConversationCompute(ctx) {
       }
     }
     const { handler: diagnose } = await Promise.resolve().then(() => (init_diagnose(), diagnose_exports));
+    ctx.skipTimeBankDiagnoseCredit = true;
+    creditGapCompute(ctx);
     const summary = await diagnose([], ctx);
     markLensCompleted(ctx, "gtm_health");
     ctx.stage = "analyzed";
@@ -8409,7 +9374,7 @@ async function runConversationCompute(ctx) {
     printCompanionFooter(ctx, companion, { justCompleted: "gtm_health" });
     return typeof summary === "string" ? summary : "Health analysis ready";
   } catch (err) {
-    console.error("  " + chalk11.red(String(err.message ?? err)));
+    console.error("  " + chalk12.red(String(err.message ?? err)));
     return;
   } finally {
     ctx.computeInProgress = false;
@@ -8425,16 +9390,17 @@ var init_compute2 = __esm({
     init_context2();
     init_gap_audit();
     init_companion();
+    init_time_bank();
   }
 });
 
 // src/config/demo.ts
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 function printDemoDisabled() {
   console.log();
-  console.log("  " + chalk12.red(DEMO_DISABLED_MESSAGE));
+  console.log("  " + chalk13.red(DEMO_DISABLED_MESSAGE));
   console.log(
-    "  " + chalk12.dim("Re-enable with ") + paint("accent", "/config set demo-enabled true") + chalk12.dim(".")
+    "  " + chalk13.dim("Re-enable with ") + paint("accent", "/config set demo-enabled true") + chalk13.dim(".")
   );
   console.log();
 }
@@ -11182,18 +12148,18 @@ var init_generator = __esm({
 });
 
 // src/demo/taxonomy-cache.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync7, mkdirSync as mkdirSync6, unlinkSync } from "fs";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync7, existsSync as existsSync10, mkdirSync as mkdirSync8, unlinkSync as unlinkSync3 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join7 } from "path";
-function ensureDir3() {
-  if (!existsSync7(NTRP_DIR4)) {
-    mkdirSync6(NTRP_DIR4, { recursive: true });
+import { join as join10 } from "path";
+function ensureDir5() {
+  if (!existsSync10(NTRP_DIR4)) {
+    mkdirSync8(NTRP_DIR4, { recursive: true });
   }
 }
 function loadCachedTaxonomy(profile) {
-  if (!existsSync7(TAXONOMY_PATH)) return null;
+  if (!existsSync10(TAXONOMY_PATH)) return null;
   try {
-    const parsed = JSON.parse(readFileSync5(TAXONOMY_PATH, "utf-8"));
+    const parsed = JSON.parse(readFileSync8(TAXONOMY_PATH, "utf-8"));
     if (!parsed || typeof parsed !== "object") return null;
     if (parsed.profile_updated_at !== profile.updated_at) return null;
     return parsed;
@@ -11202,15 +12168,15 @@ function loadCachedTaxonomy(profile) {
   }
 }
 function saveCachedTaxonomy(taxonomy) {
-  ensureDir3();
-  writeFileSync4(TAXONOMY_PATH, JSON.stringify(taxonomy, null, 2) + "\n");
+  ensureDir5();
+  writeFileSync7(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 = join7(homedir4(), ".ntrp");
-    TAXONOMY_PATH = join7(NTRP_DIR4, "demo-taxonomy.json");
+    NTRP_DIR4 = join10(homedir4(), ".ntrp");
+    TAXONOMY_PATH = join10(NTRP_DIR4, "demo-taxonomy.json");
   }
 });
 
@@ -11446,16 +12412,16 @@ var generate_exports = {};
 __export(generate_exports, {
   handler: () => handler2
 });
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 import ora4 from "ora";
 async function handler2(args, ctx) {
   const { flags } = parseArgs(args, ["list-scenarios", "regen-taxonomy"]);
   const quiet = ctx.execution.quiet;
   if (getBool(flags, "list-scenarios")) {
-    console.log(chalk13.bold("\n  Available Scenarios:\n"));
+    console.log(chalk14.bold("\n  Available Scenarios:\n"));
     for (const s of SCENARIO_LIST) {
-      console.log(`  ${chalk13.cyan(s.key.padEnd(20))} ${s.label}`);
-      console.log(`  ${chalk13.dim(" ".repeat(20))} ${s.description}
+      console.log(`  ${chalk14.cyan(s.key.padEnd(20))} ${s.label}`);
+      console.log(`  ${chalk14.dim(" ".repeat(20))} ${s.description}
 `);
     }
     return true;
@@ -11465,9 +12431,9 @@ async function handler2(args, ctx) {
   const skipProfile = getFalse(flags, "profile");
   if (!isProfileConfigured(profile) && !skipProfile) {
     console.error();
-    console.error("  " + chalk13.red("No company profile found."));
-    console.error("  " + chalk13.dim("Run ") + paint("accent", "/onboard") + chalk13.dim(" first for a richer demo,"));
-    console.error("  " + chalk13.dim("or pass ") + paint("accent", "--no-profile") + chalk13.dim(" to skip."));
+    console.error("  " + chalk14.red("No company profile found."));
+    console.error("  " + chalk14.dim("Run ") + paint("accent", "/onboard") + chalk14.dim(" first for a richer demo,"));
+    console.error("  " + chalk14.dim("or pass ") + paint("accent", "--no-profile") + chalk14.dim(" to skip."));
     console.error();
     markFailure(ctx);
     return false;
@@ -11475,8 +12441,8 @@ async function handler2(args, ctx) {
   const explicitScenario = getString(flags, "scenario", "s");
   const resolvedScenario = resolveScenarioInput(explicitScenario);
   if (resolvedScenario === null) {
-    console.error(chalk13.red(`  Unknown scenario: ${explicitScenario}`));
-    console.log(chalk13.dim(`  Valid: ${SCENARIO_LIST.map((s) => s.key).join(", ")}`));
+    console.error(chalk14.red(`  Unknown scenario: ${explicitScenario}`));
+    console.log(chalk14.dim(`  Valid: ${SCENARIO_LIST.map((s) => s.key).join(", ")}`));
     markFailure(ctx);
     return false;
   }
@@ -11490,7 +12456,7 @@ async function handler2(args, ctx) {
     const s = getScenario(scenario);
     console.log();
     console.log("  " + paint("accent", "\u2713 Scenario: ") + bold(s.label));
-    console.log("  " + chalk13.dim(s.story));
+    console.log("  " + chalk14.dim(s.story));
     console.log();
   }
   const spinner = quiet ? null : ora4({ text: "Initializing database...", discardStdin: false }).start();
@@ -11516,17 +12482,17 @@ async function handler2(args, ctx) {
     const result = await generateDemoData(config);
     if (result.mode === "direct") {
       if (spinner) {
-        spinner.succeed(`Generated demo data for "${chalk13.cyan(scenario)}" scenario`);
+        spinner.succeed(`Generated demo data for "${chalk14.cyan(scenario)}" scenario`);
         console.log();
         printEntityCounts(result.counts);
       }
       if (!quiet && ctx.analysis.primary !== "revenue_metrics") {
-        console.log(chalk13.dim("\n  Run /diagnose to compute vital signs.\n"));
+        console.log(chalk14.dim("\n  Run /diagnose to compute vital signs.\n"));
       }
     }
   } catch (err) {
     if (spinner) spinner.fail("Generation failed");
-    console.error(chalk13.red(String(err)));
+    console.error(chalk14.red(String(err)));
     markFailure(ctx);
     return false;
   }
@@ -11551,7 +12517,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("  " + chalk13.dim(String(err.message ?? err)));
+    console.log("  " + chalk14.dim(String(err.message ?? err)));
     return void 0;
   }
 }
@@ -11641,9 +12607,9 @@ var ingest_exports = {};
 __export(ingest_exports, {
   handler: () => handler3
 });
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 import ora5 from "ora";
-import { readFileSync as readFileSync6, existsSync as existsSync8 } from "fs";
+import { readFileSync as readFileSync9, existsSync as existsSync11 } from "fs";
 import { basename as basename2 } from "path";
 async function handler3(args, ctx) {
   const { positional, flags } = parseArgs(args, [
@@ -11663,21 +12629,21 @@ async function handler3(args, ctx) {
   const source = getString(flags, "source", "s") ?? "salesforce";
   const skipResolve = getBool(flags, "skip-resolve");
   if (!file) {
-    console.error(chalk14.red("  Usage: /ingest <file> [--source salesforce|hubspot|outreach]"));
-    console.error(chalk14.dim("         /ingest --demo [--scenario <name>]"));
+    console.error(chalk15.red("  Usage: /ingest <file> [--source salesforce|hubspot|outreach]"));
+    console.error(chalk15.dim("         /ingest --demo [--scenario <name>]"));
     process.exit(1);
   }
-  if (!existsSync8(file)) {
-    console.error(chalk14.red(`  File not found: ${file}`));
+  if (!existsSync11(file)) {
+    console.error(chalk15.red(`  File not found: ${file}`));
     process.exit(1);
   }
   const profile = loadProfile();
   const skipProfile = getFalse(flags, "profile");
   if (!profile && !skipProfile) {
     console.error();
-    console.error("  " + chalk14.red("No company profile found."));
-    console.error("  " + chalk14.dim("Run ") + paint("accent", "/onboard") + chalk14.dim(" first for better column mapping,"));
-    console.error("  " + chalk14.dim("or pass ") + paint("accent", "--no-profile") + chalk14.dim(" to skip."));
+    console.error("  " + chalk15.red("No company profile found."));
+    console.error("  " + chalk15.dim("Run ") + paint("accent", "/onboard") + chalk15.dim(" first for better column mapping,"));
+    console.error("  " + chalk15.dim("or pass ") + paint("accent", "--no-profile") + chalk15.dim(" to skip."));
     console.error();
     process.exit(1);
   }
@@ -11685,7 +12651,7 @@ async function handler3(args, ctx) {
   try {
     await initSchema();
     spinner.text = "Parsing CSV...";
-    const content = readFileSync6(file, "utf-8");
+    const content = readFileSync9(file, "utf-8");
     const { rows, headers } = parseCSV(content);
     if (rows.length === 0) {
       spinner.fail("CSV is empty");
@@ -11709,22 +12675,22 @@ async function handler3(args, ctx) {
         row_count: result2.imported
       });
       spinner.succeed(
-        `Imported ${chalk14.bold(result2.imported.toString())} revenue events from ${chalk14.dim(basename2(file))}`
+        `Imported ${chalk15.bold(result2.imported.toString())} revenue events from ${chalk15.dim(basename2(file))}`
       );
       if (result2.errors.length > 0) {
-        console.log(chalk14.yellow(`  ${result2.errors.length} rows skipped`));
+        console.log(chalk15.yellow(`  ${result2.errors.length} rows skipped`));
       }
       if (ctx.analysis) {
         ctx.analysis.data_source_type = "revenue_ledger";
       }
-      console.log(chalk14.dim("  Run ") + chalk14.cyan("/metrics") + chalk14.dim(" for SaaS metrics with ledger-backed retention."));
+      console.log(chalk15.dim("  Run ") + chalk15.cyan("/metrics") + chalk15.dim(" for SaaS metrics with ledger-backed retention."));
       return `${result2.imported} revenue events from ${basename2(file)}`;
     }
     spinner.text = "Detecting entity type...";
     const detection = detectEntityType(headers, source);
     if (!detection) {
       spinner.fail(`Could not auto-detect entity type for source: ${source}`);
-      console.log(chalk14.dim("  Headers found: " + headers.join(", ")));
+      console.log(chalk15.dim("  Headers found: " + headers.join(", ")));
       process.exit(1);
     }
     spinner.text = `Importing ${rows.length} ${detection.entityType} rows...`;
@@ -11747,15 +12713,15 @@ async function handler3(args, ctx) {
       row_count: result.imported
     });
     spinner.succeed(
-      `Imported ${chalk14.bold(result.imported.toString())} ${detection.entityType} from ${chalk14.dim(basename2(file))} (${source})`
+      `Imported ${chalk15.bold(result.imported.toString())} ${detection.entityType} from ${chalk15.dim(basename2(file))} (${source})`
     );
     if (result.errors.length > 0) {
-      console.log(chalk14.yellow(`  ${result.errors.length} rows skipped`));
+      console.log(chalk15.yellow(`  ${result.errors.length} rows skipped`));
       for (const err of result.errors.slice(0, 3)) {
-        console.log(chalk14.dim(`    - ${err}`));
+        console.log(chalk15.dim(`    - ${err}`));
       }
       if (result.errors.length > 3) {
-        console.log(chalk14.dim(`    ... and ${result.errors.length - 3} more`));
+        console.log(chalk15.dim(`    ... and ${result.errors.length - 3} more`));
       }
     }
     if (!skipResolve) {
@@ -11772,7 +12738,7 @@ async function handler3(args, ctx) {
     return `${result.imported} ${detection.entityType} from ${basename2(file)}`;
   } catch (err) {
     spinner.fail("Import failed");
-    console.error(chalk14.red(String(err)));
+    console.error(chalk15.red(String(err)));
     process.exit(1);
   }
 }
@@ -11801,10 +12767,10 @@ __export(ingest_chat_exports, {
   loadDemoFromChat: () => loadDemoFromChat,
   looksLikeFilePath: () => looksLikeFilePath
 });
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 import { basename as basename3, resolve as resolve4 } from "path";
 import { homedir as homedir5 } from "os";
-import chalk15 from "chalk";
+import chalk16 from "chalk";
 function extractFilePath(input) {
   const trimmed = input.trim();
   const patterns = [
@@ -11821,11 +12787,11 @@ function extractFilePath(input) {
     const m = trimmed.match(re);
     if (m?.[1]) {
       const p = expandPath(m[1]);
-      if (existsSync9(p)) return p;
+      if (existsSync12(p)) return p;
     }
     if (!m?.[1] && re.test(trimmed) && trimmed.toLowerCase().endsWith(".csv")) {
       const p = expandPath(trimmed.replace(/^["']|["']$/g, ""));
-      if (existsSync9(p)) return p;
+      if (existsSync12(p)) return p;
     }
   }
   return null;
@@ -11839,7 +12805,7 @@ function looksLikeFilePath(input) {
 }
 async function ingestFromChat(ctx, filePath) {
   if (!ctx.rl) {
-    console.log("  " + chalk15.red("Ingest confirm requires interactive mode."));
+    console.log("  " + chalk16.red("Ingest confirm requires interactive mode."));
     return false;
   }
   const name = basename3(filePath);
@@ -11847,7 +12813,7 @@ async function ingestFromChat(ctx, filePath) {
   try {
     const ok = await prompts.confirm(`Ingest ${name} as CRM export?`, true);
     if (!ok) {
-      console.log("  " + chalk15.dim("Ingest cancelled."));
+      console.log("  " + chalk16.dim("Ingest cancelled."));
       return false;
     }
   } finally {
@@ -11855,12 +12821,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: readFileSync10 } = await import("fs");
+  const { readFileSync: readFileSync13 } = 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 = readFileSync10(filePath, "utf-8");
+    const raw = readFileSync13(filePath, "utf-8");
     const { headers } = parseCSV2(raw);
     const detected = detectEntityType2(headers, "unknown");
     if (!detected) headerCheckFailed = true;
@@ -11875,7 +12841,7 @@ async function ingestFromChat(ctx, filePath) {
         false
       );
       if (useAi) {
-        console.log("  " + chalk15.dim("AI column mapping is not wired to ingest yet \u2014 trying standard ingest."));
+        console.log("  " + chalk16.dim("AI column mapping is not wired to ingest yet \u2014 trying standard ingest."));
       }
     } finally {
       prompts2.close();
@@ -11902,7 +12868,7 @@ async function ingestFromChat(ctx, filePath) {
   invalidateGapAudit(ctx);
   saveSessionState(ctx);
   console.log();
-  console.log("  " + paint("accent", "\u2713 Data loaded") + chalk15.dim(` \u2014 ${name}`));
+  console.log("  " + paint("accent", "\u2713 Data loaded") + chalk16.dim(` \u2014 ${name}`));
   recordMessage(ctx, "user", `[ingested ${name}]`);
   recordMessage(ctx, "agent", `Loaded ${name}. Checking what we can analyze\u2026`);
   const audit = await refreshGapAudit(ctx);
@@ -13083,24 +14049,24 @@ var init_embeddings = __esm({
 
 // src/strategies/readers.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync13, 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 = readFileSync7(0, "utf-8");
+    const text2 = readFileSync10(0, "utf-8");
     return createDocument("stdin", null, text2, {});
   }
   const sourcePath = resolve5(pathOrDash);
-  if (!existsSync10(sourcePath)) {
+  if (!existsSync13(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 = readFileSync7(sourcePath, "utf-8");
+  const text = readFileSync10(sourcePath, "utf-8");
   if (ext === ".yaml" || ext === ".yml") {
     const structured = parseStructuredYaml(text);
     return createDocument("yaml", sourcePath, text, structured);
@@ -13115,7 +14081,7 @@ function readStrategyText(text) {
   return createDocument("text", null, text, {});
 }
 async function readPdf(sourcePath) {
-  const data = readFileSync7(sourcePath);
+  const data = readFileSync10(sourcePath);
   const parser = new PDFParse({ data });
   try {
     const result = await parser.getText();
@@ -13304,15 +14270,15 @@ JSON SHAPE:
 });
 
 // src/strategies/library.ts
-import { writeFileSync as writeFileSync5 } from "fs";
-import { join as join9 } from "path";
+import { writeFileSync as writeFileSync8 } from "fs";
+import { join as join12 } from "path";
 import { stringify as stringifyYaml } from "yaml";
 function strategyLibraryPath(slug) {
-  return join9(getStrategiesDir(), `${slug}.md`);
+  return join12(getStrategiesDir(), `${slug}.md`);
 }
 function writeStrategyMarkdown(strategy) {
   const path = strategyLibraryPath(strategy.slug);
-  writeFileSync5(path, renderStrategyMarkdown(strategy), "utf-8");
+  writeFileSync8(path, renderStrategyMarkdown(strategy), "utf-8");
   return path;
 }
 function renderStrategyMarkdown(strategy) {
@@ -13386,7 +14352,7 @@ var init_library = __esm({
 // src/strategies/connectors.ts
 import { readdirSync as readdirSync3, statSync as statSync2 } from "fs";
 import { homedir as homedir6 } from "os";
-import { basename as basename4, extname as extname2, join as join10, relative, resolve as resolve6, sep as sep2 } from "path";
+import { basename as basename4, extname as extname2, join as join13, relative, resolve as resolve6, sep as sep2 } from "path";
 function createLocalFolderConnector(options) {
   const rootPath = resolveUserPath(options.rootPath);
   const name = options.name ?? (basename4(rootPath) || "local");
@@ -13429,7 +14395,7 @@ function createLocalFolderConnector(options) {
 }
 function walkLocalFolder(rootPath, currentPath, refs, opts) {
   for (const entry of readdirSync3(currentPath, { withFileTypes: true })) {
-    const absolutePath = join10(currentPath, entry.name);
+    const absolutePath = join13(currentPath, entry.name);
     const relativePath = normalizePath(relative(rootPath, absolutePath));
     if (entry.isDirectory()) {
       if (shouldSkipDirectory(entry.name) || matchesAny(relativePath, opts.excludePatterns)) continue;
@@ -13493,7 +14459,7 @@ function normalizePath(path) {
 }
 function resolveUserPath(path) {
   if (path === "~") return homedir6();
-  if (path.startsWith("~/")) return join10(homedir6(), path.slice(2));
+  if (path.startsWith("~/")) return join13(homedir6(), path.slice(2));
   return resolve6(path);
 }
 var DEFAULT_MAX_FILES, DEFAULT_MAX_BYTES, SUPPORTED_EXTENSIONS, DEFAULT_EXCLUDED_DIRS;
@@ -13704,9 +14670,9 @@ init_divergence();
 
 // src/memory/store.ts
 init_store();
-import { existsSync as existsSync12, readFileSync as readFileSync9, appendFileSync as appendFileSync4, readdirSync as readdirSync4, writeFileSync as writeFileSync6 } from "fs";
-import { join as join11 } from "path";
-import { randomUUID as randomUUID4 } from "crypto";
+import { existsSync as existsSync15, readFileSync as readFileSync12, appendFileSync as appendFileSync4, readdirSync as readdirSync4, writeFileSync as writeFileSync9 } from "fs";
+import { join as join14 } from "path";
+import { randomUUID as randomUUID5 } from "crypto";
 
 // src/memory/retrieval.ts
 var STOPWORDS = /* @__PURE__ */ new Set([
@@ -13835,18 +14801,18 @@ async function rankByRelevance(query, items, topK) {
 // src/memory/knowledge.ts
 init_store();
 init_readers();
-import { existsSync as existsSync11, readFileSync as readFileSync8, appendFileSync as appendFileSync3, readdirSync as readdirSync2 } from "fs";
-import { join as join8 } from "path";
-import { randomUUID as randomUUID3 } from "crypto";
+import { existsSync as existsSync14, readFileSync as readFileSync11, appendFileSync as appendFileSync3, readdirSync as readdirSync2 } from "fs";
+import { join as join11 } from "path";
+import { randomUUID as randomUUID4 } from "crypto";
 var KNOWLEDGE_FILE = "knowledge.jsonl";
 function knowledgePath() {
-  return join8(getMemoryDir(), KNOWLEDGE_FILE);
+  return join11(getMemoryDir(), KNOWLEDGE_FILE);
 }
 function loadKnowledgeChunks() {
   const path = knowledgePath();
-  if (!existsSync11(path)) return [];
+  if (!existsSync14(path)) return [];
   const out = [];
-  for (const line of readFileSync8(path, "utf-8").split("\n")) {
+  for (const line of readFileSync11(path, "utf-8").split("\n")) {
     const trimmed = line.trim();
     if (!trimmed) continue;
     try {
@@ -13861,13 +14827,13 @@ function loadKnowledgeChunks() {
 var FACTS_FILE = "facts.jsonl";
 var LEDGER_FILE = "ledger.jsonl";
 function memPath(file) {
-  return join11(getMemoryDir(), file);
+  return join14(getMemoryDir(), file);
 }
 function readJsonl(file) {
   const path = memPath(file);
-  if (!existsSync12(path)) return [];
+  if (!existsSync15(path)) return [];
   const out = [];
-  for (const line of readFileSync9(path, "utf-8").split("\n")) {
+  for (const line of readFileSync12(path, "utf-8").split("\n")) {
     const trimmed = line.trim();
     if (!trimmed) continue;
     try {
@@ -13902,7 +14868,7 @@ function loadWinSnippets() {
     const out = [];
     for (const name of readdirSync4(dir)) {
       if (!name.endsWith(".md") || name.toLowerCase() === "readme.md") continue;
-      const raw = readFileSync9(join11(dir, name), "utf-8");
+      const raw = readFileSync12(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}` });