vibe-splain 3.4.2 → 4.0.0

package/README.md

@@ -1,26 +1,25 @@
 <p align="center">
-  <strong>◈ vibe-splain</strong>
-  <br />
-  <em>Map architectural DNA and behavioral call-chains in complex codebases.</em>
+  <strong>◈ vibesplain</strong><br/>
+  <em>Give your AI agent an architectural map of any codebase.</em>
 </p>
 
 <p align="center">
   <a href="#install">Install</a> ·
-  <a href="#how-it-works">How It Works</a> ·
+  <a href="#usage">Usage</a> ·
   <a href="#mcp-tools">MCP Tools</a> ·
-  <a href="#dossier-ui">Dossier UI</a> ·
+  <a href="#how-it-works">How It Works</a> ·
   <a href="#development">Development</a>
 </p>
 
 ---
 
-vibe-splain is a high-fidelity **static analysis engine** and MCP server. It uses [Tree-Sitter](https://tree-sitter.github.io/tree-sitter/) to extract the structural and behavioral patterns of a codebase—identifying high-gravity components, mapping semantic actions, and tracing call-chains between entrypoints and side effects.
+**vibesplain** is an MCP server that scans a codebase with Tree-Sitter, scores every file by importance and complexity, and produces an **Architectural Dossier** — a structured set of decision cards your agent writes after analyzing the code.
 
-While vibe-splain is built on a language-agnostic foundation, the current toolset is **highly optimized for TypeScript and JavaScript** (especially Next.js, Prisma, and tRPC environments).
+The output is a self-contained HTML file you can open in any browser.
 
-**Zero LLM calls. Zero API keys. Pure static analysis.**
+**Zero LLM calls. Zero API keys. Zero network. Pure static analysis.**
 
-Your coding agent does all the thinking — vibe-splain just gives it the right data.
+---
 
 ## Install
 
@@ -28,215 +27,168 @@ Your coding agent does all the thinking — vibe-splain just gives it the right
 npx vibe-splain install
 ```
 
-That's it. This patches your coding agent's MCP config so it can call vibe-splain's tools. Restart your agent.
-
-### Running the Analysis
-
-You don't need to write a complex prompt. vibe-splain provides a built-in MCP Prompt called `build_dossier` that automatically tells your agent exactly what to do.
-
-**In Claude Code / Gemini CLI:**
-Type `/prompt build_dossier` and press enter.
+This patches your coding agent's config to register vibesplain as an MCP server. Restart your agent afterward.
 
-**In Cursor / Windsurf:**
-Open the MCP panel or agent chat, select the `build_dossier` prompt from the vibe-splain server, and run it.
-
-Your agent will loop through the high-gravity files, analyze each one, and build an **Architectural Dossier** — a structured set of **Decision Cards** explaining the technical rationale of the code.
-
-### Supported Agents
-
-| Agent | Config File |
-|-------|------------|
-| Claude Code | `~/.claude/claude_desktop_config.json` |
+| Agent | Config patched |
+|-------|---------------|
+| Claude Code | `~/.claude/settings.json` |
+| Claude Desktop | `~/.claude/claude_desktop_config.json` |
 | Gemini CLI | `~/.gemini/settings.json` |
 | Cursor | `~/.cursor/mcp.json` |
 | Windsurf | `~/.codeium/windsurf/mcp_config.json` |
 
-## How It Works
+---
+
+## Usage
 
+Once installed, open a project in your agent and run the built-in prompt:
+
+**Claude Code / Gemini CLI:**
 ```
-┌─────────────────────────────────────────────────────────┐
-│  Your Coding Agent (Claude / Gemini / Cursor)           │
-│                                                         │
-│  "Scan this project" ──► scan_project ──► get_file_ctx  │
-│                             │                  │        │
-│  Agent synthesizes  ◄──────┘   ◄──────────────┘        │
-│  narratives + diagrams                                  │
-│       │                                                 │
-│       ▼                                                 │
-│  write_decision_card ──► .vibe-splainer/dossier.json    │
-│                               │                         │
-│                               ▼                         │
-│                    file:// Dossier UI                    │
-└─────────────────────────────────────────────────────────┘
+/prompt build_dossier
 ```
 
-### Three Levels of Analysis
-1. **Level 0 — Semantic Classification**: Maps files to architectural "pillars" (Auth, Payments, Database, etc.) using import-path heuristics and library signatures.
-2. **Level 1 — Structural and Behavioral Gravity**: Core computes `staticGravity` using Tree-Sitter AST analysis based on link density, nesting depth, and mutation counts. **Bundled Adapters** (like Cal.com and n8n) interpret product semantics to add `behavioralLift` for critical dynamic execution paths. Final `gravity` is the combination of static evidence and adapter interpretation.
-3. **Level 2 — Behavioral Traceability**: Tree-Sitter powered call-graph analysis. It maps function-level dependencies and identifies **Critical Functions** (entrypoints, semantic actions, or high-outbound callers).
+**Cursor / Windsurf:** Select the `build_dossier` prompt from the vibesplain MCP panel.
 
-### Claude Code PreToolUse Hook
+Your agent will:
+1. Scan the project and rank files by architectural importance
+2. Read each high-importance file in depth
+3. Write a **Decision Card** for each — thesis, blast radius, evidence, optional diagram
+4. Return a `file://` link to the Dossier UI
 
-`vibe-splain` integrates directly with Claude Code's hook system to prevent AI agents from accidentally breaking your codebase:
+Open the link. Done.
 
-- **Ultra-Fast Local Gating**: Installs a standalone entrypoint (`dist/hook.js`) that runs in **< 15ms** with zero network calls, avoiding heavy WASM/tree-sitter load overhead.
-- **Hybrid Blast-Radius Logic**: Combines static gravity and substance-based direct dependents to protect important files (e.g. dynamically-loaded execution nodes or central utility modules) even if they lack standard entrypoints.
-- **Developer Friction Suppression**: Automatically demotes generated, minified, or vendored files to a `low` blast-radius, ensuring the agent is never blocked when editing build targets or lockfiles.
-- **Warn-Once session behavior**: If `.vibe-splainer/gate.json` is missing, the hook notifies you exactly once per session to run a project scan, then gracefully gets out of the way.
+---
 
 ## MCP Tools
 
-vibe-splain exposes **8 tools** over MCP stdio:
+The `build_dossier` prompt orchestrates these tools automatically. You can also call them manually.
+
+| Tool | What it does |
+|------|-------------|
+| `scan_project` | Scans the repo. Returns ranked files grouped by architectural pillar. Call this first. |
+| `get_project_map` | Returns the pillar map, top-gravity files, and wild-discovery candidates. |
+| `set_project_brief` | Stores a 3–5 sentence project summary. Write this before any decision cards. |
+| `get_file_context` | Returns full source + import graph + hot spans for a specific file. |
+| `write_decision_card` | Persists a decision card (thesis, category, evidence, optional Mermaid diagram). |
+| `get_strategic_overview` | Returns dossier state without evidence snippets — useful for quick status checks. |
+| `inspect_pillar` | Returns all decision cards for a given architectural pillar. |
+| `get_wild_discoveries` | Returns the highest-complexity files that don't fit standard patterns. |
+| `mark_stale` | Marks a file's decision card as stale after you edit it. |
 
-| Tool | Purpose |
-|------|---------|
-| `scan_project` | **Call first.** Scans the codebase, returns high-gravity files grouped by pillar. Starts file watcher. |
-| `get_file_context` | Returns full source + import graph neighbors for a specific file. |
-| `write_decision_card` | Persists a Decision Card (narrative + evidence + optional Mermaid diagram). |
-| `get_strategic_overview` | Returns dossier state without evidence snippets (saves tokens). |
-| `inspect_pillar` | Returns all Decision Cards for a pillar with full evidence. |
-| `get_wild_discoveries` | Returns the most complex files that don't fit standard patterns. |
-| `mark_stale` | Marks cards as stale when you modify files during a session. |
+---
+
+## How It Works
 
-### Recommended Agent Workflow
+vibesplain runs a deterministic static analysis pipeline — no model calls, no network:
 
 ```
-1. scan_project → get high-gravity files
-2. For each file: get_file_context → read source + neighbors
-3. Synthesize: "WHY does this code exist?"
-5. write_decision_card → persist the narrative
-6. Share the file:// UI link with the user
+Your project
+    │
+    ▼
+Tree-Sitter AST parsing
+    │
+    ├── Gravity score (0–100)
+    │     PageRank centrality × fan-in × cyclomatic complexity
+    │     × public surface × nesting depth
+    │
+    ├── Heat score (0–100)
+    │     Smell density: swallowed catches, deep nesting,
+    │     long functions, god files, magic numbers
+    │
+    └── Pillar detection
+          Auth / Database / Payments / Queue /
+          Storage / Config / Email / Realtime / Logic
+              │
+              ▼
+        .vibesplain/
+        ├── dossier.json      ← agent writes decision cards here
+        ├── analysis.json     ← raw scored file store
+        ├── graph.json        ← import graph
+        └── ui/index.html     ← self-contained dossier viewer
 ```
 
-## How It Works
+**Top 12 by gravity** = Start Here (the load-bearing hubs).  
+**Top 12 by heat** = Wild Discoveries (the most complex / smelly files).
 
-### Deep Analysis Pipeline
-Unlike simple regex scanners, vibe-splain runs a deterministic **13-stage pipeline**—from AST inventory and alias resolution to semantic classification and function-level scoring—to ensure every Decision Card is grounded in actual code paths.
+The UI is a single self-contained HTML file. Open it with `file://` — no server needed.
 
-### Semantic Rulesets
-vibe-splain uses specialized rulesets to understand framework-specific semantics. Current optimizations include:
-- **Next.js**: Server Actions, `cookies()`, `headers()`, and App Router conventions.
-- **Database**: Prisma model mutations and raw query patterns.
-- **API**: tRPC procedure calls (`mutate`/`query`) and standard `fetch`/`axios` patterns.
-- **Auth**: Clerk, NextAuth, and custom rate-limiting/validation logic.
+---
 
 ## Dossier UI
 
-After your agent writes Decision Cards, open the generated file in your browser:
+After your agent writes decision cards, open the generated file:
 
 ```
-file:///path/to/your/project/.vibe-splainer/ui/index.html
+file:///path/to/your/project/.vibesplain/ui/index.html
 ```
 
-The UI features:
-- **Dark theme** with glassmorphism and subtle grid texture
-- **Pillar tabs** for navigating architectural areas
-- **Decision Cards** with fresh/stale status badges
-- **Mermaid diagrams** rendered inline as SVG
-- **Evidence sidebar** with Shiki syntax highlighting (tokyo-night)
-- **Wild Discoveries** tab for the most complex outlier files
-- Works entirely offline via `file://` — no server needed
+Features:
+- Pillar tabs to navigate architectural areas
+- Decision cards with fresh/stale status
+- Mermaid diagrams rendered inline
+- Syntax-highlighted evidence snippets
+- Works fully offline from `file://`
+
+---
 
 ## Architecture
 
 ```
 packages/
-├── brain/           # @vibe-splain/brain — repo-agnostic analysis core + bundled adapters
+├── brain/    # @vibesplain/brain — pure static analysis, no I/O side effects
 │   └── src/
-│       ├── pipeline/
-│       │   └── adapters/ # Bundled product adapters (Cal.com, n8n)
-│       ├── scanner.ts    # Tree-Sitter AST analysis (static analysis, graph building)
-│       ├── dossier.ts    # Atomic persistence + UI regeneration
-│       ├── graph.ts      # Import graph read/write
-│       └── watcher.ts    # Chokidar file watcher
-├── cli/             # vibe-splain — MCP server + CLI
+│       ├── pipeline/         # 13-stage analysis pipeline
+│       │   └── adapters/     # Optional domain-adapter extension point (none bundled)
+│       ├── scanner.ts        # Tree-Sitter AST + gravity/heat scoring
+│       ├── dossier.ts        # Atomic dossier persistence + UI injection
+│       ├── analysis.ts       # Scored file store + validation report
+│       └── graph.ts          # Import graph read/write
+│
+├── cli/      # vibesplain — MCP server + CLI (the published npm package)
 │   └── src/
-│       ├── index.ts          # #!/usr/bin/env node entry
+│       ├── index.ts          # CLI entrypoint
 │       ├── commands/
-│       │   ├── install.ts    # Agent config patcher
-│       │   └── serve.ts      # MCP server launcher
+│       │   ├── install.ts    # Patches agent MCP configs
+│       │   └── serve.ts      # Starts the MCP server
+│       ├── export/           # Artifact writing (HTML, Markdown, JSON)
 │       └── mcp/
-│           ├── server.ts     # @modelcontextprotocol/sdk setup
-│           └── tools/        # 7 tool handlers
-└── ui/              # @vibe-splain/ui — React dossier viewer
-    └── src/
-        ├── App.tsx               # Main app (reads window.__VIBE_DOSSIER__)
-        ├── components/           # Header, PillarTabs, DecisionCard, etc.
-        └── index.css             # Design system
+│           ├── server.ts     # MCP tool registration
+│           └── tools/        # One file per tool
+│
+└── ui/       # @vibesplain/ui — React dossier viewer (embedded into cli at build time)
 ```
 
-### Key Design Decisions
+**Build order:** `brain` → `cli` → `ui` → `bundle-ui` (copies `ui/dist/` into `cli/dist/ui/`).  
+Only the `cli` package is published to npm.
 
-- **No LLM calls**: vibe-splain is a pure static analysis tool. The coding agent provides all synthesis.
-- **`async-mutex`**: All dossier writes are guarded by a mutex with atomic tmp+rename.
-- **`startOnLoad: false`**: Mermaid is initialized manually — never auto-scans the DOM.
-- **`base: './'`**: Vite builds with relative paths so the UI works from `file://` URLs.
-- **`console.log` banned**: Brain and CLI use only `console.error` to avoid corrupting MCP stdio.
-- **Tree-Sitter WASM**: Loaded from the `tree-sitter-wasms` npm package — no network calls.
+---
 
 ## Development
 
-### Prerequisites
-
-- Node.js ≥ 18
-- npm ≥ 9 (for workspaces)
-
-### Setup
-
 ```bash
-git clone https://github.com/abp2204/vibe-splain.git
-cd vibe-splain
+git clone https://github.com/abp2204/vibesplain.git
+cd vibesplain
 npm install
+npm run build          # full build
+npm run dev:ui         # Vite dev server for the UI
+npm run test:regression
 ```
 
-### Build
-
-```bash
-npm run build
-```
-
-This runs in sequence: brain → cli → ui → bundle-ui (copies UI dist into CLI dist).
-
-### Dev UI
-
-```bash
-npm run dev:ui
-```
-
-Starts the Vite dev server for the UI package at `http://localhost:5173`.
-
-### Test Install Locally
+Test locally after build:
 
 ```bash
 node packages/cli/dist/index.js install
-```
-
-### Test MCP Server
-
-```bash
 node packages/cli/dist/index.js serve
 ```
 
-Then send JSON-RPC messages over stdin (see [MCP specification](https://modelcontextprotocol.io)).
-
-### Publish
+Publish:
 
 ```bash
 npm run release
 ```
 
-Builds everything and publishes the `vibe-splain` CLI package to npm.
-
-## How the Dossier Stays Fresh
-
-When `scan_project` runs, it starts a [Chokidar](https://github.com/paulmillr/chokidar) file watcher. When source files change:
-
-1. The watcher detects the change
-2. Matching Decision Cards are marked **stale** (amber badge in UI)
-3. The `stalePaths` array in the dossier tracks which files need re-analysis
-4. Your agent can call `get_strategic_overview` to see what's stale, then re-scan
-
-You can also manually mark files stale with `mark_stale` if you modify code during a session.
+---
 
 ## License
 

package/dist/commands/install.d.ts

@@ -1,6 +1 @@
-/**
- * Idempotently register the vibe-splain PreToolUse hook in a Claude Code settings object.
- * Pure: takes a config, returns the same object mutated. Safe to run repeatedly.
- */
-export declare function addPreToolUseHook(config: Record<string, any>, hookPath?: string): Record<string, any>;
 export declare function installCommand(): Promise<void>;

package/dist/commands/install.js

@@ -1,8 +1,7 @@
 import { readFile, writeFile } from 'fs/promises';
 import { existsSync } from 'fs';
-import { join, dirname } from 'path';
+import { join } from 'path';
 import { homedir } from 'os';
-import { fileURLToPath } from 'url';
 function expandPath(p) {
     if (p.startsWith('~')) {
         return join(homedir(), p.slice(1));
@@ -25,48 +24,8 @@ const MCP_ENTRY = {
     command: 'npx',
     args: ['-y', 'vibe-splain', 'serve'],
 };
-// Claude Code PreToolUse hook: deterministically gate edits to high-blast-radius
-// files. Hooks are a Claude Code CLI feature (settings.json) — not Desktop/Cursor.
-const HOOK_MATCHER = 'Edit|Write|MultiEdit';
-const DEFAULT_HOOK_COMMAND = 'npx -y vibe-splain hook pretooluse';
-/**
- * Idempotently register the vibe-splain PreToolUse hook in a Claude Code settings object.
- * Pure: takes a config, returns the same object mutated. Safe to run repeatedly.
- */
-export function addPreToolUseHook(config, hookPath) {
-    if (!config.hooks)
-        config.hooks = {};
-    if (!Array.isArray(config.hooks.PreToolUse))
-        config.hooks.PreToolUse = [];
-    const hookCommand = hookPath ? `node "${hookPath}"` : DEFAULT_HOOK_COMMAND;
-    const already = config.hooks.PreToolUse.some((entry) => Array.isArray(entry?.hooks) &&
-        entry.hooks.some((h) => typeof h?.command === 'string' && (h.command.includes('vibe-splain hook pretooluse') || h.command.includes('hook.js'))));
-    if (already) {
-        // Update existing hook command to the resolved hook.js path
-        config.hooks.PreToolUse = config.hooks.PreToolUse.map((entry) => {
-            if (Array.isArray(entry?.hooks)) {
-                return {
-                    ...entry,
-                    hooks: entry.hooks.map((h) => {
-                        if (typeof h?.command === 'string' && (h.command.includes('vibe-splain hook pretooluse') || h.command.includes('hook.js'))) {
-                            return { ...h, command: hookCommand };
-                        }
-                        return h;
-                    })
-                };
-            }
-            return entry;
-        });
-        return config;
-    }
-    config.hooks.PreToolUse.push({
-        matcher: HOOK_MATCHER,
-        hooks: [{ type: 'command', command: hookCommand }],
-    });
-    return config;
-}
 export async function installCommand() {
-    console.error('\n🔧 vibe-splain Installer\n');
+    console.error('\n🔧 vibesplain Installer\n');
     let patchedCount = 0;
     for (const agent of AGENT_CONFIGS) {
         const resolvedPath = expandPath(agent.path);
@@ -84,20 +43,11 @@ export async function installCommand() {
                 console.error(`    ⚠ Could not parse JSON, skipping`);
                 continue;
             }
-            // Patch config (idempotent: only write when something actually changes,
-            // so existing users still pick up newly-added pieces like the hook).
             const before = JSON.stringify(config);
             if (!config.mcpServers)
                 config.mcpServers = {};
-            if (!config.mcpServers['vibe-splain'])
-                config.mcpServers['vibe-splain'] = MCP_ENTRY;
-            // The PreToolUse gate is a Claude Code CLI feature (settings.json hooks).
-            // Only register it there; Desktop/Gemini/Cursor don't run these hooks.
-            if (agent.name === 'Claude Code CLI') {
-                const __dirname = dirname(fileURLToPath(import.meta.url));
-                const hookPath = join(__dirname, '..', 'hook.js');
-                addPreToolUseHook(config, hookPath);
-            }
+            if (!config.mcpServers['vibesplain'])
+                config.mcpServers['vibesplain'] = MCP_ENTRY;
             if (JSON.stringify(config) === before) {
                 console.error(`    ✓ Already configured, skipping`);
                 patchedCount++;
@@ -116,7 +66,7 @@ export async function installCommand() {
         console.error(`Add this manually to your agent's MCP config:\n`);
         console.error(JSON.stringify({
             mcpServers: {
-                'vibe-splain': MCP_ENTRY
+                'vibesplain': MCP_ENTRY
             }
         }, null, 2));
         process.exit(1);

package/dist/commands/serve.js

@@ -1,6 +1,6 @@
 import { startMCPServer } from '../mcp/server.js';
 export async function serveCommand(options) {
-    console.error('[vibe-splain] Starting MCP server...');
+    console.error('[vibesplain] Starting MCP server...');
     await startMCPServer(options);
     // Process stays alive — do NOT call process.exit() here
 }

package/dist/export/ArtifactBundleWriter.js

@@ -7,9 +7,9 @@ export class ArtifactBundleWriter {
         this.projectRoot = projectRoot;
     }
     async writeBundle(artifacts) {
-        const outputDir = join(this.projectRoot, '.vibe-splainer');
-        const stagingDir = join(this.projectRoot, '.vibe-splainer.tmp');
-        const oldDir = join(this.projectRoot, '.vibe-splainer.old');
+        const outputDir = join(this.projectRoot, '.vibesplain');
+        const stagingDir = join(this.projectRoot, '.vibesplain.tmp');
+        const oldDir = join(this.projectRoot, '.vibesplain.old');
         try {
             await rm(stagingDir, { recursive: true, force: true });
             await rm(oldDir, { recursive: true, force: true });

package/dist/export/ExportOrchestrator.d.ts

@@ -1,30 +1,12 @@
-import type { Dossier, AnalysisStore, ImportGraph } from '@vibe-splain/brain';
+import type { Dossier, AnalysisStore, ImportGraph } from '@vibesplain/brain';
 export interface ExportOptions {
     format?: 'json' | 'html' | 'markdown' | 'delta';
     budget?: number;
     scope?: string;
 }
-export interface ManifestArtifactEntry {
-    name: string;
-    pointer: string;
-    contentHash: string;
-    sizeBytes: number;
-    indexes?: Record<string, string>;
-    hydrators?: string[];
-}
-export interface ScanManifest {
-    schemaVersion: '2.0.0';
-    scanId: string;
-    generatedAt: string;
-    projectRoot: string;
-    artifacts: ManifestArtifactEntry[];
-}
 export declare class ExportOrchestrator {
     private projectRoot;
     constructor(projectRoot: string);
-    writeBundle(dossier: Dossier, options?: ExportOptions, store?: AnalysisStore, graph?: ImportGraph, scanId?: string): Promise<{
-        scanId: string;
-        manifestPointer: string;
-    }>;
+    writeBundle(dossier: Dossier, options?: ExportOptions, store?: AnalysisStore, graph?: ImportGraph): Promise<void>;
     private buildViewModel;
 }

package/dist/export/ExportOrchestrator.js

@@ -1,4 +1,4 @@
-import { readAnalysis, RecommendationEngine, buildGateIndex } from '@vibe-splain/brain';
+import { readAnalysis } from '@vibesplain/brain';
 import { ArtifactBundleWriter } from './ArtifactBundleWriter.js';
 import { JsonRenderer } from './renderers/JsonRenderer.js';
 import { HtmlRenderer } from './renderers/HtmlRenderer.js';
@@ -6,15 +6,12 @@ import { AgentMarkdownRenderer } from './renderers/AgentMarkdownRenderer.js';
 import { ValidationRenderer } from './renderers/ValidationRenderer.js';
 import { RawAnalysisRenderer } from './renderers/RawAnalysisRenderer.js';
 import { GraphRenderer } from './renderers/GraphRenderer.js';
-import { BlobStore } from '../store/BlobStore.js';
-import { PointerStore } from '../store/PointerStore.js';
-import { v4 as uuidv4 } from 'uuid';
 export class ExportOrchestrator {
     projectRoot;
     constructor(projectRoot) {
         this.projectRoot = projectRoot;
     }
-    async writeBundle(dossier, options = {}, store, graph, scanId) {
+    async writeBundle(dossier, options = {}, store, graph) {
         const finalStore = store || await readAnalysis(this.projectRoot);
         if (!finalStore) {
             throw new Error('Analysis store not found. Scan the project first.');
@@ -32,14 +29,7 @@ export class ExportOrchestrator {
         if (graph) {
             artifacts.push(...await new GraphRenderer(graph).render(viewModel, finalStore));
         }
-        const gateIndex = buildGateIndex(finalStore);
-        artifacts.push({
-            type: 'gate',
-            path: 'gate.json',
-            content: JSON.stringify(gateIndex, null, 2),
-        });
-        // Determine additional formats
-        const formats = ['html', 'markdown']; // default
+        const formats = ['html', 'markdown'];
         if (options.format && options.format !== 'json' && options.format !== 'delta') {
             formats.length = 0;
             formats.push(options.format);
@@ -52,110 +42,9 @@ export class ExportOrchestrator {
         }
         const writer = new ArtifactBundleWriter(this.projectRoot);
         await writer.writeBundle(artifacts);
-        // Register artifacts in BlobStore + PointerStore and build manifest
-        const effectiveScanId = scanId ?? `scan_${Date.now()}`;
-        const blobStore = new BlobStore(this.projectRoot);
-        const pointerStore = PointerStore.open(this.projectRoot);
-        const now = Date.now();
-        const manifestEntries = [];
-        for (const artifact of artifacts) {
-            const content = typeof artifact.content === 'string'
-                ? Buffer.from(artifact.content, 'utf8')
-                : artifact.content;
-            const { contentHash, blobPath } = await blobStore.writeAtomic(content);
-            const pointerId = `ptr_${uuidv4().replace(/-/g, '').slice(0, 16)}`;
-            await pointerStore.insertPointer({
-                pointerId,
-                scanId: effectiveScanId,
-                artifactName: artifact.type,
-                contentHash,
-                blobPath,
-                schemaVersion: '1.0.0',
-                createdAt: now,
-                expiresAt: null,
-            });
-            const entry = {
-                name: artifact.type,
-                pointer: pointerId,
-                contentHash,
-                sizeBytes: content.length,
-            };
-            // Attach hydrator hints for the large analysis artifact
-            if (artifact.type === 'analysis') {
-                entry.hydrators = ['get_project_summary', 'get_start_here'];
-                // Generate analysis.index.json (Start-Here + Top-Heat)
-                const analysisIndex = {
-                    schemaVersion: '1.0.0',
-                    scanId: effectiveScanId,
-                    startHere: dossier.map.topGravity.slice(0, 12),
-                    topHeat: dossier.map.topHeat.slice(0, 12),
-                    pillarSummary: dossier.map.pillars.map(p => ({
-                        name: p.name,
-                        fileCount: p.memberFiles?.length ?? 0,
-                    })),
-                    totalFiles: Object.keys(finalStore.files).length,
-                    realSourceFiles: Object.values(finalStore.files).filter(f => f.isRealSource).length,
-                };
-                const indexContent = Buffer.from(JSON.stringify(analysisIndex, null, 2), 'utf8');
-                const indexWrite = await blobStore.writeAtomic(indexContent);
-                const indexPointerId = `ptr_${uuidv4().replace(/-/g, '').slice(0, 16)}`;
-                await pointerStore.insertPointer({
-                    pointerId: indexPointerId,
-                    scanId: effectiveScanId,
-                    artifactName: 'analysis.index',
-                    contentHash: indexWrite.contentHash,
-                    blobPath: indexWrite.blobPath,
-                    schemaVersion: '1.0.0',
-                    createdAt: now,
-                    expiresAt: null,
-                });
-                entry.indexes = { startHere: indexPointerId };
-            }
-            manifestEntries.push(entry);
-        }
-        // Write and register the scan manifest itself
-        const manifest = {
-            schemaVersion: '2.0.0',
-            scanId: effectiveScanId,
-            generatedAt: new Date(now).toISOString(),
-            projectRoot: this.projectRoot,
-            artifacts: manifestEntries,
-        };
-        const manifestContent = Buffer.from(JSON.stringify(manifest, null, 2), 'utf8');
-        const manifestWrite = await blobStore.writeAtomic(manifestContent);
-        const manifestPointerId = `ptr_manifest_${effectiveScanId}`;
-        await pointerStore.insertPointer({
-            pointerId: manifestPointerId,
-            scanId: effectiveScanId,
-            artifactName: 'artifact_manifest',
-            contentHash: manifestWrite.contentHash,
-            blobPath: manifestWrite.blobPath,
-            schemaVersion: '2.0.0',
-            createdAt: now,
-            expiresAt: null,
-        });
-        return { scanId: effectiveScanId, manifestPointer: manifestPointerId };
     }
-    buildViewModel(dossier, store) {
-        const recommendations = {};
-        for (const file of dossier.map.topGravity) {
-            const persisted = store.files[file];
-            if (persisted) {
-                recommendations[file] = RecommendationEngine.generateRecommendations(persisted);
-            }
-        }
-        for (const file of dossier.map.topHeat) {
-            if (!recommendations[file]) {
-                const persisted = store.files[file];
-                if (persisted) {
-                    recommendations[file] = RecommendationEngine.generateRecommendations(persisted);
-                }
-            }
-        }
-        return {
-            ...dossier,
-            recommendations,
-        };
+    buildViewModel(dossier, _store) {
+        return { ...dossier, recommendations: {} };
     }
 }
 //# sourceMappingURL=ExportOrchestrator.js.map