vibe-splain 3.4.2 → 4.0.0

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "vibe-splain",
-  "version": "3.4.2",
-  "description": "Architectural mapping and behavioral call-chain engine. Built on a language-agnostic foundation with specialized optimization for TypeScript/JavaScript projects.",
+  "version": "4.0.0",
+  "description": "Static-analysis dossier engine for codebases: Tree-Sitter powered architectural analysis and interactive UI. Language-agnostic core, optimized for TypeScript/JavaScript.",
   "type": "module",
   "license": "MIT",
   "author": "abp2204",
-  "homepage": "https://github.com/abp2204/vibe-splain#readme",
+  "homepage": "https://github.com/abp2204/vibesplain#readme",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/abp2204/vibe-splain.git",
+    "url": "git+https://github.com/abp2204/vibesplain.git",
     "directory": "packages/cli"
   },
   "bugs": {
-    "url": "https://github.com/abp2204/vibe-splain/issues"
+    "url": "https://github.com/abp2204/vibesplain/issues"
   },
   "keywords": [
     "mcp",
@@ -30,33 +30,28 @@
     "node": ">=18"
   },
   "bin": {
-    "vibe-splain": "dist/index.js"
+    "vibesplain": "dist/index.js"
   },
   "scripts": {
     "build": "tsc && node build.mjs"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "better-sqlite3": "^12.10.0",
     "chokidar": "^3.6.0",
     "commander": "^12.0.0",
     "fs-extra": "^11.0.0",
     "tar": "^7.5.16",
     "tree-sitter-wasms": "^0.1.11",
-    "web-tree-sitter": "^0.22.0"
+    "web-tree-sitter": "^0.22.0",
+    "uuid": "^9.0.0"
   },
   "devDependencies": {
-    "@types/better-sqlite3": "^7.6.13",
     "@types/fs-extra": "^11.0.0",
-    "@types/minimatch": "^5.1.2",
     "@types/tar": "^6.1.13",
     "@types/uuid": "^9.0.0",
-    "async-mutex": "^0.5.0",
     "esbuild": "^0.28.0",
-    "minimatch": "^10.2.5",
     "tsx": "^4.22.4",
-    "typescript": "^5.4.0",
-    "uuid": "^9.0.0"
+    "typescript": "^5.4.0"
   },
   "files": [
     "dist/",

package/dist/commands/bundle.d.ts

@@ -1,4 +0,0 @@
-export declare function bundleCommand(scanId: string, opts?: {
-    output?: string;
-    projectRoot?: string;
-}): Promise<void>;

package/dist/commands/bundle.js

@@ -1,68 +0,0 @@
-import { join } from 'path';
-import { writeFile, mkdir, copyFile, rm } from 'fs/promises';
-import { existsSync } from 'fs';
-import * as tar from 'tar';
-import { PointerStore } from '../store/PointerStore.js';
-import { BlobStore } from '../store/BlobStore.js';
-export async function bundleCommand(scanId, opts = {}) {
-    const root = opts.projectRoot ?? process.cwd();
-    const outputPath = opts.output ?? join(root, `vibe-bundle-${scanId}.tar.gz`);
-    console.error(`[vibe-splain bundle] Bundling scan ${scanId} from ${root}`);
-    const pointerStore = PointerStore.open(root);
-    const blobStore = new BlobStore(root);
-    const pointers = pointerStore.listPointersByScan(scanId);
-    if (pointers.length === 0) {
-        throw new Error(`No pointers found for scanId "${scanId}"`);
-    }
-    // Stage bundle into a temp directory with predictable layout
-    const stagingDir = join(root, '.vibe-splainer', 'tmp', `bundle-stage-${scanId}`);
-    const blobsStageDir = join(stagingDir, 'blobs');
-    await mkdir(blobsStageDir, { recursive: true });
-    try {
-        // Build manifest for the bundle
-        const bundleManifest = {
-            schemaVersion: '1.0.0',
-            scanId,
-            exportedAt: new Date().toISOString(),
-            projectRoot: root,
-            pointers: pointers.map(p => ({
-                pointerId: p.pointerId,
-                scanId: p.scanId,
-                artifactName: p.artifactName,
-                contentHash: p.contentHash,
-                blobFile: `blobs/${p.contentHash.replace('sha256:', 'sha256_')}`,
-                schemaVersion: p.schemaVersion,
-                createdAt: p.createdAt,
-                expiresAt: p.expiresAt,
-            })),
-        };
-        await writeFile(join(stagingDir, 'bundle-manifest.json'), JSON.stringify(bundleManifest, null, 2), 'utf8');
-        // Copy blobs (deduplicated by contentHash)
-        const seen = new Set();
-        for (const p of pointers) {
-            const hex = p.contentHash.replace('sha256:', '');
-            if (seen.has(hex))
-                continue;
-            seen.add(hex);
-            const srcPath = p.blobPath;
-            if (!existsSync(srcPath)) {
-                console.error(`[vibe-splain bundle] Warning: blob missing for ${p.pointerId}: ${srcPath}`);
-                continue;
-            }
-            await copyFile(srcPath, join(blobsStageDir, `sha256_${hex}`));
-        }
-        // Create tarball from staging directory
-        await tar.create({
-            gzip: true,
-            file: outputPath,
-            cwd: stagingDir,
-            portable: true,
-        }, ['.']);
-        console.error(`[vibe-splain bundle] Bundle written: ${outputPath}`);
-        console.error(`[vibe-splain bundle] ${pointers.length} pointers, ${seen.size} blobs`);
-    }
-    finally {
-        await rm(stagingDir, { recursive: true, force: true });
-    }
-}
-//# sourceMappingURL=bundle.js.map

package/dist/commands/export.d.ts

@@ -1 +0,0 @@
-export declare function exportCommand(projectRoot: string, options: any): Promise<void>;

package/dist/commands/export.js

@@ -1,19 +0,0 @@
-import { readDossier } from '@vibe-splain/brain';
-import { ExportOrchestrator } from '../export/ExportOrchestrator.js';
-export async function exportCommand(projectRoot, options) {
-    const root = projectRoot || process.cwd();
-    console.error(`[vibe-splain] Exporting dossier for ${root}`);
-    const dossier = await readDossier(root);
-    if (!dossier) {
-        console.error('[vibe-splain] Dossier not found. Run scan first.');
-        process.exit(1);
-    }
-    const orchestrator = new ExportOrchestrator(root);
-    await orchestrator.writeBundle(dossier, {
-        format: options.format,
-        budget: options.budget ? parseInt(options.budget, 10) : undefined,
-        scope: options.scope,
-    });
-    console.error('[vibe-splain] Export complete.');
-}
-//# sourceMappingURL=export.js.map

package/dist/commands/gc.d.ts

@@ -1,3 +0,0 @@
-export declare function gcCommand(projectRoot?: string, opts?: {
-    keepScans?: number;
-}): Promise<void>;

package/dist/commands/gc.js

@@ -1,59 +0,0 @@
-import { join } from 'path';
-import { rm, readdir } from 'fs/promises';
-import { PointerStore } from '../store/PointerStore.js';
-import { BlobStore } from '../store/BlobStore.js';
-const DEFAULT_KEEP_SCANS = 3;
-export async function gcCommand(projectRoot, opts = {}) {
-    const root = projectRoot ?? process.cwd();
-    const keepScans = opts.keepScans ?? DEFAULT_KEEP_SCANS;
-    console.error(`[vibe-splain gc] Running GC on ${root} (keeping last ${keepScans} scans)`);
-    const pointerStore = PointerStore.open(root);
-    const blobStore = new BlobStore(root);
-    // 1. Get all scan IDs ordered by createdAt desc
-    const allScanIds = pointerStore.listAllScanIds();
-    console.error(`[vibe-splain gc] Found ${allScanIds.length} scans`);
-    // Keep the N most recent by taking last N from sorted list
-    // Scan IDs contain timestamps, sort lexicographically descending
-    const sorted = [...allScanIds].sort().reverse();
-    const keepIds = sorted.slice(0, keepScans);
-    const deleteIds = sorted.slice(keepScans);
-    if (deleteIds.length === 0) {
-        console.error('[vibe-splain gc] Nothing to collect');
-        return;
-    }
-    // 2. Collect all blob paths still referenced by kept pointers before deletion
-    const keptPointers = keepIds.flatMap(id => pointerStore.listPointersByScan(id));
-    const referencedBlobs = new Set(keptPointers.map(p => p.blobPath));
-    // 3. Delete old scan pointers
-    const deleted = await pointerStore.gcScanPointers(keepIds);
-    console.error(`[vibe-splain gc] Deleted ${deleted} pointer rows`);
-    // 4. Delete unreferenced blobs (reference count = 0)
-    const allBlobs = await blobStore.listBlobPaths();
-    let blobsDeleted = 0;
-    for (const blobPath of allBlobs) {
-        if (!referencedBlobs.has(blobPath)) {
-            try {
-                await rm(blobPath);
-                blobsDeleted++;
-            }
-            catch {
-                // ignore — may have already been deleted
-            }
-        }
-    }
-    console.error(`[vibe-splain gc] Deleted ${blobsDeleted} unreferenced blobs`);
-    // 5. Clean up tmp dir
-    const tmpDir = join(root, '.vibe-splainer', 'tmp');
-    try {
-        const tmpFiles = await readdir(tmpDir);
-        for (const f of tmpFiles) {
-            await rm(join(tmpDir, f), { force: true });
-        }
-        console.error(`[vibe-splain gc] Cleaned ${tmpFiles.length} tmp files`);
-    }
-    catch {
-        // tmp dir may not exist
-    }
-    console.error('[vibe-splain gc] Done');
-}
-//# sourceMappingURL=gc.js.map

package/dist/commands/hook.d.ts

@@ -1,9 +0,0 @@
-export interface HookCommandResult {
-    /** JSON to print to stdout, or null to print nothing (defer / exit 0). */
-    stdout: string | null;
-}
-export declare function findProjectRoot(start: string | undefined): string | null;
-/** Pure-ish core: raw stdin string in, hook decision (as a string or null) out. */
-export declare function runHookCommand(rawStdin: string): Promise<HookCommandResult>;
-/** CLI entrypoint: read all of stdin, run the gate, emit the result. */
-export declare function hookPreToolUseCommand(): Promise<void>;

package/dist/commands/hook.js

@@ -1,84 +0,0 @@
-// `vibe-splain hook pretooluse` — the deterministic PreToolUse gate, wired to stdio.
-//
-// Claude Code pipes a JSON describing the tool call about to run onto stdin; we
-// decide whether to escalate and, if so, write hook JSON to stdout. On a safe
-// edit (or any non-edit tool, unscanned repo, etc.) we print nothing and exit 0,
-// deferring to normal permission flow.
-//
-// NOTE on the console.log ban: that rule protects the MCP *server's* stdout.
-// This is a separate, short-lived process whose stdout IS the hook protocol —
-// writing JSON here is correct. Diagnostics still go to stderr.
-import { existsSync, writeFileSync, readFileSync } from 'fs';
-import { dirname, join } from 'path';
-import { tmpdir } from 'os';
-import { decidePreToolUse } from '../hook/preToolUse.js';
-// Walk up from `start` looking for the directory that holds a `.vibe-splainer` scan.
-// Returns null if none is found — an unscanned repo means the gate is inert.
-export function findProjectRoot(start) {
-    let dir = start || process.cwd();
-    // Bound the walk so a stray cwd can't traverse the whole filesystem.
-    for (let i = 0; i < 64; i++) {
-        if (existsSync(join(dir, '.vibe-splainer', 'analysis.json')))
-            return dir;
-        const parent = dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return null;
-}
-/** Pure-ish core: raw stdin string in, hook decision (as a string or null) out. */
-export async function runHookCommand(rawStdin) {
-    let input;
-    try {
-        input = JSON.parse(rawStdin);
-    }
-    catch {
-        return { stdout: null }; // malformed input → never block the agent
-    }
-    const root = findProjectRoot(input.cwd);
-    const gatePath = root ? join(root, '.vibe-splainer', 'gate.json') : null;
-    const gateExists = gatePath ? existsSync(gatePath) : false;
-    let gateIndex = null;
-    if (gateExists) {
-        try {
-            gateIndex = JSON.parse(readFileSync(gatePath, 'utf8'));
-        }
-        catch { }
-    }
-    const sessionId = input.session_id || 'default';
-    const warnFile = join(tmpdir(), `vibe-splain-warn-${sessionId}`);
-    const warningShown = existsSync(warnFile);
-    const result = decidePreToolUse(input, gateIndex, { warningShown });
-    if (result.action === 'defer')
-        return { stdout: null };
-    if (!gateIndex && result.action === 'emit') {
-        try {
-            writeFileSync(warnFile, '1');
-        }
-        catch { }
-    }
-    return { stdout: JSON.stringify(result.output) };
-}
-/** CLI entrypoint: read all of stdin, run the gate, emit the result. */
-export async function hookPreToolUseCommand() {
-    const raw = await readStdin();
-    const { stdout } = await runHookCommand(raw);
-    if (stdout)
-        process.stdout.write(stdout);
-    // No stdout on defer; exit code stays 0.
-}
-function readStdin() {
-    return new Promise((resolve) => {
-        let data = '';
-        if (process.stdin.isTTY) {
-            resolve('');
-            return;
-        }
-        process.stdin.setEncoding('utf8');
-        process.stdin.on('data', (chunk) => { data += chunk; });
-        process.stdin.on('end', () => resolve(data));
-        process.stdin.on('error', () => resolve(data));
-    });
-}
-//# sourceMappingURL=hook.js.map

package/dist/commands/importBundle.d.ts

@@ -1,4 +0,0 @@
-export declare function importBundleCommand(tarballPath: string, opts?: {
-    projectRoot?: string;
-    namespace?: string;
-}): Promise<void>;

package/dist/commands/importBundle.js

@@ -1,80 +0,0 @@
-import { join } from 'path';
-import { readFile, mkdir, rm } from 'fs/promises';
-import { existsSync } from 'fs';
-import * as tar from 'tar';
-import { createHash } from 'crypto';
-import { BlobStore } from '../store/BlobStore.js';
-import { PointerStore } from '../store/PointerStore.js';
-export async function importBundleCommand(tarballPath, opts = {}) {
-    const root = opts.projectRoot ?? process.cwd();
-    const namespace = opts.namespace ?? `imported_${Date.now()}`;
-    console.error(`[vibe-splain import] Importing ${tarballPath} into ${root} (namespace: ${namespace})`);
-    if (!existsSync(tarballPath)) {
-        throw new Error(`Tarball not found: ${tarballPath}`);
-    }
-    // Extract to a temp directory
-    const extractDir = join(root, '.vibe-splainer', 'tmp', `import-${namespace}`);
-    await mkdir(extractDir, { recursive: true });
-    try {
-        await tar.extract({
-            file: tarballPath,
-            cwd: extractDir,
-        });
-        // Read bundle manifest
-        const manifestPath = join(extractDir, 'bundle-manifest.json');
-        if (!existsSync(manifestPath)) {
-            throw new Error('Invalid bundle: missing bundle-manifest.json');
-        }
-        const manifestRaw = await readFile(manifestPath, 'utf8');
-        const manifest = JSON.parse(manifestRaw);
-        if (manifest.schemaVersion !== '1.0.0') {
-            throw new Error(`Unsupported bundle schema version: ${manifest.schemaVersion}`);
-        }
-        const blobStore = new BlobStore(root);
-        const pointerStore = PointerStore.open(root);
-        await blobStore.ensureDirs();
-        let imported = 0;
-        let hashErrors = 0;
-        for (const entry of manifest.pointers) {
-            const blobSrcPath = join(extractDir, entry.blobFile);
-            if (!existsSync(blobSrcPath)) {
-                console.error(`[vibe-splain import] Missing blob for pointer ${entry.pointerId}: ${entry.blobFile}`);
-                hashErrors++;
-                continue;
-            }
-            // Verify hash before importing
-            const content = await readFile(blobSrcPath);
-            const actualHash = `sha256:${createHash('sha256').update(content).digest('hex')}`;
-            if (actualHash !== entry.contentHash) {
-                console.error(`[vibe-splain import] Hash mismatch for ${entry.pointerId}: expected ${entry.contentHash}, got ${actualHash}`);
-                hashErrors++;
-                continue;
-            }
-            // Write blob to local store (atomic)
-            const { blobPath } = await blobStore.writeAtomic(content);
-            // Insert pointer under bundle namespace alias
-            const namespacedPointerId = `${namespace}::${entry.pointerId}`;
-            const namespacedScanId = `${namespace}::${entry.scanId}`;
-            await pointerStore.insertPointer({
-                pointerId: namespacedPointerId,
-                scanId: namespacedScanId,
-                artifactName: entry.artifactName,
-                contentHash: entry.contentHash,
-                blobPath,
-                schemaVersion: entry.schemaVersion,
-                createdAt: entry.createdAt,
-                expiresAt: entry.expiresAt,
-            });
-            imported++;
-        }
-        if (hashErrors > 0) {
-            console.error(`[vibe-splain import] Warning: ${hashErrors} blobs failed hash verification and were skipped`);
-        }
-        console.error(`[vibe-splain import] Imported ${imported}/${manifest.pointers.length} pointers under namespace "${namespace}"`);
-        console.error(`[vibe-splain import] Original scanId: ${manifest.scanId} → namespaced as: ${namespace}::${manifest.scanId}`);
-    }
-    finally {
-        await rm(extractDir, { recursive: true, force: true });
-    }
-}
-//# sourceMappingURL=importBundle.js.map

package/dist/commands/network.d.ts

@@ -1 +0,0 @@
-export declare function networkPlanCommand(task: string, options: any): Promise<void>;

package/dist/commands/network.js

@@ -1,91 +0,0 @@
-import { join, resolve } from 'path';
-import { readFile, writeFile, mkdir } from 'fs/promises';
-import { buildExpertNetworkPacket } from '@vibe-splain/brain';
-export async function networkPlanCommand(task, options) {
-    const projectRoot = options.root ? resolve(options.root) : process.cwd();
-    const maxFiles = options.maxFiles ? parseInt(options.maxFiles, 10) : 8;
-    // Try to load scan artifact
-    let scanArtifact = null;
-    const artifactPath = options.scanArtifact
-        ? resolve(options.scanArtifact)
-        : join(projectRoot, '.vibe-splainer', 'analysis.json');
-    try {
-        const raw = await readFile(artifactPath, 'utf8');
-        scanArtifact = JSON.parse(raw);
-    }
-    catch (err) {
-        if (options.scanArtifact) {
-            console.error(`[vibe-splain] Error reading scan artifact at ${artifactPath}:`, err.message);
-        }
-    }
-    // Build the packet
-    const packet = buildExpertNetworkPacket({
-        task,
-        projectRoot,
-        scanArtifact,
-        errorTrace: options.errorTrace,
-        intendedBehavior: options.intendedBehavior,
-        maxFiles
-    });
-    // Save artifacts
-    const networkDir = join(projectRoot, '.vibe-splainer', 'network');
-    const packetsDir = join(networkDir, 'packets');
-    try {
-        await mkdir(packetsDir, { recursive: true });
-        // Save latest
-        const latestPath = join(networkDir, 'latest_packet.json');
-        await writeFile(latestPath, JSON.stringify(packet, null, 2), 'utf8');
-        // Save timestamped
-        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-        const timestampedPath = join(packetsDir, `${timestamp}.json`);
-        await writeFile(timestampedPath, JSON.stringify(packet, null, 2), 'utf8');
-        if (options.json) {
-            process.stdout.write(JSON.stringify(packet, null, 2) + '\n');
-        }
-        else {
-            process.stdout.write('────────────────────────────────────────────────────────\n');
-            process.stdout.write(' Vibe-Splain Specialist Network — Task Plan\n');
-            process.stdout.write('────────────────────────────────────────────────────────\n');
-            process.stdout.write(`Task:               "${packet.task}"\n`);
-            process.stdout.write(`Project Root:       ${packet.projectRoot}\n`);
-            process.stdout.write(`Primary Specialist: ${packet.route.primarySpecialist}\n`);
-            process.stdout.write(`Panel:              ${packet.route.panel.join(', ')}\n`);
-            process.stdout.write(`Confidence:         ${packet.route.confidence}\n`);
-            process.stdout.write(`Reason:             ${packet.route.reason}\n`);
-            process.stdout.write('\nSelected Files:\n');
-            if (packet.selectedFiles.length > 0) {
-                packet.selectedFiles.forEach(f => {
-                    process.stdout.write(`  • ${f.path} [blastRadius: ${f.blastRadius}]\n`);
-                    process.stdout.write(`    Reason: ${f.reason}\n`);
-                });
-            }
-            else {
-                process.stdout.write('  (No files selected)\n');
-            }
-            process.stdout.write('\nRisk Warnings:\n');
-            if (packet.riskWarnings.length > 0) {
-                packet.riskWarnings.forEach(w => {
-                    const levelLabel = w.level === 'critical' ? '🔴 CRITICAL' : (w.level === 'warning' ? '🟡 WARNING' : 'ℹ️ INFO');
-                    process.stdout.write(`  • [${levelLabel}] ${w.message}\n`);
-                    process.stdout.write(`    Reason: ${w.reason}\n`);
-                });
-            }
-            else {
-                process.stdout.write('  (No risks identified)\n');
-            }
-            process.stdout.write('\nSmallest Safe Change Policy:\n');
-            process.stdout.write(`  ${packet.smallestSafeChangePolicy.summary}\n`);
-            process.stdout.write('\nSaved Artifacts:\n');
-            process.stdout.write(`  • Latest: ${latestPath}\n`);
-            process.stdout.write(`  • Packet: ${timestampedPath}\n`);
-            process.stdout.write('────────────────────────────────────────────────────────\n');
-        }
-    }
-    catch (err) {
-        console.error('[vibe-splain] Error saving network artifacts:', err.message);
-        if (options.json) {
-            process.stdout.write(JSON.stringify(packet, null, 2) + '\n');
-        }
-    }
-}
-//# sourceMappingURL=network.js.map

package/dist/commands/scan.d.ts

@@ -1,13 +0,0 @@
-interface ScanOptions {
-    root?: string;
-    out?: string;
-    json?: boolean;
-}
-/**
- * Headless one-shot scan. Reuses the exact MCP scan pipeline (performScan),
- * relocates the artifact bundle to --out, and prints a summary. The gravity
- * formula is selected by the ROZE_GRAVITY_V2 env var, never a CLI flag — v2 is
- * still an experimental candidate (see CONTEXT.md / Phase 0).
- */
-export declare function scanCommand(options?: ScanOptions): Promise<void>;
-export {};

package/dist/commands/scan.js

@@ -1,97 +0,0 @@
-import { resolve, join, dirname } from 'path';
-import { rm, rename, mkdir, writeFile } from 'fs/promises';
-import { performScan } from '../mcp/tools/scan_project.js';
-/**
- * Headless one-shot scan. Reuses the exact MCP scan pipeline (performScan),
- * relocates the artifact bundle to --out, and prints a summary. The gravity
- * formula is selected by the ROZE_GRAVITY_V2 env var, never a CLI flag — v2 is
- * still an experimental candidate (see CONTEXT.md / Phase 0).
- */
-export async function scanCommand(options = {}) {
-    const root = resolve(options.root || '.');
-    const gravityMode = process.env.ROZE_GRAVITY_V2 === '1' ? 'v2_candidate' : 'v1_default';
-    console.error(`[roze] Scanning ${root} (gravity mode: ${gravityMode})...`);
-    const { result, scanId } = await performScan(root);
-    // The pipeline always writes to <root>/.roze. Relocate to --out if different
-    // so v1 and v2 runs can coexist for comparison.
-    const defaultDir = join(root, '.roze');
-    const outDir = resolve(options.out || defaultDir);
-    if (outDir !== defaultDir) {
-        await rm(outDir, { recursive: true, force: true });
-        await mkdir(dirname(outDir), { recursive: true });
-        await rename(defaultDir, outDir);
-    }
-    // Persist the gravity mode so v1/v2 scans are self-identifying.
-    const meta = {
-        gravityMode,
-        scannedAt: new Date().toISOString(),
-        root,
-        scanId,
-        totalFilesScanned: result.totalFilesScanned,
-        realSourceCount: result.realSourceCount,
-        wildCandidateCount: result.wildCandidates.length,
-    };
-    await writeFile(join(outDir, 'scan_meta.json'), JSON.stringify(meta, null, 2));
-    // Build gravity/heat lookups from the scored files for display.
-    const gravityByPath = new Map(result.files.map(f => [f.relativePath, f.gravity]));
-    const heatByPath = new Map(result.files.map(f => [f.relativePath, f.heat]));
-    const topGravity = result.map.topGravity.slice(0, 12).map(p => ({
-        path: p,
-        gravity: Math.round(gravityByPath.get(p) ?? 0),
-    }));
-    const topHeat = result.map.topHeat.slice(0, 12).map(p => ({
-        path: p,
-        heat: Math.round(heatByPath.get(p) ?? 0),
-    }));
-    const wildDiscovery = result.wildCandidates.slice(0, 12).map(f => ({
-        path: f.relativePath,
-        heat: Math.round(f.heat),
-        gravity: Math.round(f.gravity),
-        topSmells: f.smells.filter(s => s.severity >= 3).slice(0, 3).map(s => s.note),
-    }));
-    const specialistMap = result.map.pillars.map(p => ({
-        name: p.name,
-        fileCount: p.memberFiles.length,
-    }));
-    const summary = {
-        gravityMode,
-        root,
-        outDir,
-        dossier: join(outDir, 'dossier.json'),
-        analysis: join(outDir, 'analysis.json'),
-        stack: result.map.stack,
-        totalFilesScanned: result.totalFilesScanned,
-        realSourceCount: result.realSourceCount,
-        topGravity,
-        topHeat,
-        wildDiscovery,
-        specialistMap,
-    };
-    if (options.json) {
-        process.stdout.write(JSON.stringify(summary, null, 2) + '\n');
-        return;
-    }
-    const lines = [];
-    lines.push('');
-    lines.push(`roze scan — gravity mode: ${gravityMode}`);
-    lines.push(`  root:  ${root}`);
-    lines.push(`  stack: ${result.map.stack.join(', ') || '(none detected)'}`);
-    lines.push(`  files: ${result.totalFilesScanned} scanned, ${result.realSourceCount} real-source`);
-    lines.push('');
-    lines.push('Top Gravity (Start Here):');
-    topGravity.forEach((f, i) => lines.push(`  ${String(i + 1).padStart(2)}. [${String(f.gravity).padStart(3)}] ${f.path}`));
-    lines.push('');
-    lines.push('Top Heat (Wild Discovery):');
-    topHeat.forEach((f, i) => lines.push(`  ${String(i + 1).padStart(2)}. [${String(f.heat).padStart(3)}] ${f.path}`));
-    lines.push('');
-    lines.push('Specialist Map (pillars):');
-    specialistMap.forEach(p => lines.push(`  - ${p.name} (${p.fileCount} files)`));
-    lines.push('');
-    lines.push(`Artifacts written to: ${outDir}`);
-    lines.push(`  dossier:  ${join(outDir, 'dossier.json')}`);
-    lines.push(`  analysis: ${join(outDir, 'analysis.json')}`);
-    lines.push(`  meta:     ${join(outDir, 'scan_meta.json')} (gravityMode: ${gravityMode})`);
-    lines.push('');
-    process.stdout.write(lines.join('\n'));
-}
-//# sourceMappingURL=scan.js.map

package/dist/export/renderers/DeltaRenderer.d.ts

@@ -1,6 +0,0 @@
-import type { DossierViewModel, AnalysisStore } from '@vibe-splain/brain';
-import type { Renderer } from './Renderer.js';
-import type { Artifact } from '../ArtifactBundleWriter.js';
-export declare class DeltaRenderer implements Renderer {
-    render(_viewModel: DossierViewModel, store: AnalysisStore): Artifact[];
-}

package/dist/export/renderers/DeltaRenderer.js

@@ -1,22 +0,0 @@
-export class DeltaRenderer {
-    render(_viewModel, store) {
-        const deltaTargets = Object.values(store.files)
-            .filter(pf => pf.isRealSource)
-            .sort((a, b) => b.gravity - a.gravity)
-            .map(pf => ({
-            path: pf.relativePath,
-            gravity: Math.round(pf.gravity),
-            isLoadBearing: pf.canonicalLoadBearing,
-            blastRadius: pf.importedBy,
-            pillarHint: pf.pillarHint,
-        }));
-        return [
-            {
-                type: 'delta',
-                path: 'delta_targets.json',
-                content: JSON.stringify(deltaTargets, null, 2),
-            }
-        ];
-    }
-}
-//# sourceMappingURL=DeltaRenderer.js.map