@unerr-ai/unerr 0.2.0 → 0.2.2

package/dist/utils/session-logger.js

@@ -1,154 +0,0 @@
-/**
- * Session Logger — consola-based structured logging to .unerr/logs/.
- *
- * All debug and diagnostic data goes here, never to the terminal.
- * Terminal shows only user-facing output (ora spinners, styled stats).
- *
- * Format: NDJSON — one JSON object per line.
- * Rotation: max 10 files, max 10MB each.
- * Retention: 30 days (older files auto-deleted on boot).
- *
- * Temporal intelligence note: session log entries form the episodic memory
- * tier (fast decay, power-law half-life ~3 days). The consolidation daemon
- * compresses these into semantic facts during idle phases.
- */
-import { randomUUID } from "node:crypto";
-import { appendFileSync, existsSync, mkdirSync, readdirSync, statSync, unlinkSync, } from "node:fs";
-import { join } from "node:path";
-import { createConsola } from "consola";
-const SESSION_ID = randomUUID();
-const RETENTION_DAYS = 30;
-const MAX_FILES = 10;
-function formatTimestamp() {
-    const d = new Date();
-    const pad = (n) => String(n).padStart(2, "0");
-    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
-}
-function cleanupOldLogs(logsDir) {
-    if (!existsSync(logsDir))
-        return;
-    try {
-        const files = readdirSync(logsDir)
-            .filter((f) => f.startsWith("session-") && f.endsWith(".log"))
-            .map((f) => {
-            const fullPath = join(logsDir, f);
-            const stat = statSync(fullPath);
-            return {
-                name: f,
-                path: fullPath,
-                mtimeMs: stat.mtimeMs,
-            };
-        })
-            .sort((a, b) => b.mtimeMs - a.mtimeMs);
-        const cutoff = Date.now() - RETENTION_DAYS * 24 * 60 * 60 * 1000;
-        for (const file of files) {
-            if (file.mtimeMs < cutoff) {
-                try {
-                    unlinkSync(file.path);
-                }
-                catch {
-                    /* best effort */
-                }
-            }
-        }
-        const remaining = files.filter((f) => existsSync(f.path));
-        if (remaining.length > MAX_FILES) {
-            for (const file of remaining.slice(MAX_FILES)) {
-                try {
-                    unlinkSync(file.path);
-                }
-                catch {
-                    /* best effort */
-                }
-            }
-        }
-    }
-    catch {
-        /* never crash on log cleanup failure */
-    }
-}
-let _logger = null;
-let _logFilePath = null;
-/**
- * Initialize the session logger. Call once at boot.
- * Returns the consola logger instance. Subsequent calls return the same instance.
- */
-export function initSessionLogger(opts = {}) {
-    if (_logger)
-        return _logger;
-    const cwd = opts.cwd ?? process.cwd();
-    const logsDir = join(cwd, ".unerr", "logs");
-    mkdirSync(logsDir, { recursive: true });
-    cleanupOldLogs(logsDir);
-    const timestamp = formatTimestamp();
-    _logFilePath = join(logsDir, `session-${timestamp}.log`);
-    const levelNum = opts.level !== undefined ? Number(opts.level) : undefined;
-    const envLevel = process.env.UNERR_LOG_LEVEL;
-    const resolvedLevel = levelNum ?? (envLevel ? Number(envLevel) : 3);
-    _logger = createConsola({
-        level: resolvedLevel,
-        stdout: process.stderr,
-        stderr: process.stderr,
-        reporters: [
-            {
-                log: (logObj) => {
-                    if (!_logFilePath)
-                        return;
-                    try {
-                        const entry = {
-                            time: new Date().toISOString(),
-                            level: logObj.type,
-                            session_id: SESSION_ID,
-                            tag: logObj.tag,
-                            msg: logObj.args
-                                .map((a) => (typeof a === "string" ? a : JSON.stringify(a)))
-                                .join(" "),
-                        };
-                        appendFileSync(_logFilePath, `${JSON.stringify(entry)}\n`);
-                    }
-                    catch {
-                        /* best effort */
-                    }
-                },
-            },
-        ],
-    });
-    _logger.info({
-        module: "logger",
-        msg: "Session started",
-        data: { cwd, level: resolvedLevel },
-    });
-    return _logger;
-}
-/**
- * Get the current session logger. Returns a silent logger if not initialized.
- */
-export function getSessionLogger() {
-    if (_logger)
-        return _logger;
-    return createConsola({ level: -999 });
-}
-/**
- * Create a child logger scoped to a specific module.
- */
-export function createSessionModuleLogger(module) {
-    return getSessionLogger().withTag(module);
-}
-/**
- * Get the current session log file path.
- */
-export function getSessionLogPath() {
-    return _logFilePath;
-}
-/**
- * Get the current session ID.
- */
-export function getSessionId() {
-    return SESSION_ID;
-}
-/**
- * Flush the logger (for graceful shutdown). No-op for consola (writes are sync).
- */
-export function flushSessionLogger() {
-    /* consola file writes are synchronous via appendFileSync — no flush needed */
-}

