@sonnechasser/ntrp 0.3.2 → 0.3.5

package/dist/services/exports-registry-smoke.js

@@ -0,0 +1,858 @@
+#!/usr/bin/env node
+process.noDeprecation = true;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// src/config/store.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join, resolve } from "path";
+function ntrpHome() {
+  return NTRP_DIR;
+}
+function ensureDir() {
+  if (!existsSync(NTRP_DIR)) {
+    mkdirSync(NTRP_DIR, { recursive: true });
+  }
+}
+function loadConfig() {
+  if (cachedConfig) return cachedConfig;
+  ensureDir();
+  if (!existsSync(CONFIG_PATH)) {
+    cachedConfig = {};
+    return cachedConfig;
+  }
+  try {
+    cachedConfig = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+  } catch {
+    cachedConfig = {};
+  }
+  return cachedConfig;
+}
+function saveConfig(config) {
+  ensureDir();
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
+  cachedConfig = config;
+}
+function resetConfigCache() {
+  cachedConfig = null;
+}
+function setConfigValue(key, value) {
+  const config = loadConfig();
+  config[key] = value;
+  saveConfig(config);
+}
+function getExportsDir() {
+  const config = loadConfig();
+  const dir = resolve(config["export-dir"] ?? join(NTRP_DIR, "exports"));
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function getConfiguredAiInboxDir() {
+  const raw = loadConfig()["ai-inbox-dir"];
+  return raw ? resolve(raw) : null;
+}
+var NTRP_DIR, CONFIG_PATH, cachedConfig;
+var init_store = __esm({
+  "src/config/store.ts"() {
+    "use strict";
+    NTRP_DIR = process.env.NTRP_HOME ? resolve(process.env.NTRP_HOME) : join(homedir(), ".ntrp");
+    CONFIG_PATH = join(NTRP_DIR, "config.json");
+    cachedConfig = null;
+  }
+});
+
+// src/output/formatters.ts
+function formatCurrency(value) {
+  if (value >= 1e6) return `$${(value / 1e6).toFixed(1)}M`;
+  if (value >= 1e3) return `$${(value / 1e3).toFixed(0)}K`;
+  return `$${value.toFixed(0)}`;
+}
+var VITAL_SIGN_LABELS;
+var init_formatters = __esm({
+  "src/output/formatters.ts"() {
+    "use strict";
+    VITAL_SIGN_LABELS = {
+      freshness: "Freshness",
+      flow_rate: "Flow Rate",
+      drop_rate: "Drop Rate",
+      signal_to_noise: "Signal:Noise",
+      thread_depth: "Thread Depth"
+    };
+  }
+});
+
+// src/services/exports-registry-smoke.ts
+init_store();
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readdirSync as readdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync6 } from "fs";
+import { join as join5 } from "path";
+
+// src/services/exports-registry.ts
+init_store();
+import {
+  appendFileSync,
+  copyFileSync,
+  cpSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  readdirSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { basename, dirname, join as join2, resolve as resolve3, sep as sep2 } from "path";
+import { randomUUID } from "crypto";
+
+// src/output/path-safety.ts
+init_store();
+import { homedir as homedir2 } from "os";
+import { resolve as resolve2, sep } from "path";
+var NTRP_HOME = ntrpHome();
+function resolveUserPath(path) {
+  if (path === "~" || path.startsWith("~/") || path.startsWith("~\\")) {
+    return resolve2(homedir2(), path.slice(2));
+  }
+  return resolve2(path);
+}
+function isInsideNtrp(path) {
+  const home = ntrpHome();
+  const resolved = resolve2(path);
+  return resolved === home || resolved.startsWith(home + sep);
+}
+
+// src/services/exports-registry.ts
+var KIND_DIRS = ["handoffs", "reports", "notes", "csv", "publish"];
+var INBOX_ARCHIVE_KEEP = 20;
+function archiveSubdirForKind(kind) {
+  if (kind.startsWith("prompt:")) return "handoffs";
+  if (kind === "report") return "reports";
+  if (kind === "notes") return "notes";
+  if (kind === "csv") return "csv";
+  if (kind === "publish") return "publish";
+  return "handoffs";
+}
+function latestBasenameForKind(kind) {
+  if (kind.startsWith("prompt:")) {
+    const target = kind.slice("prompt:".length);
+    return target ? `handoff-${target}.md` : "handoff.md";
+  }
+  if (kind === "report") return "report.md";
+  if (kind === "notes") return "notes.md";
+  if (kind === "csv") return "csv";
+  if (kind === "publish") return "publish";
+  return "handoff.md";
+}
+function inboxLatestNameForKind(kind) {
+  if (kind.startsWith("prompt:")) {
+    const target = kind.slice("prompt:".length);
+    return target ? `latest-handoff-${target}.md` : "latest-handoff.md";
+  }
+  if (kind === "report") return "latest-report.md";
+  if (kind === "notes") return "latest-notes.md";
+  if (kind === "csv") return "latest-csv";
+  if (kind === "publish") return "latest-publish";
+  return "latest-handoff.md";
+}
+function exportStamp(d = /* @__PURE__ */ new Date()) {
+  return d.toISOString().replace(/T/, "-").replace(/:/g, "").slice(0, 15);
+}
+function ensureExportsLayout(root = getExportsDir()) {
+  mkdirSync2(root, { recursive: true });
+  mkdirSync2(join2(root, "latest"), { recursive: true });
+  for (const sub of KIND_DIRS) {
+    mkdirSync2(join2(root, sub), { recursive: true });
+  }
+  const readme = join2(root, "README.md");
+  if (!existsSync2(readme)) {
+    writeFileSync2(readme, ARCHIVE_README, "utf-8");
+  }
+  if (!existsSync2(join2(root, "INDEX.md"))) {
+    writeFileSync2(join2(root, "INDEX.md"), "# NTRP exports\n\n_No exports yet._\n", "utf-8");
+  }
+  if (!existsSync2(join2(root, "manifest.jsonl"))) {
+    writeFileSync2(join2(root, "manifest.jsonl"), "", "utf-8");
+  }
+  return root;
+}
+function getArchiveKindDir(kind) {
+  const root = ensureExportsLayout();
+  const dir = join2(root, archiveSubdirForKind(kind));
+  mkdirSync2(dir, { recursive: true });
+  return dir;
+}
+function resolveArchivePath(kind, filename) {
+  return join2(getArchiveKindDir(kind), filename);
+}
+function getAiInboxDir() {
+  return getConfiguredAiInboxDir();
+}
+function setAiInboxDir(path) {
+  const resolved = resolveUserPath(path);
+  mkdirSync2(resolved, { recursive: true });
+  setConfigValue("ai-inbox-dir", resolved);
+  ensureInboxLayout(resolved);
+  return resolved;
+}
+function ensureInboxLayout(inbox) {
+  mkdirSync2(inbox, { recursive: true });
+  mkdirSync2(join2(inbox, "archive"), { recursive: true });
+  const readme = join2(inbox, "README.md");
+  writeFileSync2(readme, buildInboxReadme(), "utf-8");
+  if (!existsSync2(join2(inbox, "INDEX.md"))) {
+    writeFileSync2(join2(inbox, "INDEX.md"), "# NTRP AI inbox\n\n_No exports synced yet._\n", "utf-8");
+  }
+}
+function manifestPath(root = getExportsDir()) {
+  return join2(root, "manifest.jsonl");
+}
+function readManifestEvents(root = getExportsDir()) {
+  const path = manifestPath(root);
+  if (!existsSync2(path)) return [];
+  const text = readFileSync2(path, "utf-8");
+  const events = [];
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      events.push(JSON.parse(trimmed));
+    } catch {
+    }
+  }
+  return events;
+}
+function appendManifestEvent(event, root = getExportsDir()) {
+  ensureExportsLayout(root);
+  appendFileSync(manifestPath(root), JSON.stringify(event) + "\n", "utf-8");
+}
+function listExports(opts = {}) {
+  const limit = opts.limit ?? 20;
+  const events = readManifestEvents();
+  const byId = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (e.op === "inbox_sync") continue;
+    byId.set(e.id, e);
+  }
+  let items = [...byId.values()].sort((a, b) => a.at < b.at ? 1 : a.at > b.at ? -1 : 0);
+  if (opts.kind) {
+    const k = opts.kind.toLowerCase();
+    items = items.filter((e) => e.kind === opts.kind || e.kind.startsWith(k) || e.kind.includes(k));
+  }
+  return items.slice(0, limit);
+}
+function findExportByIdOrName(idOrPath) {
+  const items = listExports({ limit: 500 });
+  const needle = idOrPath.trim();
+  const byId = items.find((e) => e.id === needle || e.id.startsWith(needle));
+  if (byId) return byId;
+  const base = basename(needle);
+  const byName = items.find((e) => basename(e.path) === base || e.path.endsWith(needle));
+  if (byName) return byName;
+  const resolved = resolveUserPath(needle);
+  return items.find((e) => e.path === resolved) ?? null;
+}
+function updateArchiveLatest(kind, sourcePath, root) {
+  const latestDir = join2(root, "latest");
+  mkdirSync2(latestDir, { recursive: true });
+  const name = latestBasenameForKind(kind);
+  const dest = join2(latestDir, name);
+  copyPath(sourcePath, dest);
+  if (kind.startsWith("prompt:")) {
+    copyPath(sourcePath, join2(latestDir, "handoff.md"));
+  }
+}
+function copyPath(src, dest) {
+  mkdirSync2(dirname(dest), { recursive: true });
+  if (existsSync2(dest)) {
+    rmSync(dest, { recursive: true, force: true });
+  }
+  const st = statSync(src);
+  if (st.isDirectory()) {
+    cpSync(src, dest, { recursive: true });
+  } else {
+    copyFileSync(src, dest);
+  }
+}
+function regenerateIndex(root = getExportsDir()) {
+  ensureExportsLayout(root);
+  const items = listExports({ limit: 50 });
+  const events = readManifestEvents(root);
+  const withHistory = items.filter((e) => (e.previous_paths?.length ?? 0) > 0);
+  const latestDir = join2(root, "latest");
+  const latestLines = [];
+  if (existsSync2(latestDir)) {
+    for (const name of readdirSync(latestDir).sort()) {
+      latestLines.push(`- \`latest/${name}\` \u2192 \`${join2(latestDir, name)}\``);
+    }
+  }
+  const lines = [
+    "# NTRP exports",
+    "",
+    `Archive root: \`${root}\``,
+    "",
+    "Desktop AI tip: set an inbox with `/inbox set <folder>` and open that folder's `latest-handoff.md` or `INDEX.md`.",
+    "",
+    "## Latest pointers",
+    ""
+  ];
+  if (latestLines.length > 0) lines.push(...latestLines);
+  else lines.push("_None yet._");
+  lines.push("", "## Recent exports", "");
+  if (items.length === 0) {
+    lines.push("_No exports yet._");
+  } else {
+    for (const e of items) {
+      const title = e.title ? ` \u2014 ${e.title}` : "";
+      const session = e.session_id ? ` \xB7 session ${e.session_id.slice(-4)}` : "";
+      lines.push(`- **${e.kind}** (${e.at})${title}${session}`);
+      lines.push(`  - id: \`${e.id}\``);
+      lines.push(`  - path: \`${e.path}\``);
+      if (e.inbox_path) lines.push(`  - inbox: \`${e.inbox_path}\``);
+    }
+  }
+  lines.push("", "## Location history", "");
+  if (withHistory.length === 0) {
+    lines.push("_No moves recorded._");
+  } else {
+    for (const e of withHistory) {
+      lines.push(`- **${e.kind}** \`${e.id}\``);
+      for (const prev of e.previous_paths ?? []) {
+        lines.push(`  - was: \`${prev}\``);
+      }
+      lines.push(`  - now: \`${e.path}\``);
+    }
+  }
+  const moveOps = events.filter((e) => e.op === "move").slice(-20).reverse();
+  if (moveOps.length > 0) {
+    lines.push("", "## Recent moves", "");
+    for (const e of moveOps) {
+      const from = e.previous_paths?.[e.previous_paths.length - 1] ?? "?";
+      lines.push(`- ${e.at}: \`${from}\` \u2192 \`${e.path}\` (${e.kind}, \`${e.id}\`)`);
+    }
+  }
+  lines.push("");
+  writeFileSync2(join2(root, "INDEX.md"), lines.join("\n"), "utf-8");
+}
+function regenerateInboxIndex(inbox) {
+  ensureInboxLayout(inbox);
+  const items = listExports({ limit: 15 });
+  const archiveRoot = getExportsDir();
+  const lines = [
+    "# NTRP AI inbox",
+    "",
+    "Start here. Prefer `latest-handoff.md` (or `latest-handoff-<target>.md`) for the newest agent prompt.",
+    "",
+    `Canonical archive: \`${archiveRoot}\` (see \`${join2(archiveRoot, "INDEX.md")}\`).`,
+    "",
+    "## Latest pointers",
+    ""
+  ];
+  const latestNames = readdirSync(inbox).filter((n) => n.startsWith("latest-")).sort();
+  if (latestNames.length === 0) lines.push("_None yet \u2014 run a handoff after `/inbox set`._");
+  else {
+    for (const name of latestNames) {
+      lines.push(`- [\`${name}\`](./${name})`);
+    }
+  }
+  lines.push("", "## Recent exports", "");
+  if (items.length === 0) lines.push("_No exports yet._");
+  else {
+    for (const e of items) {
+      lines.push(`- **${e.kind}** (${e.at}): \`${e.path}\``);
+      if (e.inbox_path) lines.push(`  - inbox copy: \`${e.inbox_path}\``);
+    }
+  }
+  lines.push("");
+  writeFileSync2(join2(inbox, "INDEX.md"), lines.join("\n"), "utf-8");
+  writeFileSync2(join2(inbox, "README.md"), buildInboxReadme(), "utf-8");
+}
+function buildInboxReadme() {
+  const archive = getExportsDir();
+  return `# NTRP AI inbox
+
+This folder is the Claude Desktop / desktop-AI landing zone for NTRP handoffs.
+
+## Start here
+
+1. Open \`INDEX.md\` for the catalog
+2. Or open \`latest-handoff.md\` (or \`latest-handoff-deck.md\`, etc.) for the newest prompt
+
+Stable \`latest-*\` files are overwritten on every export. Dated copies live in \`archive/\`.
+
+## Canonical archive
+
+The full history (with move trail) lives at:
+
+\`${archive}\`
+
+See \`${join2(archive, "INDEX.md")}\` and \`${join2(archive, "manifest.jsonl")}\`.
+
+Configure with \`/inbox set <path>\` \xB7 clear with \`/inbox clear\` \xB7 list with \`/exports\`.
+`;
+}
+var ARCHIVE_README = `# NTRP exports archive
+
+Handoffs, reports, notes, CSV receipts, and publish packages land here by kind:
+
+- \`handoffs/\` \u2014 agent prompts (\`handoff-deck-*.md\`, \u2026)
+- \`reports/\` \u2014 markdown reports
+- \`notes/\` \u2014 Obsidian-style notes
+- \`csv/\` \u2014 backmeup receipt folders
+- \`publish/\` \u2014 repository export packages
+- \`latest/\` \u2014 stable copies of the newest file per kind
+
+\`INDEX.md\` is regenerated from \`manifest.jsonl\` on every write/move.
+
+Point a desktop AI app at a dedicated inbox instead of this folder:
+
+\`\`\`
+/inbox set ~/Documents/Claude/ntrp-inbox
+\`\`\`
+`;
+function pruneInboxArchive(archiveDir, keep = INBOX_ARCHIVE_KEEP) {
+  if (!existsSync2(archiveDir)) return;
+  const entries = readdirSync(archiveDir).map((name) => {
+    const p = join2(archiveDir, name);
+    try {
+      return { name, path: p, mtime: statSync(p).mtimeMs };
+    } catch {
+      return null;
+    }
+  }).filter((e) => e != null).sort((a, b) => b.mtime - a.mtime);
+  for (const old of entries.slice(keep)) {
+    rmSync(old.path, { recursive: true, force: true });
+  }
+}
+function syncAiInbox(entry) {
+  const inbox = getAiInboxDir();
+  if (!inbox) return null;
+  if (!existsSync2(entry.path)) return null;
+  ensureInboxLayout(inbox);
+  const archiveDir = join2(inbox, "archive");
+  mkdirSync2(archiveDir, { recursive: true });
+  const base = basename(entry.path);
+  const archiveDest = join2(archiveDir, base);
+  copyPath(entry.path, archiveDest);
+  pruneInboxArchive(archiveDir);
+  const latestName = inboxLatestNameForKind(entry.kind);
+  const latestDest = join2(inbox, latestName);
+  copyPath(entry.path, latestDest);
+  if (entry.kind.startsWith("prompt:")) {
+    copyPath(entry.path, join2(inbox, "latest-handoff.md"));
+  }
+  regenerateInboxIndex(inbox);
+  return latestDest;
+}
+function recordExportWrite(opts) {
+  const root = ensureExportsLayout();
+  const path = resolve3(opts.path);
+  if (!existsSync2(path)) {
+    throw new Error(`Export path does not exist: ${path}`);
+  }
+  updateArchiveLatest(opts.kind, path, root);
+  const inboxPath = syncAiInbox({ kind: opts.kind, path });
+  const event = {
+    id: randomUUID().slice(0, 8),
+    op: "write",
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    kind: opts.kind,
+    path,
+    session_id: opts.sessionId,
+    title: opts.title,
+    inbox_path: inboxPath ?? void 0
+  };
+  appendManifestEvent(event, root);
+  regenerateIndex(root);
+  return event;
+}
+function moveExport(idOrPath, destDir) {
+  const item = findExportByIdOrName(idOrPath);
+  if (!item) {
+    throw new Error(`No export matching "${idOrPath}". Try /exports list.`);
+  }
+  if (!existsSync2(item.path)) {
+    throw new Error(`Export file missing on disk: ${item.path}`);
+  }
+  const destRoot = resolveUserPath(destDir);
+  mkdirSync2(destRoot, { recursive: true });
+  const name = basename(item.path);
+  let destPath = join2(destRoot, name);
+  if (existsSync2(destPath)) {
+    destPath = join2(destRoot, `${exportStamp()}-${name}`);
+  }
+  renameSync(item.path, destPath);
+  const previous = [...item.previous_paths ?? [], item.path];
+  updateArchiveLatest(item.kind, destPath, ensureExportsLayout());
+  const inboxPath = syncAiInbox({ kind: item.kind, path: destPath });
+  const event = {
+    id: item.id,
+    op: "move",
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    kind: item.kind,
+    path: destPath,
+    previous_paths: previous,
+    session_id: item.session_id,
+    title: item.title,
+    inbox_path: inboxPath ?? void 0
+  };
+  appendManifestEvent(event);
+  regenerateIndex();
+  return event;
+}
+function archiveIndexPath() {
+  return join2(ensureExportsLayout(), "INDEX.md");
+}
+function inboxLatestHandoffPath() {
+  const inbox = getAiInboxDir();
+  if (!inbox) return null;
+  const p = join2(inbox, "latest-handoff.md");
+  return existsSync2(p) ? p : null;
+}
+
+// src/services/context-doc.ts
+import { writeFileSync as writeFileSync5 } from "fs";
+
+// src/cli/context.ts
+import { basename as basename2, join as join4, resolve as resolve4, sep as sep3 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, writeFileSync as writeFileSync4, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2, rmSync as rmSync3 } from "fs";
+import { homedir as homedir3 } from "os";
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/services/transcript.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, rmSync as rmSync2 } from "fs";
+import { join as join3 } from "path";
+
+// src/services/terminal-capture.ts
+var SECRET_PATTERNS = [
+  /\bsk-ant-[A-Za-z0-9_-]{8,}/g,
+  // Anthropic
+  /\bsk-or-[A-Za-z0-9_-]{8,}/g,
+  // OpenRouter
+  /\bsk-proj-[A-Za-z0-9_-]{8,}/g,
+  // OpenAI project keys
+  /\bsk-[A-Za-z0-9_-]{20,}/g,
+  // OpenAI / generic sk-
+  /\bgsk_[A-Za-z0-9_-]{8,}/g,
+  // Groq
+  /\bxai-[A-Za-z0-9_-]{8,}/g,
+  // xAI
+  /\bfw_[A-Za-z0-9_-]{8,}/g,
+  // Fireworks
+  /\bAIza[A-Za-z0-9_-]{10,}/g,
+  // Google
+  /\bNTRP-[A-Z0-9][A-Z0-9-]{8,}/g
+  // license keys
+];
+function redactSecrets(line) {
+  let out = line;
+  for (const pattern of SECRET_PATTERNS) {
+    out = out.replace(pattern, (m) => `${m.slice(0, 6)}\u2026[redacted]`);
+  }
+  return out;
+}
+
+// src/cli/context.ts
+var STALE_SESSION_MS = 14 * 24 * 60 * 60 * 1e3;
+function ntrpHomeDir() {
+  return process.env.NTRP_HOME ? resolve4(process.env.NTRP_HOME) : join4(homedir3(), ".ntrp");
+}
+function getSessionsDir() {
+  const dir = join4(ntrpHomeDir(), "sessions");
+  if (!existsSync4(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+  return dir;
+}
+function getDatasetsDir() {
+  const dir = join4(ntrpHomeDir(), "datasets");
+  if (!existsSync4(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+  return dir;
+}
+function datasetPathForSession(id) {
+  return join4(getDatasetsDir(), `${id}.duckdb`);
+}
+function transcriptPathForSession(id) {
+  return join4(getSessionsDir(), `${id}.transcript.md`);
+}
+function defaultSessionAnalysis(primary = "gtm_health") {
+  return { primary, completed: [] };
+}
+
+// src/services/context-doc.ts
+init_formatters();
+init_store();
+var AGENT_EXCERPT_CHARS = 400;
+function buildSessionContextDoc(file, opts = {}) {
+  const id = file.id;
+  const shortId = id.slice(-4);
+  const exchanges = file.exchange_count ?? Math.floor(file.messages.length / 2);
+  const lines = [];
+  lines.push(`# Session context \u2014 ${id}${file.name ? ` (${file.name})` : ""}`);
+  lines.push("");
+  lines.push("## Status");
+  lines.push("");
+  lines.push(`- Stage: ${file.stage ?? "new"}`);
+  lines.push(`- Created: ${file.created_at}`);
+  if (file.ended_at) lines.push(`- Ended: ${file.ended_at}`);
+  lines.push(`- Updated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push(`- Exchanges: ${exchanges}`);
+  if (file.summary) lines.push(`- Summary: ${file.summary}`);
+  if (file.resumed_from) lines.push(`- Resumed from: ${file.resumed_from}`);
+  lines.push("");
+  lines.push("## Dataset");
+  lines.push("");
+  if (file.dataset?.label || file.dataset?.source) {
+    lines.push(`- Label: ${file.dataset.label ?? "(unlabeled)"}`);
+    if (file.dataset.source) lines.push(`- Source: ${file.dataset.source}`);
+    if (file.dataset.ingested_at) lines.push(`- Ingested: ${file.dataset.ingested_at}`);
+    const counts = Object.entries(file.dataset.counts ?? {}).filter(([, n]) => n > 0);
+    if (counts.length > 0) {
+      lines.push(`- Counts: ${counts.map(([k, n]) => `${n.toLocaleString()} ${k}`).join(", ")}`);
+    }
+  } else {
+    lines.push("- No data loaded.");
+  }
+  if (file.attachments && file.attachments.length > 0) {
+    for (const a of file.attachments) {
+      const detail = [a.entity_type, a.row_count != null ? `${a.row_count} rows` : null].filter(Boolean).join(", ");
+      lines.push(`- Attachment: ${a.path}${detail ? ` (${detail})` : ""}`);
+    }
+  }
+  lines.push("");
+  if (file.scope) {
+    lines.push("## Scope");
+    lines.push("");
+    lines.push(`- Intent: ${file.scope.intent_summary}`);
+    lines.push(`- Lens: ${file.scope.primary_lens}`);
+    if (file.scope.audience) lines.push(`- Audience: ${file.scope.audience}`);
+    if (file.scope.time_horizon) lines.push(`- Time horizon: ${file.scope.time_horizon}`);
+    if (file.scope.segments?.length) lines.push(`- Segments: ${file.scope.segments.join(", ")}`);
+    if (file.scope.confirmed_at) lines.push(`- Confirmed: ${file.scope.confirmed_at}`);
+    lines.push("");
+  }
+  lines.push("## Analysis");
+  lines.push("");
+  if (file.analysis) {
+    lines.push(`- Primary lens: ${file.analysis.primary}`);
+    lines.push(`- Completed: ${file.analysis.completed.join(", ") || "none"}`);
+    if (file.analysis.coverage) {
+      lines.push(
+        `- Coverage: ${file.analysis.coverage.distinct_months} months \xB7 recommended cadence ${file.analysis.coverage.recommended_cadence}`
+      );
+    }
+    if (file.analysis.data_source_type) {
+      lines.push(`- Data source type: ${file.analysis.data_source_type}`);
+    }
+    if (file.analysis.headline?.length) {
+      lines.push("");
+      lines.push("### Headline metrics");
+      lines.push("");
+      for (const h of file.analysis.headline) {
+        lines.push(`- ${h.label}: ${h.formatted}`);
+      }
+    }
+  } else {
+    lines.push("- No analysis recorded.");
+  }
+  const health = opts.snapshot?.aggregate;
+  if (health) {
+    lines.push("");
+    lines.push("### GTM health snapshot");
+    lines.push("");
+    lines.push(`- Overall: ${Math.round(health.overall_score)} (${health.overall_status})`);
+    lines.push(`- Gating vital sign: ${health.gating_vital_sign.replace(/_/g, " ")}`);
+    if (health.total_value_at_risk != null && health.total_value_at_risk > 0) {
+      lines.push(`- Total value at risk: ${formatCurrency(health.total_value_at_risk)}`);
+    }
+    for (const vs of health.vital_signs) {
+      const label = VITAL_SIGN_LABELS[vs.vital_sign] ?? vs.vital_sign;
+      const dollars = vs.dollar_value != null ? ` \u2014 ${formatCurrency(vs.dollar_value)}${vs.dollar_label ? ` ${vs.dollar_label}` : ""}` : "";
+      lines.push(`- ${label}: ${Math.round(vs.score)} (${vs.status})${dollars}`);
+    }
+  }
+  lines.push("");
+  if (file.strategist) {
+    lines.push("## Strategist (in flight)");
+    lines.push("");
+    lines.push(`- Step: ${file.strategist.step}`);
+    if (file.strategist.objective) lines.push(`- Objective: ${file.strategist.objective}`);
+    if (file.strategist.constraintsNote) {
+      lines.push(`- Constraints: ${file.strategist.constraintsNote}`);
+    }
+    if (file.strategist.origin) lines.push(`- Origin: ${file.strategist.origin}`);
+    lines.push("");
+  }
+  lines.push("## Deliverables");
+  lines.push("");
+  if (file.deliverables && file.deliverables.length > 0) {
+    for (const d of file.deliverables) {
+      const detail = [d.path, d.note].filter(Boolean).join(" \u2014 ");
+      lines.push(`- ${d.kind} (${d.at})${detail ? `: ${detail}` : ""}`);
+    }
+  } else {
+    lines.push("- None yet.");
+  }
+  lines.push("");
+  lines.push("## Exports");
+  lines.push("");
+  try {
+    lines.push(`- Archive index: \`${archiveIndexPath()}\``);
+    lines.push(`- Archive root: \`${getExportsDir()}\``);
+    const inbox = getAiInboxDir();
+    if (inbox) {
+      lines.push(`- AI inbox: \`${inbox}\` (open \`latest-handoff.md\` or \`INDEX.md\`)`);
+    } else {
+      lines.push("- AI inbox: unset \u2014 `/inbox set <folder>` for Claude Desktop");
+    }
+  } catch {
+    lines.push("- Export catalog unavailable.");
+  }
+  lines.push("");
+  lines.push(`## Conversation (${exchanges} exchange${exchanges === 1 ? "" : "s"})`);
+  lines.push("");
+  if (file.messages.length === 0) {
+    lines.push("- No exchanges yet.");
+  } else {
+    let n = 0;
+    for (const msg of file.messages) {
+      if (msg.role === "user") {
+        n++;
+        lines.push(`${n}. \u276F ${excerpt(msg.content, AGENT_EXCERPT_CHARS)}`);
+      } else {
+        lines.push(`   \u21B3 ${excerpt(msg.content, AGENT_EXCERPT_CHARS)}`);
+      }
+    }
+  }
+  lines.push("");
+  lines.push("## Files");
+  lines.push("");
+  lines.push(`- Transcript (raw terminal): \`${transcriptPathForSession(id)}\``);
+  lines.push(`- Session data (JSON): \`${sessionJsonPath(id)}\``);
+  lines.push(`- Dataset (DuckDB): \`${datasetPathForSession(id)}\``);
+  lines.push("");
+  lines.push("## Pick up this session");
+  lines.push("");
+  lines.push(`Run \`ntrp\`, then \`/session ${shortId}\` \u2014 rebinds the dataset and reloads the`);
+  lines.push("conversation thread in place. Read the transcript above for the full terminal");
+  lines.push("history before continuing.");
+  lines.push("");
+  return lines.map(redactSecrets).join("\n");
+}
+function excerpt(content, max) {
+  const flat = content.replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
+}
+function sessionJsonPath(id) {
+  return `${getSessionsDir()}/${id}.json`;
+}
+
+// src/services/exports-registry-smoke.ts
+var failures = [];
+function assert(cond, msg) {
+  if (!cond) failures.push(msg);
+}
+function section(name) {
+  console.log(`  \xB7 ${name}`);
+}
+section("archive layout + write");
+{
+  resetConfigCache();
+  const root = ensureExportsLayout();
+  assert(existsSync5(join5(root, "handoffs")), "handoffs/ created");
+  assert(existsSync5(join5(root, "README.md")), "archive README seeded");
+  assert(existsSync5(join5(root, "manifest.jsonl")), "manifest.jsonl seeded");
+  const out = resolveArchivePath("prompt:deck", `handoff-deck-${exportStamp()}.md`);
+  writeFileSync6(out, "# Deck handoff\n\nBuild slides from this.\n", "utf-8");
+  const event = recordExportWrite({
+    kind: "prompt:deck",
+    path: out,
+    sessionId: "sess-abcd1234",
+    title: "deck handoff prompt"
+  });
+  assert(event.kind === "prompt:deck", "kind recorded");
+  assert(existsSync5(join5(root, "latest", "handoff-deck.md")), "latest/handoff-deck.md");
+  assert(existsSync5(join5(root, "latest", "handoff.md")), "latest/handoff.md generic");
+  const index = readFileSync5(archiveIndexPath(), "utf-8");
+  assert(index.includes("prompt:deck"), "INDEX mentions kind");
+  assert(index.includes(out), "INDEX mentions path");
+  assert(readManifestEvents().some((e) => e.op === "write" && e.path === out), "manifest write event");
+}
+section("ai inbox sync");
+{
+  const inbox = join5(ntrpHome(), "claude-inbox");
+  setAiInboxDir(inbox);
+  assert(getAiInboxDir() === inbox, "inbox config set");
+  assert(existsSync5(join5(inbox, "README.md")), "inbox README");
+  const out = resolveArchivePath("prompt:plan", `handoff-plan-${exportStamp()}.md`);
+  writeFileSync6(out, "# Plan handoff\n", "utf-8");
+  const event = recordExportWrite({ kind: "prompt:plan", path: out, title: "plan" });
+  assert(typeof event.inbox_path === "string", "inbox_path on write event");
+  assert(existsSync5(join5(inbox, "latest-handoff.md")), "latest-handoff.md");
+  assert(existsSync5(join5(inbox, "latest-handoff-plan.md")), "latest-handoff-plan.md");
+  assert(existsSync5(join5(inbox, "archive")), "inbox archive dir");
+  assert(readdirSync3(join5(inbox, "archive")).length >= 1, "dated copy in inbox archive");
+  const inboxIndex = readFileSync5(join5(inbox, "INDEX.md"), "utf-8");
+  assert(inboxIndex.includes("latest-handoff"), "inbox INDEX lists latest");
+  assert(inboxLatestHandoffPath() === join5(inbox, "latest-handoff.md"), "inboxLatestHandoffPath");
+}
+section("move trail");
+{
+  const items = listExports({ limit: 10, kind: "prompt" });
+  assert(items.length >= 1, "listExports returns items");
+  const target = items.find((e) => e.kind === "prompt:deck") ?? items[0];
+  const dest = join5(ntrpHome(), "moved-exports");
+  mkdirSync4(dest, { recursive: true });
+  const moved = moveExport(target.id, dest);
+  assert(moved.op === "move", "move op");
+  assert(moved.path.startsWith(dest), `moved under dest (got ${moved.path})`);
+  assert((moved.previous_paths?.length ?? 0) >= 1, "previous_paths recorded");
+  assert(existsSync5(moved.path), "file exists at new path");
+  assert(!existsSync5(target.path), "old path gone");
+  const index = readFileSync5(archiveIndexPath(), "utf-8");
+  assert(index.includes("Location history") || index.includes("Recent moves"), "INDEX has history section");
+  assert(index.includes(moved.previous_paths[0]), "INDEX shows previous path");
+}
+section("kind dirs");
+{
+  assert(getArchiveKindDir("notes").endsWith(`${join5("exports", "notes")}`) || getArchiveKindDir("notes").includes("/notes"), "notes kind dir");
+  assert(getArchiveKindDir("csv").includes("/csv") || getArchiveKindDir("csv").includes("\\csv"), "csv kind dir");
+  assert(getArchiveKindDir("report").includes("reports"), "reports kind dir");
+}
+section("path-safety NTRP_HOME");
+{
+  const home = ntrpHome();
+  assert(isInsideNtrp(join5(home, "exports")), "exports inside NTRP_HOME");
+  assert(!isInsideNtrp("/tmp/not-ntrp-exports"), "foreign path outside");
+  const expanded = resolveUserPath("~/Documents/test-inbox");
+  assert(expanded.includes("Documents"), "tilde expands");
+}
+section("context brief exports blurb");
+{
+  const file = {
+    id: "sess-exports-test",
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    messages: [],
+    stage: "delivered",
+    analysis: defaultSessionAnalysis(),
+    deliverables: [{ kind: "prompt:deck", at: (/* @__PURE__ */ new Date()).toISOString(), path: "/tmp/deck.md" }]
+  };
+  const doc = buildSessionContextDoc(file);
+  assert(doc.includes("## Exports"), "context doc has Exports section");
+  assert(doc.includes("## Deliverables"), "context doc has Deliverables");
+  assert(doc.includes("/tmp/deck.md"), "deliverable path shown");
+  assert(doc.includes("AI inbox"), "mentions AI inbox");
+}
+if (failures.length > 0) {
+  console.error("\nexports-registry smoke FAILED:");
+  for (const f of failures) console.error(`  \u2717 ${f}`);
+  process.exit(1);
+}
+console.log("\nexports-registry smoke OK");
+//# sourceMappingURL=exports-registry-smoke.js.map