vibe-splain 3.4.2 → 3.5.0

package/dist/mcp/server.js

@@ -13,14 +13,9 @@ import { handleGetWildDiscoveries, getWildDiscoveriesTool } from './tools/get_wi
 import { handleMarkStale, markStaleTool } from './tools/mark_stale.js';
 import { handleGetFileSkeleton, getFileSkeletonTool } from './tools/get_file_skeleton.js';
 import { handleReadFile, readFileTool } from './tools/read_file.js';
-import { handleCreateWorkOrder, createWorkOrderTool, handleSpawnWorker, spawnWorkerTool } from './tools/work_orders.js';
-import { handleSetSessionScope, setSessionScopeTool } from './tools/set_session_scope.js';
-import { handleYieldForScopeExpansion, yieldForScopeExpansionTool } from './tools/yield_for_scope_expansion.js';
 import { handleGetStartHere, getStartHereTool } from './tools/hydration/get_start_here.js';
 import { handleGetProjectSummary, getProjectSummaryTool } from './tools/hydration/get_project_summary.js';
 import { handleGetEvidenceSlice, getEvidenceSliceTool } from './tools/hydration/get_evidence_slice.js';
-import { handlePrepareTaskContext, prepareTaskContextTool } from './tools/prepareTaskContext.js';
-import { handleExplainSpecialistScope, explainSpecialistScopeTool } from './tools/explainSpecialistScope.js';
 // ⚠️ CRITICAL: Never use console.log() anywhere in this codebase.
 // stdout is owned by the MCP SDK for protocol messages.
 // Use console.error() for all diagnostic output.
@@ -40,15 +35,6 @@ const ALL_TOOLS = [
     getStartHereTool,
     getProjectSummaryTool,
     getEvidenceSliceTool,
-    // Phase 3: Worker Delegation
-    createWorkOrderTool,
-    spawnWorkerTool,
-    // Phase 4: Scope & Escalation
-    setSessionScopeTool,
-    yieldForScopeExpansionTool,
-    // Specialist Network v0
-    prepareTaskContextTool,
-    explainSpecialistScopeTool,
 ];
 const TOOL_HANDLERS = {
     scan_project: handleScanProject,
@@ -66,21 +52,12 @@ const TOOL_HANDLERS = {
     get_start_here: handleGetStartHere,
     get_project_summary: handleGetProjectSummary,
     get_evidence_slice: handleGetEvidenceSlice,
-    // Phase 3
-    create_work_order: handleCreateWorkOrder,
-    spawn_worker: handleSpawnWorker,
-    // Phase 4
-    set_session_scope: handleSetSessionScope,
-    yield_for_scope_expansion: handleYieldForScopeExpansion,
-    // Specialist Network v0
-    vibe_prepare_task_context: handlePrepareTaskContext,
-    vibe_explain_specialist_scope: handleExplainSpecialistScope,
 };
 export async function startMCPServer(options = {}) {
     // Initialize Tree-Sitter WASM once at startup
     await initParser();
     console.error('[vibe-splain] Tree-Sitter parser initialized');
-    const server = new Server({ name: 'vibe-splain', version: '3.0.0' }, { capabilities: { tools: {}, prompts: {} } });
+    const server = new Server({ name: 'vibe-splain', version: '3.5.0' }, { capabilities: { tools: {}, prompts: {} } });
     // Register prompts
     server.setRequestHandler(ListPromptsRequestSchema, async () => ({
         prompts: [

package/package.json

@@ -1,7 +1,7 @@
 {
   "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": "3.5.0",
+  "description": "Static-analysis MRI for codebases: a Tree-Sitter dossier engine and deterministic PreToolUse safety gate for coding agents. Language-agnostic core, optimized for TypeScript/JavaScript.",
   "type": "module",
   "license": "MIT",
   "author": "abp2204",

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/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

package/dist/hook-entry.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/hook-entry.js

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-// Lean entrypoint for the PreToolUse hook. Bundled separately from the main CLI
-// so it pulls in ONLY the gate-index reader + decision logic — no Tree-Sitter
-// WASM, no MCP SDK, no chokidar. Keeps per-edit startup near the bare-Node floor
-// (~40–60ms) instead of loading the full scanner bundle (~260ms+).
-import { hookPreToolUseCommand } from './commands/hook.js';
-hookPreToolUseCommand();
-//# sourceMappingURL=hook-entry.js.map

package/dist/mcp/tools/apply_patch.d.ts

@@ -1,37 +0,0 @@
-export declare class StalePatchError extends Error {
-    readonly filePath: string;
-    readonly expectedHash: string;
-    readonly actualHash: string;
-    constructor(filePath: string, expectedHash: string, actualHash: string);
-}
-export declare const applyPatchTool: {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            projectRoot: {
-                type: string;
-                description: string;
-            };
-            filePath: {
-                type: string;
-                description: string;
-            };
-            newContent: {
-                type: string;
-                description: string;
-            };
-            expectedPrePatchHash: {
-                type: string;
-                description: string;
-            };
-            scanId: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
-    };
-};
-export declare function handleApplyPatch(args: Record<string, unknown>): Promise<unknown>;