package/dist/utils/startup-log.js

@@ -1,512 +0,0 @@
-/**
- * Premium Startup Logger — brand-aligned terminal output.
- *
- * Design principles (inspired by Claude Code, Vercel, PostHog):
- *   - Every line tells you something you didn't know
- *   - Strategic color: violet accent (brand), cyan (live data), emerald (success)
- *   - Dim metadata, bold insights — the eye goes to what matters
- *   - Step markers with timing — feels responsive and intentional
- *   - No walls of text — one insight per line, whitespace between phases
- *
- * Color palette (from styles/tailwind.css design system):
- *   - Violet #8B5CF6 (brand accent)
- *   - Cyan #22D3EE (live/active data)
- *   - Emerald #34D399 (success)
- *   - Amber #FBBF24 (warning)
- *   - Red #F87171 (error)
- *   - Cloud White #FAFAFA (primary text)
- *   - Muted #A1A1AA (metadata)
- *
- * All output to stderr (stdout is MCP JSON-RPC sacred).
- * File logging: call `initFileLog(cwd)` once at boot to enable parallel
- * NDJSON logging to `.unerr/logs/unerr.jsonl` with richer metadata than console.
- */
-import { appendFileSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
-import { join } from "node:path";
-// ── File logging ────────────────────────────────────────────────────
-let _fileLogPath = null;
-let _fileLogCount = 0;
-/** Strip ANSI escape sequences for machine-readable file output. */
-function stripAnsi(s) {
-    const ESC = "\x1b";
-    const CSI = new RegExp(`${ESC}\\[[0-9;?]*[A-Za-z~]`, "g");
-    const OSC = new RegExp(`${ESC}\\][^\\x07]*\\x07`, "g");
-    return s.replace(CSI, "").replace(OSC, "");
-}
-function rotateIfNeeded(filePath, maxLines, keepLines) {
-    try {
-        const content = readFileSync(filePath, "utf-8");
-        const lines = content.split("\n").filter(Boolean);
-        if (lines.length > maxLines) {
-            writeFileSync(filePath, `${lines.slice(-keepLines).join("\n")}\n`);
-        }
-    }
-    catch {
-        /* file may not exist yet */
-    }
-}
-/** Initialize file logging for this process. Call once at boot. */
-export function initFileLog(cwd) {
-    const logsDir = join(cwd, ".unerr", "logs");
-    mkdirSync(logsDir, { recursive: true });
-    _fileLogPath = join(logsDir, "unerr.jsonl");
-    rotateIfNeeded(_fileLogPath, 2000, 1000);
-}
-function writeToFile(level, message, meta) {
-    if (!_fileLogPath)
-        return;
-    const entry = {
-        ts: new Date().toISOString(),
-        pid: process.pid,
-        level,
-        msg: stripAnsi(message),
-        ...meta,
-    };
-    try {
-        appendFileSync(_fileLogPath, `${JSON.stringify(entry)}\n`);
-        if (++_fileLogCount % 200 === 0)
-            rotateIfNeeded(_fileLogPath, 2000, 1000);
-    }
-    catch {
-        /* best effort */
-    }
-}
-// ── ANSI 256-color helpers ──────────────────────────────────────────
-const ESC = "\x1b[";
-const RESET = `${ESC}0m`;
-const BOLD = `${ESC}1m`;
-const DIM = `${ESC}2m`;
-const ITALIC = `${ESC}3m`;
-// 256-color foreground: \x1b[38;5;{n}m
-function fg256(n) {
-    return `${ESC}38;5;${n}m`;
-}
-// True-color (24-bit) foreground: \x1b[38;2;r;g;bm
-function fgRgb(r, g, b) {
-    return `${ESC}38;2;${r};${g};${b}m`;
-}
-// ── Brand color codes (true-color for maximum fidelity) ─────────────
-const VIOLET = fgRgb(139, 92, 246); // #8B5CF6
-const CYAN = fgRgb(34, 211, 238); // #22D3EE
-const EMERALD = fgRgb(52, 211, 153); // #34D399
-const AMBER = fgRgb(251, 191, 36); // #FBBF24
-const RED = fgRgb(248, 113, 113); // #F87171
-const MUTED = fgRgb(161, 161, 170); // #A1A1AA
-const WHITE = fgRgb(250, 250, 250); // #FAFAFA
-// ── Formatters ──────────────────────────────────────────��───────────
-function violet(s) {
-    return `${VIOLET}${s}${RESET}`;
-}
-function cyan(s) {
-    return `${CYAN}${s}${RESET}`;
-}
-function emerald(s) {
-    return `${EMERALD}${s}${RESET}`;
-}
-function amber(s) {
-    return `${AMBER}${s}${RESET}`;
-}
-function red(s) {
-    return `${RED}${s}${RESET}`;
-}
-function muted(s) {
-    return `${MUTED}${s}${RESET}`;
-}
-function bold(s) {
-    return `${BOLD}${s}${RESET}`;
-}
-function dim(s) {
-    return `${DIM}${s}${RESET}`;
-}
-function brandBold(s) {
-    return `${BOLD}${VIOLET}${s}${RESET}`;
-}
-// ── Symbols ─────────────────────────────────────────────────────────
-const SYM = {
-    step: `${VIOLET}▸${RESET}`,
-    done: `${EMERALD}✓${RESET}`,
-    warn: `${AMBER}⚠${RESET}`,
-    fail: `${RED}✗${RESET}`,
-    dot: `${MUTED}·${RESET}`,
-    arrow: `${MUTED}→${RESET}`,
-    bar: `${MUTED}│${RESET}`,
-    brain: `${VIOLET}◆${RESET}`,
-    bolt: `${CYAN}⚡${RESET}`,
-};
-// ── Output (always stderr) ──────────────────────────────────────────
-// Pause buffer — when paused (e.g. while an interactive clack prompt owns
-// the terminal during indexing), startup lines are buffered and flushed on
-// resume. Avoids prints like "Dashboard — http://…" appearing under the
-// prompt while the user is still picking an option.
-let paused = false;
-const pauseBuffer = [];
-function write(line) {
-    if (paused) {
-        pauseBuffer.push(line);
-        return;
-    }
-    process.stderr.write(`${line}\n`);
-}
-function pauseWrites() {
-    paused = true;
-}
-function resumeWrites() {
-    paused = false;
-    if (pauseBuffer.length === 0)
-        return;
-    const pending = pauseBuffer.splice(0, pauseBuffer.length);
-    for (const line of pending) {
-        process.stderr.write(`${line}\n`);
-    }
-}
-// ── Public API ──────────────────────────────────────────��───────────
-export const startupLog = {
-    /** Brand header — first thing the user sees */
-    header() {
-        write("");
-        write(`  ${brandBold("unerr")} ${muted("— intelligence engine for AI agents")}`);
-        write("");
-        writeToFile("header", "unerr — intelligence engine for AI agents");
-    },
-    /** Phase separator with dim label */
-    phase(label) {
-        write(`  ${dim("─── ")}${muted(label)}${dim(" ───")}`);
-        writeToFile("phase", label);
-    },
-    /** Active step — something is happening */
-    step(msg) {
-        write(`  ${SYM.step} ${msg}`);
-        writeToFile("step", stripAnsi(msg));
-    },
-    /** Completed step with optional timing */
-    done(msg, ms) {
-        const timing = ms !== undefined ? ` ${muted(`${ms}ms`)}` : "";
-        write(`  ${SYM.done} ${msg}${timing}`);
-        writeToFile("done", stripAnsi(msg), ms !== undefined ? { ms } : undefined);
-    },
-    /** Insight line — the wow factor. Tells user something they didn't know */
-    insight(msg) {
-        write(`  ${SYM.brain} ${msg}`);
-        writeToFile("insight", stripAnsi(msg));
-    },
-    /** Live data / metric with cyan accent */
-    metric(label, value, unit) {
-        const unitStr = unit ? ` ${muted(unit)}` : "";
-        write(`  ${SYM.dot} ${muted(label)} ${cyan(String(value))}${unitStr}`);
-        writeToFile("metric", label, { value, unit });
-    },
-    /** Performance highlight — instant/fast operations */
-    perf(msg) {
-        write(`  ${SYM.bolt} ${msg}`);
-        writeToFile("perf", stripAnsi(msg));
-    },
-    /** Warning — non-blocking issue */
-    warn(msg) {
-        write(`  ${SYM.warn} ${amber(msg)}`);
-        writeToFile("warn", msg);
-    },
-    /**
-     * File-only log entry — writes to .unerr/logs/unerr.jsonl without touching
-     * stderr. Use this on hot paths like `unerr exec` where stderr gets merged
-     * into the agent's tool-result context (every byte we emit is LLM tokens),
-     * but we still want the event in the JSONL log for dashboards / debugging.
-     */
-    fileOnly(level, msg, meta) {
-        writeToFile(level, msg, meta);
-    },
-    /** Error — blocking issue */
-    error(msg) {
-        write(`  ${SYM.fail} ${red(msg)}`);
-        writeToFile("error", msg);
-    },
-    /** Detail line — supplementary info, indented + dim */
-    detail(msg) {
-        write(`    ${muted(msg)}`);
-        writeToFile("detail", msg);
-    },
-    /** Blank line for breathing room */
-    blank() {
-        write("");
-    },
-    /** Final ready message — the "we're good" confirmation */
-    ready(toolCount, mode) {
-        write("");
-        write(`  ${SYM.done} ${bold("Ready")} ${muted("—")} ${cyan(String(toolCount))} ${muted("tools")} ${muted("·")} ${muted(mode)} ${muted("mode")} ${muted("·")} ${emerald("<5ms")} ${muted("per query")}`);
-        write("");
-        writeToFile("ready", "Ready", { toolCount, mode });
-    },
-    /** Session summary box — end of session stats */
-    summary(stats) {
-        write("");
-        write(`  ${dim("┌──────────────────────────────────────────┐")}`);
-        write(`  ${dim("│")} ${brandBold("unerr")} session                          ${dim("│")}`);
-        write(`  ${dim("├──────────────────────────────────────────┤")}`);
-        write(`  ${dim("│")}  Duration     ${cyan(stats.duration.padEnd(24))}${dim("│")}`);
-        write(`  ${dim("│")}  Tool calls   ${cyan(String(stats.toolCalls).padEnd(24))}${dim("│")}`);
-        if (stats.tokensSaved) {
-            write(`  ${dim("│")}  Saved        ${emerald(stats.tokensSaved.padEnd(24))}${dim("│")}`);
-        }
-        if (stats.efficiency) {
-            write(`  ${dim("│")}  Efficiency   ${emerald(stats.efficiency.padEnd(24))}${dim("│")}`);
-        }
-        write(`  ${dim("└──────────────────────────────────────────┘")}`);
-        write("");
-        writeToFile("summary", "Session summary", {
-            duration: stats.duration,
-            toolCalls: stats.toolCalls,
-            tokensSaved: stats.tokensSaved,
-            efficiency: stats.efficiency,
-        });
-    },
-    // ── Convenience composites ──────────────────────────────────────
-    /** Graph loaded insight block — the money shot */
-    graphLoaded(stats) {
-        const avgConn = stats.edges > 0 ? (stats.edges / stats.entities).toFixed(1) : "0";
-        write(`  ${SYM.done} ${bold("Graph loaded")} ${muted(`in ${stats.ms}ms`)}`);
-        write("");
-        write(`    ${cyan(stats.entities.toLocaleString())} entities ${muted("across")} ${cyan(String(stats.files))} files ${muted("·")} ${cyan(stats.edges.toLocaleString())} edges ${muted(`(${avgConn} avg/entity)`)}`);
-        write(`    ${violet(String(stats.communities))} communities ${muted("detected")} ${muted("·")} ${violet(String(stats.patterns))} conventions ${muted("→")} ${violet(String(stats.rules))} rules`);
-        if (stats.hottestFile) {
-            write(`    ${muted("hottest:")} ${bold(stats.hottestFile)} ${muted(`(${stats.hottestCount} entities)`)}`);
-        }
-        write("");
-        writeToFile("graph_loaded", "Graph loaded", {
-            entities: stats.entities,
-            edges: stats.edges,
-            files: stats.files,
-            communities: stats.communities,
-            patterns: stats.patterns,
-            rules: stats.rules,
-            ms: stats.ms,
-            hottestFile: stats.hottestFile,
-            hottestCount: stats.hottestCount,
-        });
-    },
-    /** MCP tools registered */
-    toolsReady(count, ruleCount) {
-        write(`  ${SYM.done} ${cyan(String(count))} intelligence tools registered ${ruleCount > 0 ? muted(`(${ruleCount} enforcement rules)`) : ""}`);
-        writeToFile("tools_ready", "Tools registered", { count, ruleCount });
-    },
-    /** Skills installed during setup */
-    skillsInstalled(names, ide) {
-        write(`  ${SYM.done} ${emerald(String(names.length))} agent skills installed ${muted(`for ${ide}`)}`);
-        for (const name of names) {
-            write(`    ${muted("·")} ${name}`);
-        }
-        writeToFile("skills_installed", "Skills installed", {
-            ide,
-            count: names.length,
-            names,
-        });
-    },
-    /** MCP config written */
-    mcpConfigured(ide, path) {
-        write(`  ${SYM.done} MCP server registered ${muted("→")} ${dim(path)}`);
-        write(`    ${muted(`${ide} will auto-connect to unerr intelligence`)}`);
-        writeToFile("mcp_configured", "MCP configured", { ide, path });
-    },
-    /** Background indexing started */
-    indexingStarted() {
-        write(`  ${SYM.step} Deep indexing ${muted("(tree-sitter AST analysis)")}`);
-        writeToFile("indexing_started", "Deep indexing started");
-    },
-    /** Session resume context */
-    sessionResumed(prevCalls, prevMinutes) {
-        write(`  ${SYM.done} Session resumed ${muted("— picking up where you left off")}`);
-        write(`    ${muted("previous:")} ${cyan(String(prevCalls))} tool calls ${muted("·")} ${cyan(String(prevMinutes))}min`);
-        writeToFile("session_resumed", "Session resumed", {
-            prevCalls,
-            prevMinutes,
-        });
-    },
-    /** Token flow event — real-time savings display in proxy mode */
-    tokenFlow(opts) {
-        const toolSlug = opts.tool ?? "shell";
-        const prefix = opts.pid && opts.pid !== process.pid
-            ? `${muted(`[exec:${opts.pid}]`)} `
-            : "";
-        write(`  ${SYM.step} ${prefix}Turn ${cyan(String(opts.turn))}: ${bold(toolSlug)} ${muted("—")} ${emerald(opts.tokensSaved.toLocaleString())} tokens saved ${muted(`(${opts.mechanism})`)}${opts.tokensDelivered > 0 ? `, ${cyan(opts.tokensDelivered.toLocaleString())} delivered` : ""}`);
-        writeToFile("token_flow", `${toolSlug}: ${opts.tokensSaved} saved (${opts.mechanism})`, {
-            turn: opts.turn,
-            tool: opts.tool,
-            mechanism: opts.mechanism,
-            tokens_saved: opts.tokensSaved,
-            tokens_delivered: opts.tokensDelivered,
-            session_total: opts.sessionTotal,
-            pid: opts.pid,
-        });
-    },
-    /** Token flow session total — periodic summary line */
-    tokenFlowTotal(saved, delivered, efficiency) {
-        write(`  ${SYM.bolt} Session: ${emerald(saved.toLocaleString())} saved ${muted("/")} ${cyan(delivered.toLocaleString())} delivered ${muted(`(${efficiency}% efficiency)`)}`);
-        writeToFile("token_flow_total", "Session token flow", {
-            tokens_saved: saved,
-            tokens_delivered: delivered,
-            efficiency_pct: efficiency,
-        });
-    },
-    /** Health card — visually rich architecture health display */
-    healthCard(health) {
-        const gradeColor = health.score >= 90
-            ? emerald
-            : health.score >= 70
-                ? cyan
-                : health.score >= 50
-                    ? amber
-                    : red;
-        const gradeBg = health.score >= 90
-            ? fgRgb(16, 185, 129) // deeper emerald
-            : health.score >= 70
-                ? fgRgb(6, 182, 212) // deeper cyan
-                : health.score >= 50
-                    ? fgRgb(245, 158, 11) // deeper amber
-                    : fgRgb(239, 68, 68); // deeper red
-        // ── Score bar (sub-character precision) ──
-        const BAR_WIDTH = 24;
-        const BLOCKS = [" ", "▏", "▎", "▍", "▌", "▋", "▊", "▉", "█"];
-        const fillWidth = (health.score / 100) * BAR_WIDTH;
-        const fullBlocks = Math.floor(fillWidth);
-        const partialIdx = Math.round((fillWidth - fullBlocks) * (BLOCKS.length - 1));
-        const emptyBlocks = BAR_WIDTH - fullBlocks - (partialIdx > 0 ? 1 : 0);
-        const bar = "█".repeat(fullBlocks) +
-            (partialIdx > 0 ? (BLOCKS[partialIdx] ?? "") : "") +
-            "░".repeat(Math.max(0, emptyBlocks));
-        write("");
-        write(`  ${dim("┌─────────────────────────────────────────────────────┐")}`);
-        write(`  ${dim("│")}  ${violet("◆")} ${bold("Architecture Health")}                            ${dim("│")}`);
-        write(`  ${dim("├─────────────────────────────────────────────────────┤")}`);
-        write(`  ${dim("│")}                                                     ${dim("│")}`);
-        write(`  ${dim("│")}   ${gradeColor(`${BOLD}${health.grade}${RESET}`)}  ${gradeBg}${bar}${RESET}  ${gradeColor(`${health.score}`)}${muted("/100")}          ${dim("│")}`);
-        write(`  ${dim("│")}                                                     ${dim("│")}`);
-        write(`  ${dim("├─────────────────────────────────────────────────────┤")}`);
-        // ── Metrics grid ──
-        const entityStr = health.totalEntities.toLocaleString();
-        const edgeStr = health.totalEdges.toLocaleString();
-        const connectivity = health.totalEntities > 0
-            ? (health.totalEdges / health.totalEntities).toFixed(1)
-            : "0";
-        write(`  ${dim("│")}  ${muted("Entities")}     ${cyan(entityStr.padEnd(8))} ${muted("Edges")}       ${cyan(edgeStr.padEnd(8))} ${dim("│")}`);
-        write(`  ${dim("│")}  ${muted("Connectivity")} ${cyan(connectivity.padEnd(8))} ${muted("Rules")}       ${violet(String(health.totalRules).padEnd(8))} ${dim("│")}`);
-        // ── Signals ──
-        write(`  ${dim("├─────────────────────────────────────────────────────┤")}`);
-        write(`  ${dim("│")}  ${muted("Signal")}                           ${muted("Status")}         ${dim("│")}`);
-        write(`  ${dim("│")}  ${dim("─────────────────────────────────────────────")}  ${dim("│")}`);
-        // Dead functions
-        const deadIcon = health.deadFunctionCount === 0
-            ? SYM.done
-            : health.deadFunctionCount > 20
-                ? SYM.fail
-                : SYM.warn;
-        const deadColor = health.deadFunctionCount === 0
-            ? emerald
-            : health.deadFunctionCount > 20
-                ? red
-                : amber;
-        write(`  ${dim("│")}  ${deadIcon} ${muted("Dead functions")}                  ${deadColor(String(health.deadFunctionCount).padEnd(4))}       ${dim("│")}`);
-        // Circular deps
-        const circCount = health.circularDeps?.length ?? 0;
-        const circIcon = circCount === 0 ? SYM.done : circCount > 5 ? SYM.fail : SYM.warn;
-        const circColor = circCount === 0 ? emerald : circCount > 5 ? red : amber;
-        write(`  ${dim("│")}  ${circIcon} ${muted("Circular dependencies")}           ${circColor(String(circCount).padEnd(4))}       ${dim("│")}`);
-        // Import depth
-        const depth = health.maxImportDepth ?? 0;
-        const depthIcon = depth <= 7 ? SYM.done : depth > 15 ? SYM.fail : SYM.warn;
-        const depthColor = depth <= 7 ? emerald : depth > 15 ? red : amber;
-        write(`  ${dim("│")}  ${depthIcon} ${muted("Max import chain")}                ${depthColor(String(depth).padEnd(4))}       ${dim("│")}`);
-        // Convention adherence
-        const adherence = health.conventionAdherence ?? 1;
-        const adherencePct = `${Math.round(adherence * 100)}%`;
-        const adhIcon = adherence >= 0.9 ? SYM.done : adherence >= 0.7 ? SYM.warn : SYM.fail;
-        const adhColor = adherence >= 0.9 ? emerald : adherence >= 0.7 ? amber : red;
-        write(`  ${dim("│")}  ${adhIcon} ${muted("Convention adherence")}            ${adhColor(adherencePct.padEnd(4))}       ${dim("│")}`);
-        // Drift impact
-        const drift = health.driftImpactScore ?? 0;
-        const driftIcon = drift === 0 ? SYM.done : drift > 10 ? SYM.fail : SYM.warn;
-        const driftColor = drift === 0 ? emerald : drift > 10 ? red : amber;
-        write(`  ${dim("│")}  ${driftIcon} ${muted("Drift in critical paths")}         ${driftColor(String(drift).padEnd(4))}       ${dim("│")}`);
-        // Orphan test files
-        const orphanCount = health.orphanTestFiles?.length ?? 0;
-        const orphanIcon = orphanCount === 0 ? SYM.done : orphanCount > 10 ? SYM.fail : SYM.warn;
-        const orphanColor = orphanCount === 0 ? emerald : orphanCount > 10 ? red : amber;
-        write(`  ${dim("│")}  ${orphanIcon} ${muted("Orphan test files")}               ${orphanColor(String(orphanCount).padEnd(4))}       ${dim("│")}`);
-        // ── High-risk entities (chokepoints) ──
-        if (health.highRiskEntities.length > 0) {
-            write(`  ${dim("├─────────────────────────────────────────────────────┤")}`);
-            write(`  ${dim("│")}  ${amber("⚠")} ${bold("Chokepoints")} ${muted("— changes here ripple widely")}      ${dim("│")}`);
-            for (const entity of health.highRiskEntities) {
-                const fanStr = `${entity.fan_in}↓ ${entity.fan_out}↑`;
-                const nameDisplay = entity.name.length > 24
-                    ? `${entity.name.slice(0, 22)}..`
-                    : entity.name;
-                write(`  ${dim("│")}    ${cyan(nameDisplay.padEnd(26))} ${amber(fanStr.padEnd(10))}     ${dim("│")}`);
-                const fileShort = entity.file_path.length > 40
-                    ? `...${entity.file_path.slice(-37)}`
-                    : entity.file_path;
-                write(`  ${dim("│")}    ${dim(fileShort.padEnd(43))}  ${dim("│")}`);
-            }
-        }
-        write(`  ${dim("└─────────────────────────────────────────────────────┘")}`);
-        write("");
-        writeToFile("health_card", "Architecture health", {
-            grade: health.grade,
-            score: health.score,
-            totalEntities: health.totalEntities,
-            totalEdges: health.totalEdges,
-            totalRules: health.totalRules,
-            deadFunctionCount: health.deadFunctionCount,
-            circularDeps: health.circularDeps?.length ?? 0,
-            maxImportDepth: health.maxImportDepth,
-            conventionAdherence: health.conventionAdherence,
-            driftImpactScore: health.driftImpactScore,
-            orphanTestFiles: health.orphanTestFiles?.length ?? 0,
-            highRiskCount: health.highRiskEntities.length,
-        });
-    },
-    /** MCP connection card — shows config snippet for manual agent setup */
-    mcpConnectionCard(configuredAgents, projectDir) {
-        write("");
-        write(`  ${dim("┌─────────────────────────────────────────────────────┐")}`);
-        write(`  ${dim("│")}  ${violet("⚡")} ${bold("MCP Connection")}                                 ${dim("│")}`);
-        write(`  ${dim("├─────────────────────────────────────────────────────┤")}`);
-        if (configuredAgents.length > 0) {
-            write(`  ${dim("│")}  ${emerald(SYM.done)} ${muted("Auto-configured:")} ${cyan(configuredAgents.join(", "))}    ${dim("│")}`);
-        }
-        write(`  ${dim("│")}                                                     ${dim("│")}`);
-        write(`  ${dim("│")}  ${muted("For any MCP-compatible agent, add to config:")}       ${dim("│")}`);
-        write(`  ${dim("│")}                                                     ${dim("│")}`);
-        write(`  ${dim("│")}  ${dim("{")}                                                  ${dim("│")}`);
-        write(`  ${dim("│")}    ${cyan('"mcpServers"')}: ${dim("{")}                                 ${dim("│")}`);
-        write(`  ${dim("│")}      ${cyan('"unerr"')}: ${dim("{")}                                    ${dim("│")}`);
-        write(`  ${dim("│")}        ${cyan('"command"')}: ${emerald('"unerr"')}${dim(",")}                          ${dim("│")}`);
-        write(`  ${dim("│")}        ${cyan('"args"')}: [${emerald('"--mcp"')}]                          ${dim("│")}`);
-        write(`  ${dim("│")}      ${dim("}")}                                                ${dim("│")}`);
-        write(`  ${dim("│")}    ${dim("}")}                                                  ${dim("│")}`);
-        write(`  ${dim("│")}  ${dim("}")}                                                    ${dim("│")}`);
-        write(`  ${dim("│")}                                                     ${dim("│")}`);
-        write(`  ${dim("│")}  ${muted("Add more:")} ${dim("unerr install <agent>")}                    ${dim("│")}`);
-        write(`  ${dim("└─────────────────────────────────────────────────────┘")}`);
-        write("");
-        writeToFile("mcp_connection_card", "MCP connection info", {
-            configuredAgents,
-            projectDir,
-        });
-    },
-    /** Layer 7 — web dashboard is listening (127.0.0.1, same process as proxy) */
-    dashboardReady(url) {
-        write(`  ${SYM.brain} ${bold("Dashboard")} ${muted("—")} ${cyan(url)}`);
-        write(`    ${muted("Tip:")} ${dim("unerr dashboard")} ${muted("opens this in your browser")}`);
-        writeToFile("dashboard_ready", "Dashboard ready", { url });
-    },
-    /**
-     * Buffer all subsequent startup-log writes until resume() is called.
-     * Used to keep interactive prompts (e.g. SCIP build-tool picker) free of
-     * stderr clutter from async events that complete while the prompt is on
-     * screen (Dashboard ready, etc.). Buffered lines flush on resume in order.
-     */
-    pause: pauseWrites,
-    /** Resume writes and flush anything buffered since pause(). */
-    resume: resumeWrites,
-    // ── Direct color exports for custom formatting ────────────────
-    fmt: { violet, cyan, emerald, amber, red, muted, bold, dim, brandBold },
-    sym: SYM,
-};