@sonnechasser/ntrp 0.2.1 → 0.2.2

package/dist/mcp/server.js

@@ -5855,6 +5855,736 @@ var init_playbook = __esm({
   }
 });
 
+// src/workflows/registry.ts
+function parseFrontmatter(raw) {
+  if (!raw.startsWith("---")) return { meta: {}, body: raw };
+  const end = raw.indexOf("\n---", 3);
+  if (end === -1) return { meta: {}, body: raw };
+  const fm = raw.slice(3, end).trim();
+  const body = raw.slice(end + 4).replace(/^\r?\n/, "");
+  const meta = {};
+  for (const line of fm.split("\n")) {
+    const match = line.match(/^(\w+):\s*(.*)$/);
+    if (!match) continue;
+    let value = match[2].trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    meta[match[1]] = value;
+  }
+  return { meta, body: body.trim() };
+}
+function loadRegistry() {
+  if (registry) return registry;
+  registry = /* @__PURE__ */ new Map();
+  for (const entry of EMBEDDED_WORKFLOWS) {
+    const { meta: fm, body } = parseFrontmatter(entry.raw);
+    const meta = {
+      name: fm.name ?? entry.name,
+      description: fm.description ?? "",
+      section: fm.section ?? "Other",
+      args: fm.args,
+      handler: fm.handler ?? "",
+      body,
+      hidden: fm.hidden === "true"
+    };
+    registry.set(meta.name, { meta, handler: null });
+  }
+  return registry;
+}
+function listWorkflows(includeHidden = false) {
+  const all2 = Array.from(loadRegistry().values()).map((e) => e.meta);
+  return includeHidden ? all2 : all2.filter((m) => !m.hidden);
+}
+var registry, EMBEDDED_WORKFLOWS;
+var init_registry = __esm({
+  "src/workflows/registry.ts"() {
+    "use strict";
+    registry = null;
+    EMBEDDED_WORKFLOWS = [
+      {
+        name: "new",
+        raw: `---
+name: new
+description: Start a new analysis \u2014 one menu picks data + first report
+section: Hidden
+hidden: true
+args: [<file.csv>] | --demo [--scenario <name>] | --empty [--lens health|metrics]
+handler: ../commands/new.ts
+---
+
+Start a fresh point-in-time analysis. Interactive mode uses **one menu**: demo \u2192
+health, demo \u2192 metrics, your CSV, or empty. Loads data and runs the first report
+(formulas only \u2014 no AI unless you add \`--findings\` later). Demo metrics works
+without \`/onboard\`; your own CSV needs a profile for metrics calibration.
+After the report, **ask questions in plain English** \u2014 no slash needed.`
+      },
+      {
+        name: "end",
+        raw: `---
+name: end
+description: Close the current analysis without a handoff
+section: Start
+args: 
+handler: ../commands/end.ts
+---
+
+Mark the current session as finished even when you didn't produce a report or
+other output. It drops off the "in progress" list, saves your transcript and
+dataset anchor for later, and rotates you to a fresh empty session. Use
+\`/handoff\` instead when you want to ship something.`
+      },
+      {
+        name: "session",
+        raw: `---
+name: session
+description: Pick up or browse your analyses
+section: Hidden
+hidden: true
+args: [<id|name>] | new
+handler: ../commands/session.ts
+---
+
+Move between your point-in-time analyses. With no arguments, lists your
+sessions with unfinished work (reached insight, never delivered) surfaced
+first. Pass a session id (or type the 4-char suffix after listing) to pick it
+back up \u2014 this rebinds its dataset and conversation so you continue exactly
+where you left off. \`new\` starts a fresh analysis.`
+      },
+      {
+        name: "handoff",
+        raw: `---
+name: handoff
+description: Turn the analysis into an output
+section: Start
+args: [report|notes|csv|publish|prompt] [deck|asana|clay|plan]
+handler: ../commands/handoff.ts
+---
+
+Close the loop to action. Produce a markdown report, a notes export, CSV
+receipts, or a repository package \u2014 or generate a ready-to-paste prompt for
+another agent to build a review deck, an Asana project, a Clay table, or an
+action plan from this diagnosis. Producing an output marks the session
+delivered so it stops showing up as unfinished work.`
+      },
+      {
+        name: "onboard",
+        raw: `---
+name: onboard
+description: Set up your company profile
+section: Settings
+handler: ../commands/onboard.ts
+---
+
+Run the first-run wizard to build a rich company profile. Configures one or
+two LLM engines (Anthropic and/or OpenAI), then asks
+a few seed questions and uses AI to draft industry, ICP, deal size, and stack
+guesses. Profile is stored at \`~/.ntrp/profile.json\` and flows into every
+AI surface (findings, NL answers, demo generation).`
+      },
+      {
+        name: "sessions",
+        raw: `---
+name: sessions
+description: Browse past session history
+section: More
+args: [list|show <id>]
+handler: ../commands/sessions.ts
+hidden: true
+---
+
+List and inspect past REPL sessions. Shows session dates, AI-generated
+summaries, and exchange counts. Use \`show <id>\` to view the full
+conversation from a specific session.`
+      },
+      {
+        name: "setup",
+        raw: `---
+name: setup
+description: Configure NTRP for headless and agent use
+section: Settings
+args: check | agent [--profile <file|->]
+handler: ../commands/setup.ts
+---
+
+Validate local readiness or configure NTRP non-interactively for automation.
+\`setup check --json\` reports license, profile, API key, database, and writable
+directory state. \`setup agent\` accepts a profile JSON file or direct flags \u2014
+\`--llm-key <key>\` auto-detects the provider from any pasted key
+(\`--llm-provider <id>\` to force one).`
+      },
+      {
+        name: "update",
+        raw: `---
+name: update
+description: Update NTRP to the latest version
+section: Settings
+handler: ../commands/update.ts
+---
+
+Update the globally installed NTRP package via npm.`
+      },
+      {
+        name: "resume",
+        raw: `---
+name: resume
+description: Continue a previous session
+section: More
+args: [id]
+handler: ../commands/resume.ts
+hidden: true
+---
+
+Load a previous session's context so the AI can reference what was
+discussed before. Without an ID, resumes the most recent session.
+Use a full session ID or 4-char suffix.`
+      },
+      {
+        name: "name",
+        raw: `---
+name: name
+description: Tag this session with a label
+section: More
+args: [label]
+handler: ../commands/name.ts
+---
+
+Give the current session a human-readable name so you can find it
+later. The name appears in the REPL prompt, session list, and
+welcome dashboard. Max 40 characters.`
+      },
+      {
+        name: "switch",
+        raw: `---
+name: switch
+description: Jump to a named session
+section: More
+args: [name]
+handler: ../commands/switch.ts
+hidden: true
+---
+
+Save the current session and switch to a named one. If the name
+exists, loads its context and messages. If new, creates a fresh
+session with that name. Without arguments, lists all named sessions.`
+      },
+      {
+        name: "actions",
+        raw: `---
+name: actions
+description: Propose, approve, and execute actions
+section: More
+args: [list|test|show|approve|reject|execute|continue] [id]
+handler: ../commands/actions.ts
+---
+
+Create and manage action proposals. \`/actions test\` creates a local manual
+dry-run proposal that exercises the approval and execution lifecycle without
+touching external tools. Execute-class actions require local approval before
+they can run. Use \`/actions continue\` to advance the newest pending or
+approved proposal without copying a handle during the active workflow.`
+      },
+      {
+        name: "diagnose",
+        raw: `---
+name: diagnose
+description: Compute vital signs and generate findings
+section: Hidden
+hidden: true
+args: [--deep] [--segment <name>]
+handler: ../commands/diagnose.ts
+---
+
+Compute the 5 vital signs (freshness, flow rate, drop rate, signal-to-noise,
+thread depth) for either the full dataset or a segment. Companion to \`/metrics\`
+when your session primary is SaaS metrics. Use \`--deep\` to run the agentic
+investigation loop instead of the single-shot findings path.`
+      },
+      {
+        name: "metrics",
+        raw: `---
+name: metrics
+description: SaaS metrics \u2014 refresh or add the revenue view
+section: Hidden
+hidden: true
+args: [--findings] [--segment <name>]
+handler: ../commands/metrics.ts
+---
+
+Compute SaaS revenue metrics from pipeline or revenue-ledger data: ARR, NRR/GRR,
+Win Rate, Pipeline Coverage, and more. Each metric includes a confidence score
+and reliability gate showing what data unlocks the next tier. Use \`--findings\`
+for AI analysis calibrated to your company profile. Revenue ledger CSV format:
+account, period, mrr, event_type.`
+      },
+      {
+        name: "ask",
+        raw: `---
+name: ask
+description: Chat with your pipeline data
+section: Hidden
+hidden: true
+args: <question>
+handler: ../commands/ask.ts
+---
+
+Ask a plain-English question about your GTM health and SaaS metrics. Free-form
+text at the REPL prompt routes to the same agent. Respects your session primary
+lens; can cross-reference vital signs and revenue metrics via tools.`
+      },
+      {
+        name: "recap",
+        raw: `---
+name: recap
+description: Summarize the current session
+section: More
+handler: ../commands/recap.ts
+---
+
+Summarize the current REPL session using AI. Reads all natural-language
+exchanges from the session and produces a structured overview: key findings,
+dollar impacts, and recommended next steps.`
+      },
+      {
+        name: "remember",
+        raw: `---
+name: remember
+description: Teach the analyst a durable fact
+section: More
+args: <fact> | decision: <text> | preference: <text>
+handler: ../commands/remember.ts
+---
+
+Store a durable fact, decision, or preference about your business. Stored
+memory flows into every future analysis so the agent gets to know your
+business better over time \u2014 like a consultant building up a client file.`
+      },
+      {
+        name: "recall",
+        raw: `---
+name: recall
+description: See what the analyst remembers
+section: More
+args: [topic]
+handler: ../commands/recall.ts
+---
+
+Jog the analyst's memory. With no arguments, lists the durable facts it knows
+and the analyses it has already run. Pass a topic to see what it remembers
+about that subject \u2014 pulled from facts, strategies, wins, and ingested
+knowledge.`
+      },
+      {
+        name: "rate",
+        raw: `---
+name: rate
+description: Give feedback on the last answer
+section: More
+args: good [note] | bad <note>
+handler: ../commands/rate.ts
+---
+
+Tell the analyst how its last answer landed. \`/rate good\` reinforces the
+approach; \`/rate bad <what was off>\` records a correction. Feedback becomes a
+durable preference so the analyst gets better at working with you over time.`
+      },
+      {
+        name: "knowledge",
+        raw: `---
+name: knowledge
+description: Ingest external case studies & frameworks
+section: More
+args: [add <file> | list]
+handler: ../commands/knowledge.ts
+---
+
+Teach the analyst from work done outside the platform. \`/knowledge add <file>\`
+ingests a markdown, text, or PDF case study, framework, or benchmark report and
+indexes it for retrieval during analysis. \`/knowledge list\` shows what's
+indexed. Drop files into ~/.ntrp/knowledge to stage them.`
+      },
+      {
+        name: "ingest",
+        raw: `---
+name: ingest
+description: Import CRM CSV exports (or --demo)
+section: Hidden
+hidden: true
+args: <file> | --demo [--scenario <name>]
+handler: ../commands/ingest.ts
+---
+
+Import a CSV file from your CRM (Salesforce, HubSpot, Outreach). The command
+auto-detects the entity type based on column headers and runs identity
+resolution after import.
+
+Pass \`--demo\` instead of a file to generate a synthetic dataset shaped by
+your company profile. Accepts \`--scenario <name>\` to pick a scenario (else
+random) and \`--regen-taxonomy\` to rebuild the profile-derived market
+taxonomy. Rep names draw from a curated music / sports / film roster for a
+little demo delight; pass \`--no-whimsy\` to use generic names instead.`
+      },
+      {
+        name: "demo",
+        raw: `---
+name: demo
+description: Generate demo scenario data
+section: Getting Started
+args: [--scenario <name>] [--regen-taxonomy] [--no-whimsy]
+handler: ../commands/generate.ts
+hidden: true
+---
+
+Generate a complete dataset for one of 5 demo scenarios: hidden_crisis,
+leaky_bucket, stale_pipeline, lone_wolf, busy_bees. Without \`--scenario\`,
+picks one at random each run. Use \`--list-scenarios\` to see descriptions.
+Use \`--regen-taxonomy\` to force a fresh AI-built market taxonomy.
+By default, sales rep names are drawn from a curated music / sports / film
+roster; pass \`--no-whimsy\` for generic placeholder names.
+
+This command is hidden \u2014 prefer \`/ingest --demo\` which delegates here.`
+      },
+      {
+        name: "strategy",
+        raw: `---
+name: strategy
+description: Ingest and manage GTM strategies
+section: More
+args: [list|ingest|add|show|sync|sources] [file|text|id|folder]
+handler: ../commands/strategy.ts
+---
+
+Add user-authored or agent-authored GTM strategies to NTRP's strategy library.
+\`/strategy ingest <file>\` accepts markdown, YAML, PDF, or plain text files.
+\`/strategy ingest -\` reads strategy text from stdin, and \`/strategy add "..."\`
+creates a strategy from a short pasted description.
+\`/strategy sync --path <folder>\` scans an Obsidian-style local library and
+imports supported strategy documents. Use \`/strategy sources\` to see available
+library connector types.`
+      },
+      {
+        name: "segment",
+        raw: `---
+name: segment
+description: Browse and inspect segments
+section: More
+args: [list|show|compare|create|delete] [args]
+handler: ../commands/segment.ts
+---
+
+Browse, inspect, and manage data segments. With no arguments, lists all
+segments sorted worst-first. Subcommands: \`show <name>\`, \`compare <a> <b>\`,
+\`create <name> --entity <type> --filter <expr>\`, \`delete <name>\`.`
+      },
+      {
+        name: "report",
+        raw: `---
+name: report
+description: Export latest diagnosis
+section: More
+args: [--format terminal|md|json] [--output <file>]
+handler: ../commands/report.ts
+---
+
+Export the most recent diagnosis as terminal output, markdown, or JSON. Use
+\`--output <file>\` to write to disk instead of stdout.`
+      },
+      {
+        name: "progress",
+        raw: `---
+name: progress
+description: Usage stats and milestone ladder
+section: Navigation
+args: [reset] [--confirm]
+handler: ../commands/progress.ts
+---
+
+Hours saved, weekly activity trend, session counts, AI token usage, and the
+full milestone ladder with progress bars. Use reset (type "reset" to confirm)
+to clear hours and milestones while keeping this install's identity.`
+      },
+      {
+        name: "status",
+        raw: `---
+name: status
+description: Show last diagnosis and entity counts
+section: More
+handler: ../commands/status.ts
+---
+
+Show what data you currently have loaded and the result of your last
+diagnosis, if any.`
+      },
+      {
+        name: "scratch",
+        raw: `---
+name: scratch
+description: Wipe config, profile, and all datasets
+section: Admin
+args: [--confirm] [--include-progress]
+handler: ../commands/scratch.ts
+hidden: true
+---
+
+Minimal factory reset: removes API key, config, company profile, all sessions,
+per-session datasets, and demo taxonomy cache. Preserves progress (hours saved)
+by default. Pass \`--include-progress\` to also wipe install identity and hours.
+Also preserves memory, strategies, wins, knowledge, exports, and audit. Requires
+typing \`scratch\` in the REPL or passing \`--confirm\` one-shot. Triggers
+onboarding on next interactive use.`
+      },
+      {
+        name: "cleanup",
+        raw: `---
+name: cleanup
+description: Close all active sessions
+section: Admin
+args: [--confirm]
+handler: ../commands/cleanup.ts
+hidden: true
+---
+
+Mark every in-progress session as ended without deleting transcripts or dataset
+files. Interactive REPL only. Confirm with y/N or \`--confirm\` one-shot.`
+      },
+      {
+        name: "deactivate-demo",
+        raw: `---
+name: deactivate-demo
+description: Disable demo data generators
+section: Admin
+args: [--confirm]
+handler: ../commands/deactivate-demo.ts
+hidden: true
+---
+
+Persistently disable demo generators (\`/ingest --demo\`, \`/new --demo\`, NL
+"use demo data"). Re-enable with \`/config set demo-enabled true\`.`
+      },
+      {
+        name: "reset",
+        raw: `---
+name: reset
+description: Clear all data and start fresh
+section: More
+args: [--force]
+handler: ../commands/reset.ts
+---
+
+Drop all rows from every table in the local DuckDB database. Requires
+\`--force\` to proceed.`
+      },
+      {
+        name: "playbook",
+        raw: `---
+name: playbook
+description: Show or extend recommended plays
+section: More
+args: [--vital-sign <name>] [play-id] | add
+handler: ../commands/playbook.ts
+---
+
+Show the playbook of recommended plays keyed to each vital sign. Pass a
+play-id to drill into a single play's steps and expected outcome. Run
+\`/playbook add\` and the analyst walks you through capturing a new play, step by
+step \u2014 no flags or quoting needed. Learned plays become recommendable during
+analysis. (Power users can still pass everything as flags in one shot.)`
+      },
+      {
+        name: "export",
+        raw: `---
+name: export
+description: Save diagnosis to Obsidian notes
+section: More
+args: [--dir <path>] [--segment <name>]
+handler: ../commands/export.ts
+---
+
+Write the most recent diagnosis to your configured notes directory as
+markdown, ready for Obsidian, Logseq, or any other note tool.`
+      },
+      {
+        name: "publish",
+        raw: `---
+name: publish
+description: Preview and propose repository exports
+section: More
+args: [preview|propose|targets] [--target markdown] [--dir <path>]
+handler: ../commands/publish.ts
+---
+
+Build a full repository export package from the latest diagnosis, findings,
+strategies, evidence, and action receipts. \`preview\` shows the write plan;
+\`propose\` creates an approval-gated action proposal. The first executable
+target is local markdown for Obsidian-compatible repositories. Notion,
+Airtable, and GitHub mappings are documented via \`/publish targets\`.`
+      },
+      {
+        name: "backmeup",
+        raw: `---
+name: backmeup
+description: Export diagnosis receipts as CSV
+section: More
+args: [--output <dir>]
+handler: ../commands/backmeup.ts
+---
+
+Export your latest diagnosis as a folder of CSV files you can attach to a
+Slack thread, email, or slide deck. Creates a timestamped folder under
+~/.ntrp/exports/ containing a cover sheet with headline numbers, a findings
+file, and per-vital-sign evidence CSVs showing exactly which deals, contacts,
+or orgs drove each score. Use --output <dir> to write somewhere else.`
+      },
+      {
+        name: "profile",
+        raw: `---
+name: profile
+description: Set sales motion
+section: Settings
+args: [list|set|show] [preset]
+handler: ../commands/profile.ts
+---
+
+Choose a sales motion preset (PLG, SMB Velocity, Mid-Market, Enterprise). Each
+preset adjusts the vital-sign thresholds to match your deal cycle.`
+      },
+      {
+        name: "connect",
+        raw: `---
+name: connect
+description: Connect an AI provider (paste any key)
+section: Settings
+args: [provider] [--key <key>] [--base-url <url> --id <name>]
+handler: ../commands/connect.ts
+---
+
+Paste any provider's API key \u2014 NTRP identifies the provider from the key
+format (probing ambiguous ones), validates it, discovers which models the key
+can use, and builds the HIGH/MEDIUM/LOW tier stack automatically.
+
+Works with Anthropic, OpenAI, Google Gemini, Groq, Mistral, DeepSeek, xAI,
+OpenRouter, Together, and Fireworks out of the box. \`/connect ollama\` wires a
+local Ollama; \`/connect --base-url <url> --id <name>\` registers any other
+OpenAI-compatible endpoint.`
+      },
+      {
+        name: "config",
+        raw: `---
+name: config
+description: Get/set config values
+section: Settings
+args: [get|set|list|delete] <key> [value]
+handler: ../commands/config.ts
+---
+
+Manage CLI configuration stored at \`~/.ntrp/config.json\`. Useful keys:
+\`api-key\` (Anthropic), \`openai-api-key\` (and \`groq-api-key\`, \`google-api-key\`, ...),
+\`llm-primary\` (default engine), \`llm-tier\`, \`llm-auto-failover\`,
+\`default-format\`, \`export-dir\`.
+
+Setting a provider key opens a hidden prompt and auto-discovers that
+provider's models. Prefer \`/connect\` \u2014 it detects the provider for you.`
+      },
+      {
+        name: "provider",
+        raw: `---
+name: provider
+description: Switch active LLM engine
+section: Settings
+args: [<id>|list|reset|save|failover on|off]
+handler: ../commands/provider.ts
+---
+
+Choose which connected engine answers this session \u2014 any provider added via
+\`/connect\` (anthropic, openai, groq, google, ollama, custom endpoints, ...).
+Session-scoped by default; \`/provider save\` writes the default to config.
+\`/provider failover on\` enables rate-limit auto-failover.`
+      },
+      {
+        name: "tier",
+        raw: `---
+name: tier
+description: Set inference tier (HIGH/MEDIUM/LOW)
+section: Settings
+args: [high|medium|low|list] [--default]
+handler: ../commands/tier.ts
+---
+
+Set quality/cost tier for this REPL session. Agentic surfaces respect your tier;
+some single-shot surfaces keep fixed defaults. \`/tier list\` highlights the
+active stack. Add \`--default\` to persist to config.`
+      },
+      {
+        name: "model",
+        raw: `---
+name: model
+description: Override the active LLM model
+section: Settings
+args: [list|set <id>|refresh|clear] [--default]
+handler: ../commands/model.ts
+---
+
+\`/model list\` shows the models discovered for the active engine with their
+tier assignments. \`/model refresh\` re-discovers the live list. \`/model set <id>\`
+pins a model on the **active engine**; cross-provider IDs are rejected \u2014
+switch with \`/provider\` first.`
+      },
+      {
+        name: "activate",
+        raw: `---
+name: activate
+description: Enter license key
+section: Settings
+args: <license>
+handler: ../commands/activate.ts
+---
+
+Activate NTRP with your license key (format: NTRP-XXXX-XXXX-XXXX). Most
+commands require a valid license.`
+      },
+      {
+        name: "upgrade",
+        raw: `---
+name: upgrade
+description: Upgrade trial to Pro \u2014 checkout + paste key
+section: Settings
+handler: ../commands/upgrade.ts
+---
+
+Open the Pro checkout page and paste your new license key without leaving
+the REPL. Use during trial grace or after cutoff. Flags: --url (print checkout URL only).`
+      },
+      {
+        name: "checkout",
+        raw: `---
+name: checkout
+description: Open signup checkout in your browser
+section: Settings
+handler: ../commands/checkout.ts
+---
+
+Opens the Lemon Squeezy checkout page in your default browser. Use anytime
+you need a trial or Pro license key.`
+      },
+      {
+        name: "feedback",
+        raw: `---
+name: feedback
+description: Correct your profile in plain English
+section: Settings
+args: <correction>
+handler: ../commands/feedback.ts
+---
+
+Apply natural-language corrections to your company profile. Maps structured
+fields when possible (e.g. "our sales cycle is 6 months" updates
+sales_cycle_days) and merges remaining nuances into a custom_context
+paragraph that flows into all AI surfaces.`
+      }
+    ];
+  }
+});
+
 // src/ai/prompt-parts.ts
 function buildCompanyProfileBlock() {
   const p = loadProfile();
@@ -5881,12 +6611,41 @@ function buildPlaybookBlock() {
 Learned plays (added from this team's experience and ingested case studies \u2014 recommend these when they fit):
 ${learned}`;
 }
-var ANALYST_INSTINCT_BLOCK, VITAL_SIGNS_BLOCK, PLAYBOOK_BLOCK, METRICS_BLOCK, FINDINGS_SCHEMA_BLOCK;
+function buildCommandCatalogBlock() {
+  const GROUP_ANALYSIS = "Analysis & data";
+  const GROUP_SESSION = "Session, memory & outputs";
+  const GROUP_SETTINGS = "Settings & providers";
+  const groupOrder = [GROUP_ANALYSIS, GROUP_SESSION, GROUP_SETTINGS];
+  const groupFor = (section) => {
+    if (section === "Hidden" || section === "Getting Started") return GROUP_ANALYSIS;
+    if (section === "Settings") return GROUP_SETTINGS;
+    return GROUP_SESSION;
+  };
+  const groups = new Map(groupOrder.map((label) => [label, []]));
+  for (const meta of listWorkflows(true)) {
+    if (meta.name === "ask") continue;
+    if (meta.section === "Admin") continue;
+    groups.get(groupFor(meta.section)).push(formatCatalogLine(meta));
+  }
+  groups.get(GROUP_SESSION).push(
+    "- /help \u2014 Show the shortcut list",
+    "- /home \u2014 Show the welcome dashboard and current session status"
+  );
+  return groupOrder.filter((label) => groups.get(label).length > 0).map((label) => `${label}:
+${groups.get(label).join("\n")}`).join("\n\n");
+}
+function formatCatalogLine(meta) {
+  const args = meta.args?.trim() ? ` ${meta.args.trim()}` : "";
+  const note = DESTRUCTIVE_COMMAND_NOTES[meta.name] ? ` (${DESTRUCTIVE_COMMAND_NOTES[meta.name]})` : "";
+  return `- /${meta.name}${args} \u2014 ${meta.description}${note}`;
+}
+var ANALYST_INSTINCT_BLOCK, VITAL_SIGNS_BLOCK, PLAYBOOK_BLOCK, DESTRUCTIVE_COMMAND_NOTES, METRICS_BLOCK, FINDINGS_SCHEMA_BLOCK;
 var init_prompt_parts = __esm({
   "src/ai/prompt-parts.ts"() {
     "use strict";
     init_profile();
     init_playbook();
+    init_registry();
     ANALYST_INSTINCT_BLOCK = `A search box returns numbers; a world-class analyst returns insight. The instincts below are what separate the two. Bring them PROACTIVELY \u2014 surface the connection, the chain, and the priority without waiting to be asked, because the user often doesn't know to ask.
 
 - ROOT CAUSE OVER SYMPTOM LIST. GTM problems are rarely independent \u2014 they're usually one failure wearing several masks. When two or more vital signs are red or yellow, your first instinct is to ask "is this the same underlying problem showing up in different places?" and, when it is, name the single cause. (Classic shape: a broken lead handoff starves reps of new pipeline \u2192 they work only what they can already see \u2192 everything else ages into stale, zombie deals \u2192 the forecast inflates with deals nobody is touching \u2192 the quarter is quietly at risk. One cause, four symptoms.)
@@ -5909,6 +6668,9 @@ Restraint matters: NTRP is a stethoscope, not a surgeon. Observe, connect, and r
 - "Fix the Handoff Gap" (id: fix-handoff-gap) \u2014 when drop_rate is high
 - "Retarget Misdirected Effort" (id: retarget-effort) \u2014 when signal_to_noise is low
 - "Unstick the Pipeline" (id: unstick-pipeline) \u2014 when flow_rate is low`;
+    DESTRUCTIVE_COMMAND_NOTES = {
+      reset: "destructive \u2014 wipes all data, requires --force"
+    };
     METRICS_BLOCK = `Revenue metrics measure GTM output \u2014 the standard SaaS metrics:
 - ARR: Total closed-won revenue. New ARR + Expansion ARR = growth; Churned + Contraction = leakage.
 - NRR (Net Revenue Retention): >100% means growing from existing customers. Best-in-class: 110%+.
@@ -14373,6 +15135,16 @@ FORMATTING (brief mode \u2014 scannable, not chunky):
 - No ### headings, no tables, no --- footer, no closing "want me to dig deeper?" question.
 - Single-point answers can stay one sentence \u2014 don't force bullets when one line is enough.
 `;
+  const commandStyleRule = responseMode === "brief" ? '- Style in brief mode: a suggestion is at most ONE short trailing line after your answer (e.g. "`/segment compare enterprise smb` gives the full side-by-side.") \u2014 no heading, no footer.' : "- Style: weave the suggestion naturally into your close \u2014 one sentence with the exact invocation in `inline code`.";
+  const commandSection = `PRESET COMMANDS (slash commands the user can type at the prompt \u2014 you may SUGGEST these; you have no ability to run them):
+${buildCommandCatalogBlock()}
+
+COMMAND SUGGESTION RULES (suggest-only):
+- Evaluate whether the user's question overlaps a preset command's capability. Answer the question yourself first, from tools and context; suggest a command only when it adds capability beyond your answer \u2014 writing files, opening a wizard, running a heavier analysis, or changing settings.
+- If the message is primarily a request to DO what a command does (e.g. "export this to my notes"), say plainly that you don't execute commands and give the exact invocation to type, e.g. \`/handoff notes\`.
+- Never claim a command was run. Never invent flags \u2014 use only the documented arguments above. At most ONE command suggestion per answer; most answers need none.
+- Only suggest a command that can work right now given the session state you know (e.g. no \`/diagnose\` or \`/export\` before data or a diagnosis exists).
+${commandStyleRule}`;
   const outputRules = responseMode === "brief" ? `OUTPUT RULES:
 - Respond in plain text markdown (not JSON). Lead sentence + bullets when helpful \u2014 never a dense paragraph wall.
 - Pull numbers from the completed session analysis or conversation history \u2014 never guess.
@@ -14396,6 +15168,8 @@ ${VITAL_SIGNS_BLOCK}
 
 PLAYBOOK \u2014 recommend these plays when appropriate:
 ${buildPlaybookBlock()}
+
+${commandSection}
 ${formattingSection}
 ${outputRules}`;
 }
@@ -14654,57 +15428,133 @@ var init_diagnosis = __esm({
   }
 });
 
-// src/ai/strategy-normalize.ts
-function stripFences2(text) {
-  const trimmed = text.trim();
-  const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
-  if (fenced) return fenced[1].trim();
-  return trimmed;
-}
-async function normalizeStrategy(input, ctx) {
-  assertReplAi(ctx);
-  const playbookBlock = getPlaybook().map((play) => `- ${play.id}: ${play.name} (${play.trigger_vital_sign}) \u2014 ${play.why}`).join("\n");
-  const { text } = await llmCompleteText(
-    "strategy",
-    SYSTEM_PROMPT2,
-    `AVAILABLE PLAYBOOK IDS:
-${playbookBlock}
-
-SOURCE TYPE: ${input.source_type}
-SOURCE PATH: ${input.source_path ?? "none"}
-STRUCTURED HINT:
-${JSON.stringify(input.structured_hint ?? {}, null, 2)}
-
-RAW STRATEGY DOCUMENT:
-${input.raw_text.slice(0, 16e3)}
-
-Normalize this strategy now as strict JSON.`,
-    1800,
-    ctx
-  );
-  let parsed;
-  try {
-    parsed = JSON.parse(stripFences2(text));
-  } catch {
-    throw new Error("AI response is not valid strategy JSON");
+// src/services/report.ts
+async function loadReportData(segmentName) {
+  await initSchema();
+  const diagnosis = await loadLatestDiagnosis();
+  if (!diagnosis) {
+    throw new NtrpError("no_diagnosis", "No diagnosis data found. Run diagnose first.", 4 /* NoData */);
   }
-  return validateStrategyDraft(parsed, input);
-}
-function validateStrategyDraft(raw, input) {
-  const title = stringValue(raw.title) ?? "Untitled Strategy";
-  const goal = stringValue(raw.goal) ?? "Clarify the GTM strategy and define measurable outcomes.";
-  const hypothesis = stringValue(raw.hypothesis) ?? "If the team executes this strategy consistently, the targeted GTM health metrics should improve.";
-  const targetSegment = stringValue(raw.target_segment) ?? "Unspecified segment";
-  return {
-    title,
-    status: enumValue(raw.status, ["draft", "active", "paused", "completed", "archived"], "draft"),
-    source_type: input.source_type,
-    source_path: input.source_path,
-    goal,
-    hypothesis,
-    target_segment: targetSegment,
-    priority: enumValue(raw.priority, ["low", "medium", "high"], "medium"),
-    linked_play_ids: validPlayIds(raw.linked_play_ids),
+  let { health, segments, findings, entityCounts } = diagnosis;
+  let scopedSegment = null;
+  if (segmentName) {
+    const lower = segmentName.toLowerCase();
+    let match = segments.find((s) => s.segment.name.toLowerCase() === lower);
+    if (!match) {
+      const subs = segments.filter((s) => s.segment.name.toLowerCase().includes(lower));
+      if (subs.length === 1) match = subs[0];
+      else if (subs.length > 1) {
+        throw new NtrpError("ambiguous_segment", `"${segmentName}" matches multiple segments.`, 2 /* Usage */, {
+          matches: subs.map((s) => s.segment.name)
+        });
+      }
+    }
+    if (!match) {
+      throw new NtrpError("segment_not_found", `No segment matching "${segmentName}".`, 2 /* Usage */, {
+        available_segments: segments.map((s) => s.segment.name)
+      });
+    }
+    scopedSegment = match;
+    health = match.result;
+    segments = [match];
+    findings = findings.filter((f) => f.segment.toLowerCase().includes(lower));
+  }
+  return {
+    diagnosis,
+    scopedSegment,
+    reportData: {
+      health,
+      segments,
+      findings,
+      entityCounts,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+var init_report = __esm({
+  "src/services/report.ts"() {
+    "use strict";
+    init_schema();
+    init_queries();
+    init_errors2();
+    init_types2();
+  }
+});
+
+// src/ai/explore-mode.ts
+function isDeepDiveQuestion(question) {
+  return DEEP_DIVE_PATTERNS.some((p) => p.test(question.trim()));
+}
+function resolveExploreResponseMode(question, ctx, priorTurnCount) {
+  if (isDeepDiveQuestion(question)) return "deep";
+  if (isAnalysisReady(ctx)) return "brief";
+  if (ctx.stage === "analyzed" || ctx.analysis.completed.length > 0) return "brief";
+  if (priorTurnCount === 0) return "deep";
+  return "brief";
+}
+var DEEP_DIVE_PATTERNS;
+var init_explore_mode = __esm({
+  "src/ai/explore-mode.ts"() {
+    "use strict";
+    init_context2();
+    DEEP_DIVE_PATTERNS = [
+      /\b(break down|breakdown|drill|dig deeper|show me|list all|by rep|by stage|by segment|query|sql|detail|expand|elaborate|full analysis|walk me through|pull up|give me the data)\b/i,
+      /\b(how many|which deals|which accounts|who owns|top \d+|every deal|all stuck)\b/i
+    ];
+  }
+});
+
+// src/ai/strategy-normalize.ts
+function stripFences2(text) {
+  const trimmed = text.trim();
+  const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+  if (fenced) return fenced[1].trim();
+  return trimmed;
+}
+async function normalizeStrategy(input, ctx) {
+  assertReplAi(ctx);
+  const playbookBlock = getPlaybook().map((play) => `- ${play.id}: ${play.name} (${play.trigger_vital_sign}) \u2014 ${play.why}`).join("\n");
+  const { text } = await llmCompleteText(
+    "strategy",
+    SYSTEM_PROMPT2,
+    `AVAILABLE PLAYBOOK IDS:
+${playbookBlock}
+
+SOURCE TYPE: ${input.source_type}
+SOURCE PATH: ${input.source_path ?? "none"}
+STRUCTURED HINT:
+${JSON.stringify(input.structured_hint ?? {}, null, 2)}
+
+RAW STRATEGY DOCUMENT:
+${input.raw_text.slice(0, 16e3)}
+
+Normalize this strategy now as strict JSON.`,
+    1800,
+    ctx
+  );
+  let parsed;
+  try {
+    parsed = JSON.parse(stripFences2(text));
+  } catch {
+    throw new Error("AI response is not valid strategy JSON");
+  }
+  return validateStrategyDraft(parsed, input);
+}
+function validateStrategyDraft(raw, input) {
+  const title = stringValue(raw.title) ?? "Untitled Strategy";
+  const goal = stringValue(raw.goal) ?? "Clarify the GTM strategy and define measurable outcomes.";
+  const hypothesis = stringValue(raw.hypothesis) ?? "If the team executes this strategy consistently, the targeted GTM health metrics should improve.";
+  const targetSegment = stringValue(raw.target_segment) ?? "Unspecified segment";
+  return {
+    title,
+    status: enumValue(raw.status, ["draft", "active", "paused", "completed", "archived"], "draft"),
+    source_type: input.source_type,
+    source_path: input.source_path,
+    goal,
+    hypothesis,
+    target_segment: targetSegment,
+    priority: enumValue(raw.priority, ["low", "medium", "high"], "medium"),
+    linked_play_ids: validPlayIds(raw.linked_play_ids),
     success_metrics: metricArray(raw.success_metrics),
     leading_indicators: metricArray(raw.leading_indicators),
     risks: stringArray(raw.risks),
@@ -15264,1117 +16114,1062 @@ var init_strategy = __esm({
   }
 });
 
-// src/ai/embeddings.ts
-var embeddings_exports = {};
-__export(embeddings_exports, {
-  embedItems: () => embedItems,
-  embedText: () => embedText,
-  isEmbeddingsEnabled: () => isEmbeddingsEnabled
-});
-function resolveConfig() {
-  const explicit = getConfigValue("embeddings-provider");
-  if (explicit === "none") return null;
-  const voyageKey = process.env.VOYAGE_API_KEY ?? getConfigValue("voyage-api-key");
-  const openaiKey = getOpenAiApiKey();
-  const provider = explicit ?? (voyageKey ? "voyage" : openaiKey ? "openai" : "none");
-  if (provider === "voyage" && voyageKey) {
-    return { provider, apiKey: voyageKey, model: VOYAGE_MODEL, url: "https://api.voyageai.com/v1/embeddings" };
-  }
-  if (provider === "openai" && openaiKey) {
-    return { provider, apiKey: openaiKey, model: OPENAI_MODEL, url: "https://api.openai.com/v1/embeddings" };
-  }
-  return null;
-}
-function isEmbeddingsEnabled() {
-  return resolveConfig() !== null;
-}
-async function callProvider(texts) {
-  const cfg = resolveConfig();
-  if (!cfg || texts.length === 0) return null;
-  try {
-    const res = await fetch(cfg.url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${cfg.apiKey}`
-      },
-      body: JSON.stringify({ input: texts, model: cfg.model })
-    });
-    if (!res.ok) return null;
-    const json = await res.json();
-    if (!json.data) return null;
-    return json.data.map((d) => d.embedding);
-  } catch {
-    return null;
+// src/repositories/bundle.ts
+async function buildRepositoryExportPackage(options) {
+  await initSchema();
+  const bundle = await loadSessionAnalysisBundle();
+  const diagnosis = bundle.diagnosis;
+  if (!diagnosis) {
+    if (bundle.metrics) {
+      throw new NtrpError(
+        "diagnosis_required",
+        "Publish packages require a GTM health snapshot. Run /diagnose (companion) or /handoff report for metrics-only export.",
+        4 /* NoData */
+      );
+    }
+    if (!hasAnyAnalysis(bundle)) {
+      throw new NtrpError("diagnosis_required", "No analysis data found. Run /new, /diagnose, or /metrics first.", 4 /* NoData */);
+    }
+    throw new NtrpError("diagnosis_required", "No diagnosis data found. Run /diagnose first.", 4 /* NoData */);
   }
-}
-async function embedText(text) {
-  const key = text.trim();
-  if (!key) return null;
-  const cached2 = cache.get(key);
-  if (cached2) return cached2;
-  const result = await callProvider([key]);
-  const vec = result?.[0] ?? null;
-  if (vec) cache.set(key, vec);
-  return vec;
-}
-async function embedItems(items) {
-  const needing = [];
-  const out = items.map((it, index) => {
-    if (it.embedding && it.embedding.length > 0) return { ...it };
-    const cached2 = cache.get(it.text.trim());
-    if (cached2) return { ...it, embedding: cached2 };
-    needing.push({ index, text: it.text });
-    return { ...it };
+  const strategies = await listStrategies("all");
+  const strategiesWithSources = await Promise.all(
+    strategies.map(async (strategy) => ({
+      strategy,
+      sources: await listStrategySources(strategy.id)
+    }))
+  );
+  const proposals = await listActionProposals(100);
+  const actions = await Promise.all(
+    proposals.map(async (proposal) => ({
+      proposal,
+      executions: await listActionExecutions(proposal.id)
+    }))
+  );
+  const sections = buildSections({
+    diagnosis,
+    strategiesCount: strategiesWithSources.length,
+    actionsCount: actions.length
   });
-  if (needing.length === 0) return out;
-  const vectors = await callProvider(needing.map((n) => n.text));
-  if (!vectors) return out;
-  needing.forEach((n, i) => {
-    const vec = vectors[i];
-    if (vec) {
-      out[n.index].embedding = vec;
-      cache.set(n.text.trim(), vec);
+  return {
+    schema_version: "ntrp.repository_export.v1",
+    export_id: uuid(),
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    target: options.target,
+    summary: {
+      overall_score: diagnosis.health.overall_score,
+      overall_status: diagnosis.health.overall_status,
+      gating_vital_sign: diagnosis.health.gating_vital_sign,
+      total_value_at_risk: diagnosis.health.total_value_at_risk ?? null,
+      findings_count: diagnosis.findings.length,
+      strategies_count: strategiesWithSources.length,
+      action_proposals_count: actions.length
+    },
+    diagnosis: {
+      health: diagnosis.health,
+      segments: diagnosis.segments.map((segment) => ({
+        segment: segment.segment,
+        result: segment.result
+      })),
+      findings: diagnosis.findings,
+      entity_counts: diagnosis.entityCounts,
+      upload_batch_id: diagnosis.uploadBatchId
+    },
+    strategies: strategiesWithSources,
+    actions,
+    sections,
+    provenance: {
+      command: options.command ?? "publish",
+      model_or_fixture: options.modelOrFixture,
+      source: options.source ?? "local_duckdb",
+      notes: [
+        "Generated from the latest persisted diagnosis.",
+        "Repository writes are approval-gated through local action proposals."
+      ]
     }
-  });
-  return out;
+  };
 }
-var VOYAGE_MODEL, OPENAI_MODEL, cache;
-var init_embeddings = __esm({
-  "src/ai/embeddings.ts"() {
+function buildSections(input) {
+  const { diagnosis } = input;
+  const health = diagnosis.health;
+  return [
+    {
+      id: "cover",
+      title: "Cover Summary",
+      summary: `${health.overall_score}/100 ${health.overall_status}, gated by ${health.gating_vital_sign}`,
+      markdown: [
+        `Overall score: **${health.overall_score}/100** (${health.overall_status})`,
+        `Gating vital sign: **${VITAL_SIGN_LABELS[health.gating_vital_sign]}**`,
+        `Total value at risk: **${health.total_value_at_risk ? formatCurrency(health.total_value_at_risk) : "N/A"}**`,
+        `Findings: **${diagnosis.findings.length}**`,
+        `Strategies: **${input.strategiesCount}**`,
+        `Action proposals: **${input.actionsCount}**`
+      ].join("\n\n")
+    },
+    {
+      id: "vital-signs",
+      title: "Vital Signs",
+      summary: `${health.vital_signs.length} vital signs`,
+      markdown: health.vital_signs.map((vs) => `- **${VITAL_SIGN_LABELS[vs.vital_sign]}:** ${Math.round(vs.score)}/100 (${vs.status}) \u2014 ${formatDollarImpact(vs.dollar_value, vs.dollar_label)}`).join("\n"),
+      children: health.vital_signs.map((vs) => ({
+        id: `vital-${vs.vital_sign}`,
+        title: `${VITAL_SIGN_LABELS[vs.vital_sign]}: ${Math.round(vs.score)}/100`,
+        summary: formatDollarImpact(vs.dollar_value, vs.dollar_label),
+        markdown: [
+          `Status: **${vs.status}**`,
+          `Value: **${formatDollarImpact(vs.dollar_value, vs.dollar_label)}**`,
+          `Flagged entities: **${vs.entity_details.length}**`,
+          "",
+          "Components:",
+          "```json",
+          JSON.stringify(vs.components, null, 2),
+          "```",
+          "",
+          "Top entity details:",
+          "```json",
+          JSON.stringify(vs.entity_details.slice(0, 25), null, 2),
+          "```"
+        ].join("\n"),
+        metadata: { vital_sign: vs.vital_sign }
+      }))
+    },
+    {
+      id: "findings",
+      title: "Findings and Deep Analysis",
+      summary: `${diagnosis.findings.length} findings`,
+      markdown: diagnosis.findings.length > 0 ? diagnosis.findings.map((finding) => `- **${finding.severity.toUpperCase()}** ${finding.segment}: ${finding.finding}`).join("\n") : "_No findings recorded._",
+      children: diagnosis.findings.map((finding, index) => ({
+        id: `finding-${index + 1}`,
+        title: `${finding.severity.toUpperCase()} \u2014 ${finding.segment}`,
+        summary: finding.dollar_value ? formatCurrency(finding.dollar_value) : void 0,
+        markdown: [
+          finding.finding,
+          "",
+          finding.recommended_plays && finding.recommended_plays.length > 0 ? `Recommended plays: ${finding.recommended_plays.map((play) => `**${play.play_name}**`).join(", ")}` : "Recommended plays: _None recorded._",
+          "",
+          "Scores:",
+          "```json",
+          JSON.stringify(finding.vital_signs, null, 2),
+          "```"
+        ].join("\n")
+      }))
+    },
+    {
+      id: "segments",
+      title: "Segments",
+      summary: `${diagnosis.segments.length} segments`,
+      markdown: diagnosis.segments.length > 0 ? diagnosis.segments.map((segment) => `- **${segment.segment.name}:** ${Math.round(segment.result.overall_score)}/100 (${segment.result.overall_status}), gated by ${segment.result.gating_vital_sign}`).join("\n") : "_No segments recorded._"
+    }
+  ];
+}
+var init_bundle = __esm({
+  "src/repositories/bundle.ts"() {
     "use strict";
-    init_store();
-    init_llm_config();
-    VOYAGE_MODEL = "voyage-3";
-    OPENAI_MODEL = "text-embedding-3-small";
-    cache = /* @__PURE__ */ new Map();
+    init_queries();
+    init_session_analysis();
+    init_schema();
+    init_formatters();
+    init_errors2();
+    init_types2();
   }
 });
 
-// src/memory/retrieval.ts
-function tokenize(text) {
-  return text.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length >= 3 && !STOPWORDS.has(t));
-}
-function keywordRank(query, items, topK) {
-  const queryTokens = new Set(tokenize(query));
-  if (queryTokens.size === 0) {
-    return items.slice(-topK).reverse().map((it) => ({ id: it.id, score: 0 }));
-  }
-  const scored = items.map((it) => {
-    const tokens = tokenize(it.text);
-    if (tokens.length === 0) return { id: it.id, score: 0 };
-    let overlap = 0;
-    const seen = /* @__PURE__ */ new Set();
-    for (const t of tokens) {
-      if (queryTokens.has(t) && !seen.has(t)) {
-        overlap++;
-        seen.add(t);
-      }
+// src/repositories/markdown.ts
+import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync11 } from "fs";
+import { basename as basename5, dirname as dirname2, join as join15, resolve as resolve7 } from "path";
+import { stringify as stringifyYaml2 } from "yaml";
+function renderMarkdownFiles(pkg) {
+  const bundleJson = JSON.stringify(pkg, null, 2) + "\n";
+  const vitalDetails = renderVitalEvidence(pkg);
+  const findings = renderFindings(pkg);
+  const receipts = JSON.stringify({
+    export_id: pkg.export_id,
+    generated_at: pkg.generated_at,
+    actions: pkg.actions
+  }, null, 2) + "\n";
+  const strategyFiles = pkg.strategies.map((entry) => ({
+    relativePath: `strategies/${safeFilename(entry.strategy.slug || entry.strategy.title)}`,
+    contents: renderStrategy(entry),
+    description: `Strategy: ${entry.strategy.title}`
+  }));
+  return [
+    {
+      relativePath: "index.md",
+      contents: renderIndex(pkg),
+      description: "Repository export index"
+    },
+    {
+      relativePath: "evidence/vital-signs.md",
+      contents: vitalDetails,
+      description: "Detailed vital-sign evidence"
+    },
+    {
+      relativePath: "evidence/findings.md",
+      contents: findings,
+      description: "Findings and recommended plays"
+    },
+    ...strategyFiles,
+    {
+      relativePath: "receipts/actions.json",
+      contents: receipts,
+      description: "Action proposal and execution receipts"
+    },
+    {
+      relativePath: "bundle.json",
+      contents: bundleJson,
+      description: "Canonical repository export package"
     }
-    return { id: it.id, score: overlap / Math.sqrt(tokens.length) };
-  });
-  const positive = scored.filter((s) => s.score > 0).sort((a, b) => b.score - a.score);
-  if (positive.length > 0) return positive.slice(0, topK);
-  return items.slice(-topK).reverse().map((it) => ({ id: it.id, score: 0 }));
+  ];
 }
-function cosine(a, b) {
-  let dot = 0;
-  let na = 0;
-  let nb = 0;
-  const len = Math.min(a.length, b.length);
-  for (let i = 0; i < len; i++) {
-    dot += a[i] * b[i];
-    na += a[i] * a[i];
-    nb += b[i] * b[i];
-  }
-  if (na === 0 || nb === 0) return 0;
-  return dot / (Math.sqrt(na) * Math.sqrt(nb));
+function renderIndex(pkg) {
+  const frontmatter = stringifyYaml2({
+    export_id: pkg.export_id,
+    generated_at: pkg.generated_at,
+    target: pkg.target.kind,
+    overall_score: pkg.summary.overall_score,
+    overall_status: pkg.summary.overall_status,
+    gating_vital_sign: pkg.summary.gating_vital_sign,
+    total_value_at_risk: pkg.summary.total_value_at_risk,
+    tags: ["ntrp", "repository-export", pkg.summary.gating_vital_sign.replace(/_/g, "-")]
+  }).trim();
+  return [
+    "---",
+    frontmatter,
+    "---",
+    "",
+    "# NTRP Repository Export",
+    "",
+    `Generated: ${pkg.generated_at}`,
+    "",
+    `Overall score: **${pkg.summary.overall_score}/100** (${pkg.summary.overall_status})`,
+    `Gating vital sign: **${VITAL_SIGN_LABELS[pkg.summary.gating_vital_sign]}**`,
+    `Total value at risk: **${pkg.summary.total_value_at_risk ? formatCurrency(pkg.summary.total_value_at_risk) : "N/A"}**`,
+    "",
+    "## Sections",
+    "",
+    ...pkg.sections.map(renderSection),
+    "## Files",
+    "",
+    "- [[evidence/vital-signs|Vital-sign evidence]]",
+    "- [[evidence/findings|Findings]]",
+    "- `bundle.json`",
+    "- `receipts/actions.json`",
+    ""
+  ].join("\n");
 }
-async function rankByRelevance(query, items, topK) {
-  if (items.length === 0) return [];
-  try {
-    const { isEmbeddingsEnabled: isEmbeddingsEnabled2, embedText: embedText2, embedItems: embedItems2 } = await Promise.resolve().then(() => (init_embeddings(), embeddings_exports));
-    if (isEmbeddingsEnabled2()) {
-      const queryVec = await embedText2(query);
-      if (queryVec) {
-        const withVecs = await embedItems2(items);
-        const scored = withVecs.filter((it) => it.embedding && it.embedding.length > 0).map((it) => ({ id: it.id, score: cosine(queryVec, it.embedding) })).sort((a, b) => b.score - a.score);
-        if (scored.length > 0) return scored.slice(0, topK);
-      }
-    }
-  } catch {
-  }
-  return keywordRank(query, items, topK);
+function renderSection(section) {
+  const childMarkdown = section.children && section.children.length > 0 ? ["", ...section.children.map(renderNestedSection)].join("\n") : "";
+  return [
+    "<details>",
+    `<summary>${escapeSummary(section.title)}${section.summary ? ` \u2014 ${escapeSummary(section.summary)}` : ""}</summary>`,
+    "",
+    section.markdown,
+    childMarkdown,
+    "",
+    "</details>",
+    ""
+  ].join("\n");
 }
-var STOPWORDS;
-var init_retrieval = __esm({
-  "src/memory/retrieval.ts"() {
-    "use strict";
-    STOPWORDS = /* @__PURE__ */ new Set([
-      "the",
-      "and",
-      "for",
-      "are",
-      "was",
-      "were",
-      "with",
-      "that",
-      "this",
-      "from",
-      "have",
-      "has",
-      "had",
-      "our",
-      "your",
-      "you",
-      "what",
-      "which",
-      "how",
-      "why",
-      "who",
-      "when",
-      "where",
-      "into",
-      "about",
-      "over",
-      "than",
-      "then",
-      "they",
-      "them",
-      "their",
-      "there",
-      "here",
-      "been",
-      "being",
-      "does",
-      "did",
-      "doing",
-      "can",
-      "could",
-      "would",
-      "should",
-      "will",
-      "shall",
-      "may",
-      "might",
-      "must",
-      "not",
-      "but",
-      "all",
-      "any",
-      "some",
-      "more",
-      "most",
-      "much",
-      "many",
-      "very",
-      "just",
-      "like",
-      "out",
-      "off",
-      "per",
-      "via",
-      "use",
-      "get",
-      "got"
-    ]);
+function renderNestedSection(section) {
+  return [
+    "<details>",
+    `<summary>${escapeSummary(section.title)}${section.summary ? ` \u2014 ${escapeSummary(section.summary)}` : ""}</summary>`,
+    "",
+    section.markdown,
+    "",
+    "</details>"
+  ].join("\n");
+}
+function renderVitalEvidence(pkg) {
+  const lines = ["# Vital-Sign Evidence", ""];
+  for (const vs of pkg.diagnosis.health.vital_signs) {
+    lines.push(`## ${VITAL_SIGN_LABELS[vs.vital_sign]}`);
+    lines.push("");
+    lines.push(`Score: **${Math.round(vs.score)}/100** (${vs.status})`);
+    lines.push(`Value: **${formatDollarImpact(vs.dollar_value, vs.dollar_label)}**`);
+    lines.push(`Flagged entities: **${vs.entity_details.length}**`);
+    lines.push("");
+    lines.push("<details>");
+    lines.push("<summary>Components</summary>");
+    lines.push("");
+    lines.push("```json");
+    lines.push(JSON.stringify(vs.components, null, 2));
+    lines.push("```");
+    lines.push("");
+    lines.push("</details>");
+    lines.push("");
+    lines.push("<details>");
+    lines.push("<summary>Entity details</summary>");
+    lines.push("");
+    lines.push("```json");
+    lines.push(JSON.stringify(vs.entity_details, null, 2));
+    lines.push("```");
+    lines.push("");
+    lines.push("</details>");
+    lines.push("");
   }
-});
-
-// src/memory/knowledge.ts
-import { existsSync as existsSync16, readFileSync as readFileSync14, appendFileSync as appendFileSync3, readdirSync as readdirSync3 } from "fs";
-import { join as join17 } from "path";
-import { randomUUID as randomUUID4 } from "crypto";
-function knowledgePath() {
-  return join17(getMemoryDir(), KNOWLEDGE_FILE);
+  return lines.join("\n");
 }
-function loadKnowledgeChunks() {
-  const path = knowledgePath();
-  if (!existsSync16(path)) return [];
-  const out = [];
-  for (const line of readFileSync14(path, "utf-8").split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    try {
-      out.push(JSON.parse(trimmed));
-    } catch {
+function renderFindings(pkg) {
+  if (pkg.diagnosis.findings.length === 0) return "# Findings\n\n_No findings recorded._\n";
+  const lines = ["# Findings", ""];
+  for (const finding of pkg.diagnosis.findings) {
+    lines.push(`## ${finding.severity.toUpperCase()} \u2014 ${finding.segment}`);
+    lines.push("");
+    lines.push(finding.finding);
+    lines.push("");
+    if (finding.dollar_value) lines.push(`Dollar value: **${formatCurrency(finding.dollar_value)}**`);
+    if (finding.recommended_plays && finding.recommended_plays.length > 0) {
+      lines.push(`Recommended plays: ${finding.recommended_plays.map((play) => `**${play.play_name}**`).join(", ")}`);
     }
+    lines.push("");
   }
-  return out;
+  return lines.join("\n");
 }
-var KNOWLEDGE_FILE;
-var init_knowledge = __esm({
-  "src/memory/knowledge.ts"() {
+function renderStrategy(entry) {
+  const { strategy, sources } = entry;
+  const frontmatter = stringifyYaml2({
+    id: strategy.id,
+    slug: strategy.slug,
+    status: strategy.status,
+    priority: strategy.priority,
+    linked_play_ids: strategy.linked_play_ids,
+    source_count: sources.length,
+    updated_at: strategy.updated_at
+  }).trim();
+  return [
+    "---",
+    frontmatter,
+    "---",
+    "",
+    `# ${strategy.title}`,
+    "",
+    `Goal: ${strategy.goal}`,
+    "",
+    `Hypothesis: ${strategy.hypothesis}`,
+    "",
+    `Target segment: ${strategy.target_segment}`,
+    "",
+    "## Recommended Actions",
+    "",
+    strategy.recommended_actions.length > 0 ? strategy.recommended_actions.map((action) => `- ${action}`).join("\n") : "_None specified._",
+    "",
+    "## Source Metadata",
+    "",
+    "```json",
+    JSON.stringify(sources, null, 2),
+    "```",
+    ""
+  ].join("\n");
+}
+function getRootPath(target) {
+  return resolve7(target.directory ?? `ntrp-repository-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`);
+}
+function safeFilename(value) {
+  return (basename5(value).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "strategy") + ".md";
+}
+function escapeSummary(value) {
+  return value.replace(/[<>]/g, "");
+}
+var markdownRepositoryAdapter;
+var init_markdown2 = __esm({
+  "src/repositories/markdown.ts"() {
     "use strict";
-    init_store();
-    init_readers();
-    KNOWLEDGE_FILE = "knowledge.jsonl";
+    init_formatters();
+    markdownRepositoryAdapter = {
+      kind: "markdown",
+      describeTarget(target) {
+        return target.directory ? `local markdown folder ${resolve7(target.directory)}` : "local markdown folder";
+      },
+      planWrite(pkg) {
+        const files = renderMarkdownFiles(pkg);
+        return {
+          target: pkg.target,
+          root_path: getRootPath(pkg.target),
+          files: files.map((file) => ({
+            path: file.relativePath,
+            bytes: Buffer.byteLength(file.contents, "utf-8"),
+            description: file.description
+          }))
+        };
+      },
+      write(pkg) {
+        const root = getRootPath(pkg.target);
+        const files = renderMarkdownFiles(pkg);
+        mkdirSync9(root, { recursive: true });
+        const written = [];
+        for (const file of files) {
+          const absolutePath = join15(root, file.relativePath);
+          mkdirSync9(dirname2(absolutePath), { recursive: true });
+          writeFileSync11(absolutePath, file.contents, "utf-8");
+          written.push(absolutePath);
+        }
+        return {
+          mode: "repository_export",
+          target: pkg.target,
+          root_path: root,
+          files_written: written,
+          bundle_id: pkg.export_id,
+          message: `Wrote ${written.length} repository export files to ${root}.`,
+          external_side_effects: false
+        };
+      }
+    };
   }
 });
 
-// src/memory/store.ts
-var store_exports2 = {};
-__export(store_exports2, {
-  FACTS_JSONL: () => FACTS_JSONL,
-  LEDGER_JSONL: () => LEDGER_JSONL,
-  addFact: () => addFact,
-  buildMemoryBlock: () => buildMemoryBlock,
-  listFacts: () => listFacts,
-  listLedger: () => listLedger,
-  recordAnalysis: () => recordAnalysis,
-  rewriteJsonl: () => rewriteJsonl,
-  scrubText: () => scrubText
-});
-import { existsSync as existsSync17, readFileSync as readFileSync15, appendFileSync as appendFileSync4, readdirSync as readdirSync4, writeFileSync as writeFileSync12 } from "fs";
-import { join as join18 } from "path";
-import { randomUUID as randomUUID5 } from "crypto";
-function memPath(file) {
-  return join18(getMemoryDir(), file);
-}
-function readJsonl(file) {
-  const path = memPath(file);
-  if (!existsSync17(path)) return [];
-  const out = [];
-  for (const line of readFileSync15(path, "utf-8").split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    try {
-      out.push(JSON.parse(trimmed));
-    } catch {
-    }
-  }
-  return out;
-}
-function appendJsonl(file, obj) {
-  try {
-    appendFileSync4(memPath(file), JSON.stringify(obj) + "\n");
-  } catch {
+// src/repositories/adapters.ts
+function getRepositoryAdapter(kind) {
+  switch (kind) {
+    case "markdown":
+      return markdownRepositoryAdapter;
+    case "notion":
+    case "airtable":
+    case "github":
+      throw new NtrpError("repository_target_planned", `${kind} repository exports are planned but not implemented yet. Use --target markdown for now.`, 2 /* Usage */);
   }
 }
-function rewriteJsonl(file, rows) {
-  try {
-    writeFileSync12(memPath(file), rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length ? "\n" : ""));
-  } catch {
-  }
-}
-function scrubText(text) {
-  return text.replace(/[\w.+-]+@[\w-]+\.[\w.-]+/g, "[email]").trim();
-}
-function addFact(input) {
-  const fact = {
-    id: randomUUID5(),
-    text: scrubText(input.text),
-    kind: input.kind ?? "fact",
-    source: input.source ?? "user",
-    session_id: input.session_id,
-    created_at: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  appendJsonl(FACTS_FILE, fact);
-  return fact;
-}
-function listFacts() {
-  return readJsonl(FACTS_FILE);
-}
-function summarizeAnswer(answer) {
-  const plain = answer.replace(/[#*`>_]/g, "").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\s+/g, " ").trim();
-  const match = plain.match(/^(.+?[.!?])(\s|$)/);
-  const sentence = match ? match[1] : plain;
-  return sentence.length > 200 ? sentence.slice(0, 200).replace(/\s+\S*$/, "") + "\u2026" : sentence;
-}
-function recordAnalysis(input) {
-  const entry = {
-    id: randomUUID5(),
-    question: scrubText(input.question).slice(0, 300),
-    summary: scrubText(summarizeAnswer(input.answer)),
-    tools: input.tools,
-    session_id: input.session_id,
-    created_at: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  appendJsonl(LEDGER_FILE, entry);
-  return entry;
-}
-function listLedger() {
-  return readJsonl(LEDGER_FILE);
-}
-async function loadStrategySnippets() {
-  try {
-    const { getStrategies: getStrategies2 } = await Promise.resolve().then(() => (init_strategy(), strategy_exports));
-    const strategies = await getStrategies2("all");
-    return strategies.filter((s) => s.status === "active" || s.status === "draft").map((s) => ({
-      id: `strategy:${s.slug}`,
-      title: s.title,
-      text: `${s.title}. Goal: ${s.goal} Hypothesis: ${s.hypothesis} Target: ${s.target_segment}`
-    }));
-  } catch {
-    return [];
-  }
-}
-function loadWinSnippets() {
-  try {
-    const dir = getWinsDir();
-    const out = [];
-    for (const name of readdirSync4(dir)) {
-      if (!name.endsWith(".md") || name.toLowerCase() === "readme.md") continue;
-      const raw = readFileSync15(join18(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}` });
-    }
-    return out;
-  } catch {
-    return [];
-  }
-}
-async function buildMemoryBlock(query, opts = {}) {
-  const maxFacts = opts.maxFacts ?? 8;
-  const maxLedger = opts.maxLedger ?? 6;
-  const maxStrategies = opts.maxStrategies ?? 4;
-  const maxWins = opts.maxWins ?? 3;
-  const maxKnowledge = opts.maxKnowledge ?? 4;
-  const facts = listFacts();
-  const ledger = listLedger();
-  const strategies = await loadStrategySnippets();
-  const wins = loadWinSnippets();
-  let knowledge = [];
-  try {
-    knowledge = loadKnowledgeChunks();
-  } catch {
-    knowledge = [];
-  }
-  const sections = [];
-  if (facts.length > 0) {
-    const ranked = await rankByRelevance(query, facts.map((f) => ({ id: f.id, text: f.text, embedding: f.embedding })), maxFacts);
-    const chosen = ranked.map((r) => facts.find((f) => f.id === r.id)).filter(Boolean);
-    if (chosen.length > 0) {
-      sections.push(
-        "Known facts & decisions:\n" + chosen.map((f) => `- ${f.text}${f.kind === "decision" ? " (decision)" : f.kind === "preference" ? " (preference)" : ""}`).join("\n")
-      );
-    }
-  }
-  if (strategies.length > 0) {
-    const ranked = await rankByRelevance(query, strategies, maxStrategies);
-    const chosen = ranked.map((r) => strategies.find((s) => s.id === r.id)).filter(Boolean);
-    if (chosen.length > 0) {
-      sections.push("Active strategies:\n" + chosen.map((s) => `- ${s.title}`).join("\n"));
-    }
-  }
-  if (wins.length > 0) {
-    const ranked = await rankByRelevance(query, wins, maxWins);
-    const chosen = ranked.map((r) => wins.find((w) => w.id === r.id)).filter(Boolean);
-    if (chosen.length > 0) {
-      sections.push("Logged wins (what has worked before):\n" + chosen.map((w) => `- ${w.title}`).join("\n"));
-    }
-  }
-  if (knowledge.length > 0) {
-    const ranked = await rankByRelevance(query, knowledge.map((k) => ({ id: k.id, text: k.text, embedding: k.embedding })), maxKnowledge);
-    const chosen = ranked.map((r) => knowledge.find((k) => k.id === r.id)).filter(Boolean);
-    if (chosen.length > 0) {
-      sections.push(
-        "Relevant external knowledge (case studies / frameworks you've ingested):\n" + chosen.map((k) => `- [${k.title}] ${k.text.replace(/\s+/g, " ").slice(0, 280)}`).join("\n")
-      );
-    }
-  }
-  if (ledger.length > 0) {
-    const ranked = await rankByRelevance(
-      query,
-      ledger.map((l) => ({ id: l.id, text: `${l.question} ${l.summary}`, embedding: l.embedding })),
-      maxLedger
-    );
-    const chosen = ranked.map((r) => ledger.find((l) => l.id === r.id)).filter(Boolean);
-    if (chosen.length > 0) {
-      sections.push(
-        "Analyses already run for this business (do NOT repeat these unless asked to revisit or connect them):\n" + chosen.map((l) => `- "${l.question}" \u2192 ${l.summary}`).join("\n")
-      );
-    }
-  }
-  return sections.join("\n\n");
-}
-var FACTS_FILE, LEDGER_FILE, FACTS_JSONL, LEDGER_JSONL;
-var init_store2 = __esm({
-  "src/memory/store.ts"() {
-    "use strict";
-    init_store();
-    init_retrieval();
-    init_knowledge();
-    FACTS_FILE = "facts.jsonl";
-    LEDGER_FILE = "ledger.jsonl";
-    FACTS_JSONL = FACTS_FILE;
-    LEDGER_JSONL = LEDGER_FILE;
+var init_adapters = __esm({
+  "src/repositories/adapters.ts"() {
+    "use strict";
+    init_markdown2();
+    init_errors2();
+    init_types2();
   }
 });
 
-// src/mcp/server.ts
-init_context2();
-init_diagnosis();
-init_metrics_analysis();
-import { createInterface as createInterface2 } from "readline";
-
-// src/services/report.ts
-init_schema();
-init_queries();
-init_errors2();
-init_types2();
-async function loadReportData(segmentName) {
+// src/services/publish.ts
+async function proposeRepositoryExport(options) {
   await initSchema();
-  const diagnosis = await loadLatestDiagnosis();
-  if (!diagnosis) {
-    throw new NtrpError("no_diagnosis", "No diagnosis data found. Run diagnose first.", 4 /* NoData */);
-  }
-  let { health, segments, findings, entityCounts } = diagnosis;
-  let scopedSegment = null;
-  if (segmentName) {
-    const lower = segmentName.toLowerCase();
-    let match = segments.find((s) => s.segment.name.toLowerCase() === lower);
-    if (!match) {
-      const subs = segments.filter((s) => s.segment.name.toLowerCase().includes(lower));
-      if (subs.length === 1) match = subs[0];
-      else if (subs.length > 1) {
-        throw new NtrpError("ambiguous_segment", `"${segmentName}" matches multiple segments.`, 2 /* Usage */, {
-          matches: subs.map((s) => s.segment.name)
-        });
-      }
-    }
-    if (!match) {
-      throw new NtrpError("segment_not_found", `No segment matching "${segmentName}".`, 2 /* Usage */, {
-        available_segments: segments.map((s) => s.segment.name)
-      });
-    }
-    scopedSegment = match;
-    health = match.result;
-    segments = [match];
-    findings = findings.filter((f) => f.segment.toLowerCase().includes(lower));
+  const pkg = await buildPackage(options, "publish propose");
+  const adapter = getRepositoryAdapter(pkg.target.kind);
+  const plan = adapter.planWrite(pkg);
+  const id = await insertActionProposal({
+    handle_title: options.source === "smoke_protocol" ? "Monkey Pelican Export" : "NTRP Repository Export",
+    kind: "repository_export",
+    title: options.source === "smoke_protocol" ? "Monkey Pelican Export" : `Publish NTRP evidence bundle to ${pkg.target.kind}`,
+    summary: `Export diagnosis, findings, strategies, evidence, and action receipts to ${adapter.describeTarget(pkg.target)}.`,
+    permission_class: "execute",
+    status: "pending_approval",
+    target: {
+      connector_id: `${pkg.target.kind}-repository`,
+      connector_type: pkg.target.kind,
+      operation: "write_repository_export"
+    },
+    payload: {
+      repository_export: pkg,
+      write_plan: plan
+    },
+    dry_run: {
+      mode: "dry_run",
+      summary: `Would write ${plan.files.length} file${plan.files.length === 1 ? "" : "s"} to ${plan.root_path}.`,
+      would_execute: false,
+      expected_mutations: plan.files.map((file) => `${file.path} (${file.description})`),
+      risk_notes: [
+        "Requires explicit local approval before writing files.",
+        "Markdown target writes only to the local filesystem.",
+        "Notion and Airtable targets are planned adapter mappings only in this slice."
+      ]
+    },
+    source: options.source ?? "publish"
+  });
+  const proposal = await getActionProposal(id);
+  if (!proposal) {
+    throw new NtrpError("publish_proposal_missing", `Publish proposal was not found after insert: ${id}`, 1 /* RuntimeError */);
   }
-  return {
-    diagnosis,
-    scopedSegment,
-    reportData: {
-      health,
-      segments,
-      findings,
-      entityCounts,
-      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    }
-  };
-}
-
-// src/services/ask.ts
-init_agentic_loop();
-
-// src/ai/explore-mode.ts
-init_context2();
-var DEEP_DIVE_PATTERNS = [
-  /\b(break down|breakdown|drill|dig deeper|show me|list all|by rep|by stage|by segment|query|sql|detail|expand|elaborate|full analysis|walk me through|pull up|give me the data)\b/i,
-  /\b(how many|which deals|which accounts|who owns|top \d+|every deal|all stuck)\b/i
-];
-function isDeepDiveQuestion(question) {
-  return DEEP_DIVE_PATTERNS.some((p) => p.test(question.trim()));
+  return { action: "propose", proposal, plan };
 }
-function resolveExploreResponseMode(question, ctx, priorTurnCount) {
-  if (isDeepDiveQuestion(question)) return "deep";
-  if (isAnalysisReady(ctx)) return "brief";
-  if (ctx.stage === "analyzed" || ctx.analysis.completed.length > 0) return "brief";
-  if (priorTurnCount === 0) return "deep";
-  return "brief";
+async function buildPackage(options, command) {
+  const target = {
+    kind: options.target,
+    directory: options.directory
+  };
+  return buildRepositoryExportPackage({
+    target,
+    command,
+    source: options.source ?? "publish",
+    modelOrFixture: options.modelOrFixture
+  });
 }
-
-// src/services/ask.ts
-init_health_score();
-init_divergence();
-init_repl_api();
-init_context2();
-init_phase();
-init_session_analysis();
+var init_publish = __esm({
+  "src/services/publish.ts"() {
+    "use strict";
+    init_queries();
+    init_schema();
+    init_errors2();
+    init_types2();
+    init_bundle();
+    init_adapters();
+  }
+});
 
 // src/services/smoke-protocol.ts
-init_queries();
-init_diagnosis();
-init_strategy();
 import { join as join16 } from "path";
-
-// src/services/publish.ts
-init_queries();
-init_schema();
-init_errors2();
-init_types2();
-
-// src/repositories/bundle.ts
-init_queries();
-init_session_analysis();
-init_schema();
-init_formatters();
-init_errors2();
-init_types2();
-async function buildRepositoryExportPackage(options) {
-  await initSchema();
-  const bundle = await loadSessionAnalysisBundle();
-  const diagnosis = bundle.diagnosis;
-  if (!diagnosis) {
-    if (bundle.metrics) {
-      throw new NtrpError(
-        "diagnosis_required",
-        "Publish packages require a GTM health snapshot. Run /diagnose (companion) or /handoff report for metrics-only export.",
-        4 /* NoData */
-      );
-    }
-    if (!hasAnyAnalysis(bundle)) {
-      throw new NtrpError("diagnosis_required", "No analysis data found. Run /new, /diagnose, or /metrics first.", 4 /* NoData */);
-    }
-    throw new NtrpError("diagnosis_required", "No diagnosis data found. Run /diagnose first.", 4 /* NoData */);
-  }
-  const strategies = await listStrategies("all");
-  const strategiesWithSources = await Promise.all(
-    strategies.map(async (strategy) => ({
-      strategy,
-      sources: await listStrategySources(strategy.id)
-    }))
-  );
-  const proposals = await listActionProposals(100);
-  const actions = await Promise.all(
-    proposals.map(async (proposal) => ({
-      proposal,
-      executions: await listActionExecutions(proposal.id)
-    }))
+function isSmokeProtocolTrigger(input) {
+  return normalize(input).includes(SMOKE_TRIGGER_PHRASE);
+}
+async function runSmokeProtocol(_input, ctx) {
+  const diagnosis = await runDiagnosis({ findings: false, segments: true });
+  ctx.snapshot.computeResult = {
+    aggregate: diagnosis.health,
+    segments: diagnosis.segments
+  };
+  ctx.snapshot.divergences = diagnosis.divergences;
+  const gatingVital = diagnosis.health.vital_signs.find((vs) => vs.vital_sign === diagnosis.health.gating_vital_sign) ?? diagnosis.health.vital_signs[0];
+  const play = getPlaysForVitalSign(diagnosis.health.gating_vital_sign)[0];
+  const finding = buildSmokeFinding(
+    diagnosis.health.vital_signs,
+    gatingVital,
+    play?.id ?? "review-playbook",
+    play?.name ?? "Review the playbook"
   );
-  const sections = buildSections({
-    diagnosis,
-    strategiesCount: strategiesWithSources.length,
-    actionsCount: actions.length
+  await insertFinding({
+    findings: [finding],
+    model_used: "smoke-protocol-v1",
+    raw_prompt: `Smoke trigger: ${SMOKE_TRIGGER_PHRASE}`
+  });
+  const strategyResult = await addStrategyText(renderSmokeStrategy(finding, play?.name ?? "Review the playbook"), {
+    useAi: false,
+    sourceMetadata: {
+      connector_kind: "smoke_protocol",
+      connector_name: "Monkey Pelican Trigger",
+      sync_mode: "local_fixture",
+      write_back: "approval_required_future",
+      trigger_phrase: SMOKE_TRIGGER_PHRASE
+    }
+  });
+  const proposalResult = await proposeRepositoryExport({
+    target: "markdown",
+    directory: join16(getExportsDir(), "repository-smoke"),
+    source: "smoke_protocol",
+    modelOrFixture: "smoke-protocol-v1"
+  });
+  const answer = renderSmokeAnswer({
+    overallScore: diagnosis.health.overall_score,
+    overallStatus: diagnosis.health.overall_status,
+    gatingVital: diagnosis.health.gating_vital_sign,
+    totalValueAtRisk: diagnosis.health.total_value_at_risk,
+    finding,
+    strategyTitle: strategyResult.strategy.title,
+    strategyPath: strategyResult.library_path
   });
   return {
-    schema_version: "ntrp.repository_export.v1",
-    export_id: uuid(),
-    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
-    target: options.target,
-    summary: {
+    answer,
+    finding,
+    strategy: strategyResult.strategy,
+    action_proposal: proposalResult.proposal,
+    health: {
       overall_score: diagnosis.health.overall_score,
       overall_status: diagnosis.health.overall_status,
       gating_vital_sign: diagnosis.health.gating_vital_sign,
-      total_value_at_risk: diagnosis.health.total_value_at_risk ?? null,
-      findings_count: diagnosis.findings.length,
-      strategies_count: strategiesWithSources.length,
-      action_proposals_count: actions.length
-    },
-    diagnosis: {
-      health: diagnosis.health,
-      segments: diagnosis.segments.map((segment) => ({
-        segment: segment.segment,
-        result: segment.result
-      })),
-      findings: diagnosis.findings,
-      entity_counts: diagnosis.entityCounts,
-      upload_batch_id: diagnosis.uploadBatchId
-    },
-    strategies: strategiesWithSources,
-    actions,
-    sections,
-    provenance: {
-      command: options.command ?? "publish",
-      model_or_fixture: options.modelOrFixture,
-      source: options.source ?? "local_duckdb",
-      notes: [
-        "Generated from the latest persisted diagnosis.",
-        "Repository writes are approval-gated through local action proposals."
-      ]
+      total_value_at_risk: diagnosis.health.total_value_at_risk ?? null
     }
   };
 }
-function buildSections(input) {
-  const { diagnosis } = input;
-  const health = diagnosis.health;
-  return [
-    {
-      id: "cover",
-      title: "Cover Summary",
-      summary: `${health.overall_score}/100 ${health.overall_status}, gated by ${health.gating_vital_sign}`,
-      markdown: [
-        `Overall score: **${health.overall_score}/100** (${health.overall_status})`,
-        `Gating vital sign: **${VITAL_SIGN_LABELS[health.gating_vital_sign]}**`,
-        `Total value at risk: **${health.total_value_at_risk ? formatCurrency(health.total_value_at_risk) : "N/A"}**`,
-        `Findings: **${diagnosis.findings.length}**`,
-        `Strategies: **${input.strategiesCount}**`,
-        `Action proposals: **${input.actionsCount}**`
-      ].join("\n\n")
-    },
-    {
-      id: "vital-signs",
-      title: "Vital Signs",
-      summary: `${health.vital_signs.length} vital signs`,
-      markdown: health.vital_signs.map((vs) => `- **${VITAL_SIGN_LABELS[vs.vital_sign]}:** ${Math.round(vs.score)}/100 (${vs.status}) \u2014 ${formatDollarImpact(vs.dollar_value, vs.dollar_label)}`).join("\n"),
-      children: health.vital_signs.map((vs) => ({
-        id: `vital-${vs.vital_sign}`,
-        title: `${VITAL_SIGN_LABELS[vs.vital_sign]}: ${Math.round(vs.score)}/100`,
-        summary: formatDollarImpact(vs.dollar_value, vs.dollar_label),
-        markdown: [
-          `Status: **${vs.status}**`,
-          `Value: **${formatDollarImpact(vs.dollar_value, vs.dollar_label)}**`,
-          `Flagged entities: **${vs.entity_details.length}**`,
-          "",
-          "Components:",
-          "```json",
-          JSON.stringify(vs.components, null, 2),
-          "```",
-          "",
-          "Top entity details:",
-          "```json",
-          JSON.stringify(vs.entity_details.slice(0, 25), null, 2),
-          "```"
-        ].join("\n"),
-        metadata: { vital_sign: vs.vital_sign }
-      }))
-    },
-    {
-      id: "findings",
-      title: "Findings and Deep Analysis",
-      summary: `${diagnosis.findings.length} findings`,
-      markdown: diagnosis.findings.length > 0 ? diagnosis.findings.map((finding) => `- **${finding.severity.toUpperCase()}** ${finding.segment}: ${finding.finding}`).join("\n") : "_No findings recorded._",
-      children: diagnosis.findings.map((finding, index) => ({
-        id: `finding-${index + 1}`,
-        title: `${finding.severity.toUpperCase()} \u2014 ${finding.segment}`,
-        summary: finding.dollar_value ? formatCurrency(finding.dollar_value) : void 0,
-        markdown: [
-          finding.finding,
-          "",
-          finding.recommended_plays && finding.recommended_plays.length > 0 ? `Recommended plays: ${finding.recommended_plays.map((play) => `**${play.play_name}**`).join(", ")}` : "Recommended plays: _None recorded._",
-          "",
-          "Scores:",
-          "```json",
-          JSON.stringify(finding.vital_signs, null, 2),
-          "```"
-        ].join("\n")
-      }))
-    },
-    {
-      id: "segments",
-      title: "Segments",
-      summary: `${diagnosis.segments.length} segments`,
-      markdown: diagnosis.segments.length > 0 ? diagnosis.segments.map((segment) => `- **${segment.segment.name}:** ${Math.round(segment.result.overall_score)}/100 (${segment.result.overall_status}), gated by ${segment.result.gating_vital_sign}`).join("\n") : "_No segments recorded._"
-    }
-  ];
+function buildSmokeFinding(vitals, gatingVital, playId, playName) {
+  const vitalSigns = Object.fromEntries(vitals.map((vs) => [vs.vital_sign, Math.round(vs.score)]));
+  const value = gatingVital?.dollar_value ?? null;
+  const valueLabel = gatingVital?.dollar_label ?? "value at risk";
+  const score = Math.round(gatingVital?.score ?? 0);
+  const vital = gatingVital?.vital_sign ?? "freshness";
+  const formattedValue = value === null ? "N/A" : formatCurrency(value);
+  return {
+    severity: gatingVital?.status === "red" ? "critical" : gatingVital?.status === "yellow" ? "warning" : "info",
+    segment: "All Pipeline",
+    finding: `**${formattedValue} ${valueLabel}** is the smoke-test headline. The current gating vital sign is **${vital}** at **${score}/100**, so the placeholder deep analysis would recommend **${playName}** as the next play.`,
+    vital_signs: vitalSigns,
+    entity_count: gatingVital?.entity_details.length ?? 0,
+    recommended_focus: vital,
+    dollar_value: value,
+    recommended_plays: [{
+      play_id: playId,
+      play_name: playName,
+      rationale: "Selected from the current gating vital sign to exercise the diagnosis-to-play smoke workflow."
+    }]
+  };
 }
+function renderSmokeStrategy(finding, playName) {
+  return `# Smoke Test: ${playName}
 
-// src/repositories/markdown.ts
-init_formatters();
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync11 } from "fs";
-import { basename as basename5, dirname as dirname2, join as join15, resolve as resolve7 } from "path";
-import { stringify as stringifyYaml2 } from "yaml";
-var markdownRepositoryAdapter = {
-  kind: "markdown",
-  describeTarget(target) {
-    return target.directory ? `local markdown folder ${resolve7(target.directory)}` : "local markdown folder";
-  },
-  planWrite(pkg) {
-    const files = renderMarkdownFiles(pkg);
-    return {
-      target: pkg.target,
-      root_path: getRootPath(pkg.target),
-      files: files.map((file) => ({
-        path: file.relativePath,
-        bytes: Buffer.byteLength(file.contents, "utf-8"),
-        description: file.description
-      }))
-    };
-  },
-  write(pkg) {
-    const root = getRootPath(pkg.target);
-    const files = renderMarkdownFiles(pkg);
-    mkdirSync9(root, { recursive: true });
-    const written = [];
-    for (const file of files) {
-      const absolutePath = join15(root, file.relativePath);
-      mkdirSync9(dirname2(absolutePath), { recursive: true });
-      writeFileSync11(absolutePath, file.contents, "utf-8");
-      written.push(absolutePath);
-    }
-    return {
-      mode: "repository_export",
-      target: pkg.target,
-      root_path: root,
-      files_written: written,
-      bundle_id: pkg.export_id,
-      message: `Wrote ${written.length} repository export files to ${root}.`,
-      external_side_effects: false
-    };
+Goal: Validate the flow from natural-language trigger to diagnosis, deep-analysis-style response, saved strategy, and approval-gated library write-back.
+
+Target Segment: ${finding.segment}
+
+Recommended play: ${playName}
+
+Smoke finding: ${finding.finding.replace(/\*\*/g, "")}
+`;
+}
+function renderSmokeAnswer(input) {
+  const totalValue = input.totalValueAtRisk === null ? "N/A" : formatCurrency(input.totalValueAtRisk);
+  return `### Smoke Protocol Complete
+
+I treated the monkey/pelican phrase as a local smoke trigger and ran the placeholder protocol without calling an AI model.
+
+- Diagnosis: overall score **${Math.round(input.overallScore)}/100** (${input.overallStatus}), gated by **${input.gatingVital}**, with **${totalValue}** total value at risk.
+- Deep analysis fixture: ${input.finding.finding}
+- Saved play/strategy: **${input.strategyTitle}** at \`${input.strategyPath}\`.
+- Repository export prepared for an approval-gated Obsidian-compatible markdown bundle.
+
+---
+*Next: run \`/actions continue\` to approve the export, then \`/actions continue\` again to write it to the repository.*`;
+}
+function normalize(input) {
+  return input.trim().toLowerCase().replace(/\s+/g, " ");
+}
+var SMOKE_TRIGGER_PHRASE;
+var init_smoke_protocol = __esm({
+  "src/services/smoke-protocol.ts"() {
+    "use strict";
+    init_queries();
+    init_diagnosis();
+    init_strategy();
+    init_publish();
+    init_playbook();
+    init_store();
+    init_formatters();
+    SMOKE_TRIGGER_PHRASE = "the monkey is green and riding a pelican";
   }
-};
-function renderMarkdownFiles(pkg) {
-  const bundleJson = JSON.stringify(pkg, null, 2) + "\n";
-  const vitalDetails = renderVitalEvidence(pkg);
-  const findings = renderFindings(pkg);
-  const receipts = JSON.stringify({
-    export_id: pkg.export_id,
-    generated_at: pkg.generated_at,
-    actions: pkg.actions
-  }, null, 2) + "\n";
-  const strategyFiles = pkg.strategies.map((entry) => ({
-    relativePath: `strategies/${safeFilename(entry.strategy.slug || entry.strategy.title)}`,
-    contents: renderStrategy(entry),
-    description: `Strategy: ${entry.strategy.title}`
-  }));
-  return [
-    {
-      relativePath: "index.md",
-      contents: renderIndex(pkg),
-      description: "Repository export index"
-    },
-    {
-      relativePath: "evidence/vital-signs.md",
-      contents: vitalDetails,
-      description: "Detailed vital-sign evidence"
-    },
-    {
-      relativePath: "evidence/findings.md",
-      contents: findings,
-      description: "Findings and recommended plays"
-    },
-    ...strategyFiles,
-    {
-      relativePath: "receipts/actions.json",
-      contents: receipts,
-      description: "Action proposal and execution receipts"
-    },
-    {
-      relativePath: "bundle.json",
-      contents: bundleJson,
-      description: "Canonical repository export package"
+});
+
+// src/ai/embeddings.ts
+var embeddings_exports = {};
+__export(embeddings_exports, {
+  embedItems: () => embedItems,
+  embedText: () => embedText,
+  isEmbeddingsEnabled: () => isEmbeddingsEnabled
+});
+function resolveConfig() {
+  const explicit = getConfigValue("embeddings-provider");
+  if (explicit === "none") return null;
+  const voyageKey = process.env.VOYAGE_API_KEY ?? getConfigValue("voyage-api-key");
+  const openaiKey = getOpenAiApiKey();
+  const provider = explicit ?? (voyageKey ? "voyage" : openaiKey ? "openai" : "none");
+  if (provider === "voyage" && voyageKey) {
+    return { provider, apiKey: voyageKey, model: VOYAGE_MODEL, url: "https://api.voyageai.com/v1/embeddings" };
+  }
+  if (provider === "openai" && openaiKey) {
+    return { provider, apiKey: openaiKey, model: OPENAI_MODEL, url: "https://api.openai.com/v1/embeddings" };
+  }
+  return null;
+}
+function isEmbeddingsEnabled() {
+  return resolveConfig() !== null;
+}
+async function callProvider(texts) {
+  const cfg = resolveConfig();
+  if (!cfg || texts.length === 0) return null;
+  try {
+    const res = await fetch(cfg.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${cfg.apiKey}`
+      },
+      body: JSON.stringify({ input: texts, model: cfg.model })
+    });
+    if (!res.ok) return null;
+    const json = await res.json();
+    if (!json.data) return null;
+    return json.data.map((d) => d.embedding);
+  } catch {
+    return null;
+  }
+}
+async function embedText(text) {
+  const key = text.trim();
+  if (!key) return null;
+  const cached2 = cache.get(key);
+  if (cached2) return cached2;
+  const result = await callProvider([key]);
+  const vec = result?.[0] ?? null;
+  if (vec) cache.set(key, vec);
+  return vec;
+}
+async function embedItems(items) {
+  const needing = [];
+  const out = items.map((it, index) => {
+    if (it.embedding && it.embedding.length > 0) return { ...it };
+    const cached2 = cache.get(it.text.trim());
+    if (cached2) return { ...it, embedding: cached2 };
+    needing.push({ index, text: it.text });
+    return { ...it };
+  });
+  if (needing.length === 0) return out;
+  const vectors = await callProvider(needing.map((n) => n.text));
+  if (!vectors) return out;
+  needing.forEach((n, i) => {
+    const vec = vectors[i];
+    if (vec) {
+      out[n.index].embedding = vec;
+      cache.set(n.text.trim(), vec);
     }
-  ];
+  });
+  return out;
 }
-function renderIndex(pkg) {
-  const frontmatter = stringifyYaml2({
-    export_id: pkg.export_id,
-    generated_at: pkg.generated_at,
-    target: pkg.target.kind,
-    overall_score: pkg.summary.overall_score,
-    overall_status: pkg.summary.overall_status,
-    gating_vital_sign: pkg.summary.gating_vital_sign,
-    total_value_at_risk: pkg.summary.total_value_at_risk,
-    tags: ["ntrp", "repository-export", pkg.summary.gating_vital_sign.replace(/_/g, "-")]
-  }).trim();
-  return [
-    "---",
-    frontmatter,
-    "---",
-    "",
-    "# NTRP Repository Export",
-    "",
-    `Generated: ${pkg.generated_at}`,
-    "",
-    `Overall score: **${pkg.summary.overall_score}/100** (${pkg.summary.overall_status})`,
-    `Gating vital sign: **${VITAL_SIGN_LABELS[pkg.summary.gating_vital_sign]}**`,
-    `Total value at risk: **${pkg.summary.total_value_at_risk ? formatCurrency(pkg.summary.total_value_at_risk) : "N/A"}**`,
-    "",
-    "## Sections",
-    "",
-    ...pkg.sections.map(renderSection),
-    "## Files",
-    "",
-    "- [[evidence/vital-signs|Vital-sign evidence]]",
-    "- [[evidence/findings|Findings]]",
-    "- `bundle.json`",
-    "- `receipts/actions.json`",
-    ""
-  ].join("\n");
+var VOYAGE_MODEL, OPENAI_MODEL, cache;
+var init_embeddings = __esm({
+  "src/ai/embeddings.ts"() {
+    "use strict";
+    init_store();
+    init_llm_config();
+    VOYAGE_MODEL = "voyage-3";
+    OPENAI_MODEL = "text-embedding-3-small";
+    cache = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/memory/retrieval.ts
+function tokenize(text) {
+  return text.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length >= 3 && !STOPWORDS.has(t));
 }
-function renderSection(section) {
-  const childMarkdown = section.children && section.children.length > 0 ? ["", ...section.children.map(renderNestedSection)].join("\n") : "";
-  return [
-    "<details>",
-    `<summary>${escapeSummary(section.title)}${section.summary ? ` \u2014 ${escapeSummary(section.summary)}` : ""}</summary>`,
-    "",
-    section.markdown,
-    childMarkdown,
-    "",
-    "</details>",
-    ""
-  ].join("\n");
+function keywordRank(query, items, topK) {
+  const queryTokens = new Set(tokenize(query));
+  if (queryTokens.size === 0) {
+    return items.slice(-topK).reverse().map((it) => ({ id: it.id, score: 0 }));
+  }
+  const scored = items.map((it) => {
+    const tokens = tokenize(it.text);
+    if (tokens.length === 0) return { id: it.id, score: 0 };
+    let overlap = 0;
+    const seen = /* @__PURE__ */ new Set();
+    for (const t of tokens) {
+      if (queryTokens.has(t) && !seen.has(t)) {
+        overlap++;
+        seen.add(t);
+      }
+    }
+    return { id: it.id, score: overlap / Math.sqrt(tokens.length) };
+  });
+  const positive = scored.filter((s) => s.score > 0).sort((a, b) => b.score - a.score);
+  if (positive.length > 0) return positive.slice(0, topK);
+  return items.slice(-topK).reverse().map((it) => ({ id: it.id, score: 0 }));
 }
-function renderNestedSection(section) {
-  return [
-    "<details>",
-    `<summary>${escapeSummary(section.title)}${section.summary ? ` \u2014 ${escapeSummary(section.summary)}` : ""}</summary>`,
-    "",
-    section.markdown,
-    "",
-    "</details>"
-  ].join("\n");
+function cosine(a, b) {
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  const len = Math.min(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  if (na === 0 || nb === 0) return 0;
+  return dot / (Math.sqrt(na) * Math.sqrt(nb));
 }
-function renderVitalEvidence(pkg) {
-  const lines = ["# Vital-Sign Evidence", ""];
-  for (const vs of pkg.diagnosis.health.vital_signs) {
-    lines.push(`## ${VITAL_SIGN_LABELS[vs.vital_sign]}`);
-    lines.push("");
-    lines.push(`Score: **${Math.round(vs.score)}/100** (${vs.status})`);
-    lines.push(`Value: **${formatDollarImpact(vs.dollar_value, vs.dollar_label)}**`);
-    lines.push(`Flagged entities: **${vs.entity_details.length}**`);
-    lines.push("");
-    lines.push("<details>");
-    lines.push("<summary>Components</summary>");
-    lines.push("");
-    lines.push("```json");
-    lines.push(JSON.stringify(vs.components, null, 2));
-    lines.push("```");
-    lines.push("");
-    lines.push("</details>");
-    lines.push("");
-    lines.push("<details>");
-    lines.push("<summary>Entity details</summary>");
-    lines.push("");
-    lines.push("```json");
-    lines.push(JSON.stringify(vs.entity_details, null, 2));
-    lines.push("```");
-    lines.push("");
-    lines.push("</details>");
-    lines.push("");
+async function rankByRelevance(query, items, topK) {
+  if (items.length === 0) return [];
+  try {
+    const { isEmbeddingsEnabled: isEmbeddingsEnabled2, embedText: embedText2, embedItems: embedItems2 } = await Promise.resolve().then(() => (init_embeddings(), embeddings_exports));
+    if (isEmbeddingsEnabled2()) {
+      const queryVec = await embedText2(query);
+      if (queryVec) {
+        const withVecs = await embedItems2(items);
+        const scored = withVecs.filter((it) => it.embedding && it.embedding.length > 0).map((it) => ({ id: it.id, score: cosine(queryVec, it.embedding) })).sort((a, b) => b.score - a.score);
+        if (scored.length > 0) return scored.slice(0, topK);
+      }
+    }
+  } catch {
+  }
+  return keywordRank(query, items, topK);
+}
+var STOPWORDS;
+var init_retrieval = __esm({
+  "src/memory/retrieval.ts"() {
+    "use strict";
+    STOPWORDS = /* @__PURE__ */ new Set([
+      "the",
+      "and",
+      "for",
+      "are",
+      "was",
+      "were",
+      "with",
+      "that",
+      "this",
+      "from",
+      "have",
+      "has",
+      "had",
+      "our",
+      "your",
+      "you",
+      "what",
+      "which",
+      "how",
+      "why",
+      "who",
+      "when",
+      "where",
+      "into",
+      "about",
+      "over",
+      "than",
+      "then",
+      "they",
+      "them",
+      "their",
+      "there",
+      "here",
+      "been",
+      "being",
+      "does",
+      "did",
+      "doing",
+      "can",
+      "could",
+      "would",
+      "should",
+      "will",
+      "shall",
+      "may",
+      "might",
+      "must",
+      "not",
+      "but",
+      "all",
+      "any",
+      "some",
+      "more",
+      "most",
+      "much",
+      "many",
+      "very",
+      "just",
+      "like",
+      "out",
+      "off",
+      "per",
+      "via",
+      "use",
+      "get",
+      "got"
+    ]);
   }
-  return lines.join("\n");
+});
+
+// src/memory/knowledge.ts
+import { existsSync as existsSync16, readFileSync as readFileSync14, appendFileSync as appendFileSync3, readdirSync as readdirSync3 } from "fs";
+import { join as join17 } from "path";
+import { randomUUID as randomUUID4 } from "crypto";
+function knowledgePath() {
+  return join17(getMemoryDir(), KNOWLEDGE_FILE);
 }
-function renderFindings(pkg) {
-  if (pkg.diagnosis.findings.length === 0) return "# Findings\n\n_No findings recorded._\n";
-  const lines = ["# Findings", ""];
-  for (const finding of pkg.diagnosis.findings) {
-    lines.push(`## ${finding.severity.toUpperCase()} \u2014 ${finding.segment}`);
-    lines.push("");
-    lines.push(finding.finding);
-    lines.push("");
-    if (finding.dollar_value) lines.push(`Dollar value: **${formatCurrency(finding.dollar_value)}**`);
-    if (finding.recommended_plays && finding.recommended_plays.length > 0) {
-      lines.push(`Recommended plays: ${finding.recommended_plays.map((play) => `**${play.play_name}**`).join(", ")}`);
+function loadKnowledgeChunks() {
+  const path = knowledgePath();
+  if (!existsSync16(path)) return [];
+  const out = [];
+  for (const line of readFileSync14(path, "utf-8").split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
     }
-    lines.push("");
-  }
-  return lines.join("\n");
-}
-function renderStrategy(entry) {
-  const { strategy, sources } = entry;
-  const frontmatter = stringifyYaml2({
-    id: strategy.id,
-    slug: strategy.slug,
-    status: strategy.status,
-    priority: strategy.priority,
-    linked_play_ids: strategy.linked_play_ids,
-    source_count: sources.length,
-    updated_at: strategy.updated_at
-  }).trim();
-  return [
-    "---",
-    frontmatter,
-    "---",
-    "",
-    `# ${strategy.title}`,
-    "",
-    `Goal: ${strategy.goal}`,
-    "",
-    `Hypothesis: ${strategy.hypothesis}`,
-    "",
-    `Target segment: ${strategy.target_segment}`,
-    "",
-    "## Recommended Actions",
-    "",
-    strategy.recommended_actions.length > 0 ? strategy.recommended_actions.map((action) => `- ${action}`).join("\n") : "_None specified._",
-    "",
-    "## Source Metadata",
-    "",
-    "```json",
-    JSON.stringify(sources, null, 2),
-    "```",
-    ""
-  ].join("\n");
-}
-function getRootPath(target) {
-  return resolve7(target.directory ?? `ntrp-repository-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`);
-}
-function safeFilename(value) {
-  return (basename5(value).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "strategy") + ".md";
-}
-function escapeSummary(value) {
-  return value.replace(/[<>]/g, "");
-}
-
-// src/repositories/adapters.ts
-init_errors2();
-init_types2();
-function getRepositoryAdapter(kind) {
-  switch (kind) {
-    case "markdown":
-      return markdownRepositoryAdapter;
-    case "notion":
-    case "airtable":
-    case "github":
-      throw new NtrpError("repository_target_planned", `${kind} repository exports are planned but not implemented yet. Use --target markdown for now.`, 2 /* Usage */);
   }
+  return out;
 }
-
-// src/services/publish.ts
-async function proposeRepositoryExport(options) {
-  await initSchema();
-  const pkg = await buildPackage(options, "publish propose");
-  const adapter = getRepositoryAdapter(pkg.target.kind);
-  const plan = adapter.planWrite(pkg);
-  const id = await insertActionProposal({
-    handle_title: options.source === "smoke_protocol" ? "Monkey Pelican Export" : "NTRP Repository Export",
-    kind: "repository_export",
-    title: options.source === "smoke_protocol" ? "Monkey Pelican Export" : `Publish NTRP evidence bundle to ${pkg.target.kind}`,
-    summary: `Export diagnosis, findings, strategies, evidence, and action receipts to ${adapter.describeTarget(pkg.target)}.`,
-    permission_class: "execute",
-    status: "pending_approval",
-    target: {
-      connector_id: `${pkg.target.kind}-repository`,
-      connector_type: pkg.target.kind,
-      operation: "write_repository_export"
-    },
-    payload: {
-      repository_export: pkg,
-      write_plan: plan
-    },
-    dry_run: {
-      mode: "dry_run",
-      summary: `Would write ${plan.files.length} file${plan.files.length === 1 ? "" : "s"} to ${plan.root_path}.`,
-      would_execute: false,
-      expected_mutations: plan.files.map((file) => `${file.path} (${file.description})`),
-      risk_notes: [
-        "Requires explicit local approval before writing files.",
-        "Markdown target writes only to the local filesystem.",
-        "Notion and Airtable targets are planned adapter mappings only in this slice."
-      ]
-    },
-    source: options.source ?? "publish"
-  });
-  const proposal = await getActionProposal(id);
-  if (!proposal) {
-    throw new NtrpError("publish_proposal_missing", `Publish proposal was not found after insert: ${id}`, 1 /* RuntimeError */);
+var KNOWLEDGE_FILE;
+var init_knowledge = __esm({
+  "src/memory/knowledge.ts"() {
+    "use strict";
+    init_store();
+    init_readers();
+    KNOWLEDGE_FILE = "knowledge.jsonl";
   }
-  return { action: "propose", proposal, plan };
-}
-async function buildPackage(options, command) {
-  const target = {
-    kind: options.target,
-    directory: options.directory
-  };
-  return buildRepositoryExportPackage({
-    target,
-    command,
-    source: options.source ?? "publish",
-    modelOrFixture: options.modelOrFixture
-  });
-}
+});
 
-// src/services/smoke-protocol.ts
-init_playbook();
-init_store();
-init_formatters();
-var SMOKE_TRIGGER_PHRASE = "the monkey is green and riding a pelican";
-function isSmokeProtocolTrigger(input) {
-  return normalize(input).includes(SMOKE_TRIGGER_PHRASE);
+// src/memory/store.ts
+var store_exports2 = {};
+__export(store_exports2, {
+  FACTS_JSONL: () => FACTS_JSONL,
+  LEDGER_JSONL: () => LEDGER_JSONL,
+  addFact: () => addFact,
+  buildMemoryBlock: () => buildMemoryBlock,
+  listFacts: () => listFacts,
+  listLedger: () => listLedger,
+  recordAnalysis: () => recordAnalysis,
+  rewriteJsonl: () => rewriteJsonl,
+  scrubText: () => scrubText
+});
+import { existsSync as existsSync17, readFileSync as readFileSync15, appendFileSync as appendFileSync4, readdirSync as readdirSync4, writeFileSync as writeFileSync12 } from "fs";
+import { join as join18 } from "path";
+import { randomUUID as randomUUID5 } from "crypto";
+function memPath(file) {
+  return join18(getMemoryDir(), file);
 }
-async function runSmokeProtocol(_input, ctx) {
-  const diagnosis = await runDiagnosis({ findings: false, segments: true });
-  ctx.snapshot.computeResult = {
-    aggregate: diagnosis.health,
-    segments: diagnosis.segments
-  };
-  ctx.snapshot.divergences = diagnosis.divergences;
-  const gatingVital = diagnosis.health.vital_signs.find((vs) => vs.vital_sign === diagnosis.health.gating_vital_sign) ?? diagnosis.health.vital_signs[0];
-  const play = getPlaysForVitalSign(diagnosis.health.gating_vital_sign)[0];
-  const finding = buildSmokeFinding(
-    diagnosis.health.vital_signs,
-    gatingVital,
-    play?.id ?? "review-playbook",
-    play?.name ?? "Review the playbook"
-  );
-  await insertFinding({
-    findings: [finding],
-    model_used: "smoke-protocol-v1",
-    raw_prompt: `Smoke trigger: ${SMOKE_TRIGGER_PHRASE}`
-  });
-  const strategyResult = await addStrategyText(renderSmokeStrategy(finding, play?.name ?? "Review the playbook"), {
-    useAi: false,
-    sourceMetadata: {
-      connector_kind: "smoke_protocol",
-      connector_name: "Monkey Pelican Trigger",
-      sync_mode: "local_fixture",
-      write_back: "approval_required_future",
-      trigger_phrase: SMOKE_TRIGGER_PHRASE
-    }
-  });
-  const proposalResult = await proposeRepositoryExport({
-    target: "markdown",
-    directory: join16(getExportsDir(), "repository-smoke"),
-    source: "smoke_protocol",
-    modelOrFixture: "smoke-protocol-v1"
-  });
-  const answer = renderSmokeAnswer({
-    overallScore: diagnosis.health.overall_score,
-    overallStatus: diagnosis.health.overall_status,
-    gatingVital: diagnosis.health.gating_vital_sign,
-    totalValueAtRisk: diagnosis.health.total_value_at_risk,
-    finding,
-    strategyTitle: strategyResult.strategy.title,
-    strategyPath: strategyResult.library_path
-  });
-  return {
-    answer,
-    finding,
-    strategy: strategyResult.strategy,
-    action_proposal: proposalResult.proposal,
-    health: {
-      overall_score: diagnosis.health.overall_score,
-      overall_status: diagnosis.health.overall_status,
-      gating_vital_sign: diagnosis.health.gating_vital_sign,
-      total_value_at_risk: diagnosis.health.total_value_at_risk ?? null
+function readJsonl(file) {
+  const path = memPath(file);
+  if (!existsSync17(path)) return [];
+  const out = [];
+  for (const line of readFileSync15(path, "utf-8").split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
     }
+  }
+  return out;
+}
+function appendJsonl(file, obj) {
+  try {
+    appendFileSync4(memPath(file), JSON.stringify(obj) + "\n");
+  } catch {
+  }
+}
+function rewriteJsonl(file, rows) {
+  try {
+    writeFileSync12(memPath(file), rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length ? "\n" : ""));
+  } catch {
+  }
+}
+function scrubText(text) {
+  return text.replace(/[\w.+-]+@[\w-]+\.[\w.-]+/g, "[email]").trim();
+}
+function addFact(input) {
+  const fact = {
+    id: randomUUID5(),
+    text: scrubText(input.text),
+    kind: input.kind ?? "fact",
+    source: input.source ?? "user",
+    session_id: input.session_id,
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
   };
+  appendJsonl(FACTS_FILE, fact);
+  return fact;
 }
-function buildSmokeFinding(vitals, gatingVital, playId, playName) {
-  const vitalSigns = Object.fromEntries(vitals.map((vs) => [vs.vital_sign, Math.round(vs.score)]));
-  const value = gatingVital?.dollar_value ?? null;
-  const valueLabel = gatingVital?.dollar_label ?? "value at risk";
-  const score = Math.round(gatingVital?.score ?? 0);
-  const vital = gatingVital?.vital_sign ?? "freshness";
-  const formattedValue = value === null ? "N/A" : formatCurrency(value);
-  return {
-    severity: gatingVital?.status === "red" ? "critical" : gatingVital?.status === "yellow" ? "warning" : "info",
-    segment: "All Pipeline",
-    finding: `**${formattedValue} ${valueLabel}** is the smoke-test headline. The current gating vital sign is **${vital}** at **${score}/100**, so the placeholder deep analysis would recommend **${playName}** as the next play.`,
-    vital_signs: vitalSigns,
-    entity_count: gatingVital?.entity_details.length ?? 0,
-    recommended_focus: vital,
-    dollar_value: value,
-    recommended_plays: [{
-      play_id: playId,
-      play_name: playName,
-      rationale: "Selected from the current gating vital sign to exercise the diagnosis-to-play smoke workflow."
-    }]
+function listFacts() {
+  return readJsonl(FACTS_FILE);
+}
+function summarizeAnswer(answer) {
+  const plain = answer.replace(/[#*`>_]/g, "").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\s+/g, " ").trim();
+  const match = plain.match(/^(.+?[.!?])(\s|$)/);
+  const sentence = match ? match[1] : plain;
+  return sentence.length > 200 ? sentence.slice(0, 200).replace(/\s+\S*$/, "") + "\u2026" : sentence;
+}
+function recordAnalysis(input) {
+  const entry = {
+    id: randomUUID5(),
+    question: scrubText(input.question).slice(0, 300),
+    summary: scrubText(summarizeAnswer(input.answer)),
+    tools: input.tools,
+    session_id: input.session_id,
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
   };
+  appendJsonl(LEDGER_FILE, entry);
+  return entry;
 }
-function renderSmokeStrategy(finding, playName) {
-  return `# Smoke Test: ${playName}
-
-Goal: Validate the flow from natural-language trigger to diagnosis, deep-analysis-style response, saved strategy, and approval-gated library write-back.
-
-Target Segment: ${finding.segment}
-
-Recommended play: ${playName}
-
-Smoke finding: ${finding.finding.replace(/\*\*/g, "")}
-`;
+function listLedger() {
+  return readJsonl(LEDGER_FILE);
 }
-function renderSmokeAnswer(input) {
-  const totalValue = input.totalValueAtRisk === null ? "N/A" : formatCurrency(input.totalValueAtRisk);
-  return `### Smoke Protocol Complete
-
-I treated the monkey/pelican phrase as a local smoke trigger and ran the placeholder protocol without calling an AI model.
-
-- Diagnosis: overall score **${Math.round(input.overallScore)}/100** (${input.overallStatus}), gated by **${input.gatingVital}**, with **${totalValue}** total value at risk.
-- Deep analysis fixture: ${input.finding.finding}
-- Saved play/strategy: **${input.strategyTitle}** at \`${input.strategyPath}\`.
-- Repository export prepared for an approval-gated Obsidian-compatible markdown bundle.
-
----
-*Next: run \`/actions continue\` to approve the export, then \`/actions continue\` again to write it to the repository.*`;
+async function loadStrategySnippets() {
+  try {
+    const { getStrategies: getStrategies2 } = await Promise.resolve().then(() => (init_strategy(), strategy_exports));
+    const strategies = await getStrategies2("all");
+    return strategies.filter((s) => s.status === "active" || s.status === "draft").map((s) => ({
+      id: `strategy:${s.slug}`,
+      title: s.title,
+      text: `${s.title}. Goal: ${s.goal} Hypothesis: ${s.hypothesis} Target: ${s.target_segment}`
+    }));
+  } catch {
+    return [];
+  }
 }
-function normalize(input) {
-  return input.trim().toLowerCase().replace(/\s+/g, " ");
+function loadWinSnippets() {
+  try {
+    const dir = getWinsDir();
+    const out = [];
+    for (const name of readdirSync4(dir)) {
+      if (!name.endsWith(".md") || name.toLowerCase() === "readme.md") continue;
+      const raw = readFileSync15(join18(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}` });
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+async function buildMemoryBlock(query, opts = {}) {
+  const maxFacts = opts.maxFacts ?? 8;
+  const maxLedger = opts.maxLedger ?? 6;
+  const maxStrategies = opts.maxStrategies ?? 4;
+  const maxWins = opts.maxWins ?? 3;
+  const maxKnowledge = opts.maxKnowledge ?? 4;
+  const facts = listFacts();
+  const ledger = listLedger();
+  const strategies = await loadStrategySnippets();
+  const wins = loadWinSnippets();
+  let knowledge = [];
+  try {
+    knowledge = loadKnowledgeChunks();
+  } catch {
+    knowledge = [];
+  }
+  const sections = [];
+  if (facts.length > 0) {
+    const ranked = await rankByRelevance(query, facts.map((f) => ({ id: f.id, text: f.text, embedding: f.embedding })), maxFacts);
+    const chosen = ranked.map((r) => facts.find((f) => f.id === r.id)).filter(Boolean);
+    if (chosen.length > 0) {
+      sections.push(
+        "Known facts & decisions:\n" + chosen.map((f) => `- ${f.text}${f.kind === "decision" ? " (decision)" : f.kind === "preference" ? " (preference)" : ""}`).join("\n")
+      );
+    }
+  }
+  if (strategies.length > 0) {
+    const ranked = await rankByRelevance(query, strategies, maxStrategies);
+    const chosen = ranked.map((r) => strategies.find((s) => s.id === r.id)).filter(Boolean);
+    if (chosen.length > 0) {
+      sections.push("Active strategies:\n" + chosen.map((s) => `- ${s.title}`).join("\n"));
+    }
+  }
+  if (wins.length > 0) {
+    const ranked = await rankByRelevance(query, wins, maxWins);
+    const chosen = ranked.map((r) => wins.find((w) => w.id === r.id)).filter(Boolean);
+    if (chosen.length > 0) {
+      sections.push("Logged wins (what has worked before):\n" + chosen.map((w) => `- ${w.title}`).join("\n"));
+    }
+  }
+  if (knowledge.length > 0) {
+    const ranked = await rankByRelevance(query, knowledge.map((k) => ({ id: k.id, text: k.text, embedding: k.embedding })), maxKnowledge);
+    const chosen = ranked.map((r) => knowledge.find((k) => k.id === r.id)).filter(Boolean);
+    if (chosen.length > 0) {
+      sections.push(
+        "Relevant external knowledge (case studies / frameworks you've ingested):\n" + chosen.map((k) => `- [${k.title}] ${k.text.replace(/\s+/g, " ").slice(0, 280)}`).join("\n")
+      );
+    }
+  }
+  if (ledger.length > 0) {
+    const ranked = await rankByRelevance(
+      query,
+      ledger.map((l) => ({ id: l.id, text: `${l.question} ${l.summary}`, embedding: l.embedding })),
+      maxLedger
+    );
+    const chosen = ranked.map((r) => ledger.find((l) => l.id === r.id)).filter(Boolean);
+    if (chosen.length > 0) {
+      sections.push(
+        "Analyses already run for this business (do NOT repeat these unless asked to revisit or connect them):\n" + chosen.map((l) => `- "${l.question}" \u2192 ${l.summary}`).join("\n")
+      );
+    }
+  }
+  return sections.join("\n\n");
 }
+var FACTS_FILE, LEDGER_FILE, FACTS_JSONL, LEDGER_JSONL;
+var init_store2 = __esm({
+  "src/memory/store.ts"() {
+    "use strict";
+    init_store();
+    init_retrieval();
+    init_knowledge();
+    FACTS_FILE = "facts.jsonl";
+    LEDGER_FILE = "ledger.jsonl";
+    FACTS_JSONL = FACTS_FILE;
+    LEDGER_JSONL = LEDGER_FILE;
+  }
+});
 
 // src/services/ask.ts
 async function ensureAskSnapshot(ctx) {
@@ -16459,24 +17254,22 @@ async function runAsk(question, ctx) {
   }
   return { answer, tool_calls: toolCalls, findings, model_used: modelUsed, provider_used: providerUsed, failover };
 }
-
-// src/services/setup.ts
-init_repl_api();
-init_providers();
-init_llm_config();
-init_store();
-init_profile();
-import { existsSync as existsSync18, mkdirSync as mkdirSync10, readFileSync as readFileSync16, writeFileSync as writeFileSync13 } from "fs";
-import { join as join19 } from "path";
-
-// src/license/verify.ts
-init_store();
-import { createHmac } from "crypto";
+var init_ask = __esm({
+  "src/services/ask.ts"() {
+    "use strict";
+    init_agentic_loop();
+    init_explore_mode();
+    init_health_score();
+    init_divergence();
+    init_repl_api();
+    init_context2();
+    init_phase();
+    init_session_analysis();
+    init_smoke_protocol();
+  }
+});
 
 // src/license/trial-policy.ts
-var TRIAL_FULL_DAYS = 11;
-var TRIAL_GRACE_END_DAYS = 30;
-var TRIAL_ACTIVE_NUDGE_FROM_DAY = 8;
 function evaluateTrial(activatedAt, now2 = /* @__PURE__ */ new Date()) {
   const daysSince = Math.floor((now2.getTime() - activatedAt.getTime()) / 864e5);
   if (daysSince >= TRIAL_GRACE_END_DAYS) {
@@ -16512,38 +17305,65 @@ function formatTrialActiveMessage(daysSince) {
   const dayWord = daysLeft === 1 ? "day" : "days";
   return `trial license (${daysLeft} ${dayWord} remaining)`;
 }
+var TRIAL_FULL_DAYS, TRIAL_GRACE_END_DAYS, TRIAL_ACTIVE_NUDGE_FROM_DAY;
+var init_trial_policy = __esm({
+  "src/license/trial-policy.ts"() {
+    "use strict";
+    TRIAL_FULL_DAYS = 11;
+    TRIAL_GRACE_END_DAYS = 30;
+    TRIAL_ACTIVE_NUDGE_FROM_DAY = 8;
+  }
+});
 
 // src/license/upgrade-whimsy.ts
-var CUTOFF_NUDGES = [
-  "Okay \u2014 that's the line. /upgrade and you're back.",
-  "We're paused until you say yes. /upgrade.",
-  "Didn't want it to end like this. /upgrade if you want in again.",
-  "Time's up. /upgrade \u2014 takes a minute.",
-  "I'll be here. You just need to /upgrade first.",
-  "That's all I can do on the free side. /upgrade.",
-  "Door's closed for now. /upgrade opens it."
-];
 function pick(items) {
   return items[Math.floor(Math.random() * items.length)] ?? items[0];
 }
 function randomCutoffNudge() {
   return pick(CUTOFF_NUDGES);
 }
+var CUTOFF_NUDGES;
+var init_upgrade_whimsy = __esm({
+  "src/license/upgrade-whimsy.ts"() {
+    "use strict";
+    init_trial_policy();
+    CUTOFF_NUDGES = [
+      "Okay \u2014 that's the line. /upgrade and you're back.",
+      "We're paused until you say yes. /upgrade.",
+      "Didn't want it to end like this. /upgrade if you want in again.",
+      "Time's up. /upgrade \u2014 takes a minute.",
+      "I'll be here. You just need to /upgrade first.",
+      "That's all I can do on the free side. /upgrade.",
+      "Door's closed for now. /upgrade opens it."
+    ];
+  }
+});
 
 // src/license/normalize.ts
-var NTRP_PREFIX = /^NTRP-/i;
-var UUID_KEY = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function detectLicenseFormat(key) {
   if (NTRP_PREFIX.test(key)) return "ntrp";
   if (UUID_KEY.test(key)) return "lemonsqueezy";
   return "unknown";
 }
+var NTRP_PREFIX, UUID_KEY;
+var init_normalize = __esm({
+  "src/license/normalize.ts"() {
+    "use strict";
+    NTRP_PREFIX = /^NTRP-/i;
+    UUID_KEY = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  }
+});
 
 // src/license/lemonsqueezy.ts
 import { hostname } from "os";
+var init_lemonsqueezy = __esm({
+  "src/license/lemonsqueezy.ts"() {
+    "use strict";
+  }
+});
 
 // src/license/verify.ts
-var SIGNING_SECRET = "ntrp-gtm-health-2026";
+import { createHmac } from "crypto";
 function validateLicenseKey(key) {
   const invalid = (msg) => ({
     valid: false,
@@ -16657,8 +17477,22 @@ function checkLicense() {
   }
   return applyTrialPolicy(result);
 }
+var SIGNING_SECRET;
+var init_verify = __esm({
+  "src/license/verify.ts"() {
+    "use strict";
+    init_store();
+    init_trial_policy();
+    init_upgrade_whimsy();
+    init_normalize();
+    init_lemonsqueezy();
+    SIGNING_SECRET = "ntrp-gtm-health-2026";
+  }
+});
 
 // src/services/setup.ts
+import { existsSync as existsSync18, mkdirSync as mkdirSync10, readFileSync as readFileSync16, writeFileSync as writeFileSync13 } from "fs";
+import { join as join19 } from "path";
 function setupCheck() {
   const home = ntrpHome();
   let writable = false;
@@ -16702,18 +17536,22 @@ function setupCheck() {
     }
   };
 }
-
-// src/mcp/server.ts
-init_playbook();
-init_queries();
-init_serialize();
-init_errors2();
+var init_setup = __esm({
+  "src/services/setup.ts"() {
+    "use strict";
+    init_repl_api();
+    init_providers();
+    init_llm_config();
+    init_store();
+    init_profile();
+    init_verify();
+  }
+});
 
 // src/version.ts
 import { existsSync as existsSync19, readFileSync as readFileSync17 } from "fs";
 import { dirname as dirname3, join as join20 } from "path";
 import { fileURLToPath } from "url";
-var cachedVersion;
 function getInstalledVersion() {
   if (cachedVersion) return cachedVersion;
   const start = dirname3(fileURLToPath(import.meta.url));
@@ -16732,8 +17570,26 @@ function getInstalledVersion() {
   cachedVersion = "0.0.0";
   return cachedVersion;
 }
+var cachedVersion;
+var init_version = __esm({
+  "src/version.ts"() {
+    "use strict";
+  }
+});
 
 // src/mcp/server.ts
+init_context2();
+init_diagnosis();
+init_metrics_analysis();
+init_report();
+init_ask();
+init_setup();
+init_playbook();
+init_queries();
+init_serialize();
+init_errors2();
+init_version();
+import { createInterface as createInterface2 } from "readline";
 var tools = [
   {
     name: "ntrp_setup_check",