@unerr-ai/unerr 0.1.0 → 0.1.1

package/dist/__tests__/local-mode-stats.test.js

@@ -0,0 +1,273 @@
+/**
+ * Sprint L4 Tests: Statistical Proof Engine — LocalModeStats, shutdown summary, cumulative stats.
+ */
+import { mkdirSync, rmSync, writeFileSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createLocalModeStats, createSessionStats, formatLocalModeSessionStats, loadCumulativeLocalStats, persistCumulativeLocalStats, recordBlastRadius, recordCommunityContext, recordCorrectionInjection, recordEmbedding, recordGraphQuery, recordIndexingResult, recordLatency, recordSemanticSearch, recordToolCall, recordTruncationSavings, } from "../proxy/session-stats.js";
+// ── LocalModeStats Creation ─────────────────────────────────────
+describe("createLocalModeStats", () => {
+    it("initializes all counters to zero", () => {
+        const lm = createLocalModeStats();
+        expect(lm.filesIndexed).toBe(0);
+        expect(lm.entitiesExtracted).toBe(0);
+        expect(lm.edgesComputed).toBe(0);
+        expect(lm.indexingTimeMs).toBe(0);
+        expect(lm.communitiesDetected).toBe(0);
+        expect(lm.embeddingsComputed).toBe(0);
+        expect(lm.embeddingTimeMs).toBe(0);
+        expect(lm.semanticSearches).toBe(0);
+        expect(lm.tokensSavedByTruncation).toBe(0);
+        expect(lm.truncatedResponses).toBe(0);
+        expect(lm.correctionPatternsInjected).toBe(0);
+        expect(lm.communityContextsInjected).toBe(0);
+        expect(lm.blastRadiusComputations).toBe(0);
+        expect(lm.firewallBlockedCount).toBe(0);
+        expect(lm.graphQueriesByType).toEqual({});
+    });
+});
+// ── SessionStats with Local Mode ────────────────────────────────
+describe("createSessionStats with isLocalMode", () => {
+    it("creates localMode=null for standard mode", () => {
+        const stats = createSessionStats(false);
+        expect(stats.localMode).toBeNull();
+    });
+    it("creates localMode stats for local mode", () => {
+        const stats = createSessionStats(true);
+        expect(stats.localMode).not.toBeNull();
+        expect(stats.localMode?.filesIndexed).toBe(0);
+    });
+});
+// ── Recording Functions ─────────────────────────────────────────
+describe("LocalModeStats recording functions", () => {
+    let lm;
+    beforeEach(() => {
+        lm = createLocalModeStats();
+    });
+    it("recordGraphQuery tracks per-tool counts", () => {
+        recordGraphQuery(lm, "get_function");
+        recordGraphQuery(lm, "get_function");
+        recordGraphQuery(lm, "search_code");
+        recordGraphQuery(lm, "get_callers");
+        expect(lm.graphQueriesByType.get_function).toBe(2);
+        expect(lm.graphQueriesByType.search_code).toBe(1);
+        expect(lm.graphQueriesByType.get_callers).toBe(1);
+    });
+    it("recordTruncationSavings accumulates token savings", () => {
+        recordTruncationSavings(lm, 10000, 3000); // saved 7000
+        recordTruncationSavings(lm, 5000, 2000); // saved 3000
+        recordTruncationSavings(lm, 1000, 1500); // no savings (used > full)
+        expect(lm.tokensSavedByTruncation).toBe(10000);
+        expect(lm.truncatedResponses).toBe(2);
+    });
+    it("recordIndexingResult sets all indexing fields", () => {
+        recordIndexingResult(lm, {
+            fileCount: 500,
+            entityCount: 2000,
+            edgeCount: 5000,
+            elapsedMs: 3200,
+            communityCount: 25,
+        });
+        expect(lm.filesIndexed).toBe(500);
+        expect(lm.entitiesExtracted).toBe(2000);
+        expect(lm.edgesComputed).toBe(5000);
+        expect(lm.indexingTimeMs).toBe(3200);
+        expect(lm.communitiesDetected).toBe(25);
+    });
+    it("recordBlastRadius increments counter", () => {
+        recordBlastRadius(lm);
+        recordBlastRadius(lm);
+        expect(lm.blastRadiusComputations).toBe(2);
+    });
+    it("recordCorrectionInjection increments counter", () => {
+        recordCorrectionInjection(lm);
+        recordCorrectionInjection(lm);
+        recordCorrectionInjection(lm);
+        expect(lm.correctionPatternsInjected).toBe(3);
+    });
+    it("recordCommunityContext increments counter", () => {
+        recordCommunityContext(lm);
+        expect(lm.communityContextsInjected).toBe(1);
+    });
+    it("recordEmbedding accumulates counts and time", () => {
+        recordEmbedding(lm, 100, 500);
+        recordEmbedding(lm, 50, 300);
+        expect(lm.embeddingsComputed).toBe(150);
+        expect(lm.embeddingTimeMs).toBe(800);
+    });
+    it("recordSemanticSearch increments counter", () => {
+        recordSemanticSearch(lm);
+        recordSemanticSearch(lm);
+        expect(lm.semanticSearches).toBe(2);
+    });
+});
+// ── Local Mode Shutdown Summary ─────────────────────────────────
+describe("formatLocalModeSessionStats", () => {
+    function makeStats() {
+        const stats = createSessionStats(true);
+        // Simulate a session with activity
+        for (let i = 0; i < 50; i++) {
+            recordToolCall(stats);
+            recordLatency(stats.latency, 2 + Math.random() * 3);
+        }
+        stats.violationsCaught = 3;
+        stats.riskWarningsIssued = 1;
+        stats.events.chokepointWarningsIssued = 2;
+        const lm = stats.localMode;
+        recordGraphQuery(lm, "get_function");
+        recordGraphQuery(lm, "get_function");
+        recordGraphQuery(lm, "get_class");
+        recordGraphQuery(lm, "search_code");
+        recordGraphQuery(lm, "get_callers");
+        recordBlastRadius(lm);
+        recordBlastRadius(lm);
+        recordTruncationSavings(lm, 10000, 3000);
+        recordCorrectionInjection(lm);
+        return stats;
+    }
+    it("returns null for zero tool calls", () => {
+        const stats = createSessionStats(true);
+        expect(formatLocalModeSessionStats(stats)).toBeNull();
+    });
+    it("falls back to standard format when localMode is null", () => {
+        const stats = createSessionStats(false);
+        recordToolCall(stats);
+        const result = formatLocalModeSessionStats(stats);
+        // Should use formatSessionStats (standard mode output)
+        expect(result).toContain("unerr session");
+    });
+    it("renders Local Mode session summary header", () => {
+        const result = formatLocalModeSessionStats(makeStats());
+        expect(result).toContain("Local Mode Session Summary");
+    });
+    it("includes MCP tool call counts", () => {
+        const result = formatLocalModeSessionStats(makeStats());
+        expect(result).toContain("50 (all local)");
+    });
+    it("includes latency percentiles", () => {
+        const result = formatLocalModeSessionStats(makeStats());
+        expect(result).toContain("(p50)");
+        expect(result).toContain("(p95)");
+    });
+    it("includes graph intelligence section", () => {
+        const result = formatLocalModeSessionStats(makeStats());
+        expect(result).toContain("Graph Intelligence:");
+        expect(result).toContain("Entity lookups:");
+        expect(result).toContain("Blast radius:");
+        expect(result).toContain("Search queries:");
+        expect(result).toContain("Callers/callees:");
+    });
+    it("includes token discipline section", () => {
+        const result = formatLocalModeSessionStats(makeStats());
+        expect(result).toContain("Token Discipline:");
+        expect(result).toContain("Tokens saved:");
+        expect(result).toContain("Responses truncated:");
+    });
+    it("includes safety catches section", () => {
+        const result = formatLocalModeSessionStats(makeStats());
+        expect(result).toContain("Safety Catches:");
+        expect(result).toContain("Violations caught:");
+        expect(result).toContain("Corrections applied:");
+    });
+    it("includes network isolation section", () => {
+        const result = formatLocalModeSessionStats(makeStats());
+        expect(result).toContain("Network Isolation:");
+        expect(result).toContain("0 (firewall sealed)");
+    });
+    it("omits empty sections", () => {
+        const stats = createSessionStats(true);
+        recordToolCall(stats);
+        recordLatency(stats.latency, 2);
+        const result = formatLocalModeSessionStats(stats);
+        expect(result).not.toContain("Graph Intelligence:");
+        expect(result).not.toContain("Token Discipline:");
+        expect(result).not.toContain("Safety Catches:");
+        expect(result).not.toContain("Semantic Intelligence:");
+        // Network Isolation always shown
+        expect(result).toContain("Network Isolation:");
+    });
+    it("includes semantic intelligence when embeddings computed", () => {
+        const stats = makeStats();
+        recordEmbedding(stats.localMode, 100, 500);
+        recordSemanticSearch(stats.localMode);
+        const result = formatLocalModeSessionStats(stats);
+        expect(result).toContain("Semantic Intelligence:");
+        expect(result).toContain("Embeddings computed:");
+        expect(result).toContain("Semantic searches:");
+    });
+});
+// ── Cumulative Local Stats Persistence ──────────────────────────
+describe("CumulativeLocalStats", () => {
+    let tmpDir;
+    const originalHome = process.env.HOME;
+    beforeEach(() => {
+        tmpDir = join(tmpdir(), `unerr-cumul-test-${Date.now()}`);
+        mkdirSync(join(tmpDir, ".unerr"), { recursive: true });
+        process.env.HOME = tmpDir;
+    });
+    afterEach(() => {
+        process.env.HOME = originalHome;
+        try {
+            rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch {
+            /* ignore */
+        }
+    });
+    it("returns empty stats when no file exists", () => {
+        const cls = loadCumulativeLocalStats();
+        expect(cls.totalSessions).toBe(0);
+        expect(cls.totalToolCalls).toBe(0);
+        expect(cls.totalTokensSaved).toBe(0);
+    });
+    it("persists and loads stats across calls", () => {
+        const stats = createSessionStats(true);
+        for (let i = 0; i < 10; i++)
+            recordToolCall(stats);
+        stats.violationsCaught = 2;
+        recordTruncationSavings(stats.localMode, 5000, 1000);
+        recordCorrectionInjection(stats.localMode);
+        const result = persistCumulativeLocalStats(stats);
+        expect(result.totalSessions).toBe(1);
+        expect(result.totalToolCalls).toBe(10);
+        expect(result.totalTokensSaved).toBe(4000);
+        expect(result.totalViolationsCaught).toBe(2);
+        expect(result.totalCorrectionsApplied).toBe(1);
+        // Second session accumulates
+        const stats2 = createSessionStats(true);
+        for (let i = 0; i < 5; i++)
+            recordToolCall(stats2);
+        stats2.violationsCaught = 1;
+        recordTruncationSavings(stats2.localMode, 3000, 1000);
+        const result2 = persistCumulativeLocalStats(stats2);
+        expect(result2.totalSessions).toBe(2);
+        expect(result2.totalToolCalls).toBe(15);
+        expect(result2.totalTokensSaved).toBe(6000);
+        expect(result2.totalViolationsCaught).toBe(3);
+    });
+    it("resets on new week", () => {
+        // Write stats with a stale week
+        const staleStats = {
+            weekStartDate: "2020-01-06",
+            totalSessions: 100,
+            totalToolCalls: 5000,
+            totalTokensSaved: 999999,
+            totalViolationsCaught: 50,
+            totalCorrectionsApplied: 10,
+            totalFilesIndexed: 200,
+            totalSemanticSearches: 30,
+            avgLatencyP50: 2.5,
+        };
+        const filePath = join(tmpDir, ".unerr", "cumulative-local-stats.json");
+        writeFileSync(filePath, JSON.stringify(staleStats));
+        const loaded = loadCumulativeLocalStats();
+        expect(loaded.totalSessions).toBe(0);
+        expect(loaded.totalToolCalls).toBe(0);
+    });
+    it("returns existing cumulative when localMode is null", () => {
+        const stats = createSessionStats(false); // standard mode
+        const result = persistCumulativeLocalStats(stats);
+        expect(result.totalSessions).toBe(0);
+    });
+});

package/dist/__tests__/local-mode-tui.test.js

@@ -0,0 +1,343 @@
+/**
+ * Tests for Sprint L7 — Local Mode TUI components.
+ *
+ * Covers:
+ *   - StartupDisplay Local Mode variant (Three-Act structure)
+ *   - SessionSummaryCard Local Mode variant (proof-of-value shutdown)
+ *   - StartupRenderer local mode methods
+ *   - Latency advantage injection
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { render } from "ink-testing-library";
+import React from "react";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { SessionSummaryCard } from "../components/SessionSummaryCard.js";
+import { StartupDisplay, } from "../components/StartupDisplay.js";
+import { ThemeProvider } from "../components/Theme.js";
+import { createLatencyTracker, createLocalModeStats, createSessionEvents, recordLatencyAdvantage, } from "../proxy/session-stats.js";
+function renderWithTheme(el) {
+    return render(React.createElement(ThemeProvider, null, el));
+}
+function renderStartup(state) {
+    return renderWithTheme(React.createElement(StartupDisplay, { state }));
+}
+function makeLocalStats() {
+    return {
+        toolCallsLocal: 25,
+        estimatedTokensSaved: 0,
+        violationsCaught: 2,
+        riskWarningsIssued: 1,
+        sessionStartedAt: Date.now() - 300_000, // 5 min ago
+        latency: createLatencyTracker(),
+        events: {
+            ...createSessionEvents(),
+            conventionViolationsCaught: 2,
+            chokepointWarningsIssued: 1,
+        },
+        isResumedSession: false,
+        previousSession: null,
+        localMode: {
+            ...createLocalModeStats(),
+            blastRadiusComputations: 3,
+            communityContextsInjected: 5,
+            correctionPatternsInjected: 2,
+            tokensSavedByTruncation: 12000,
+            truncatedResponses: 4,
+            semanticSearches: 7,
+            cumulativeLatencySavedMs: 4850,
+            firewallBlockedCount: 0,
+        },
+    };
+}
+// ── StartupDisplay Local Mode ─────────────────────────────────────
+describe("StartupDisplay Local Mode (L7.1)", () => {
+    it("renders locally computed health title instead of First Look", () => {
+        const { lastFrame } = renderStartup({
+            steps: [],
+            firstBoot: false,
+            ready: false,
+            localMode: true,
+            health: {
+                grade: "B",
+                totalEntities: 500,
+                totalEdges: 300,
+                totalRules: 8,
+                deadFunctionCount: 5,
+                highRiskEntities: [],
+                score: 78,
+            },
+        });
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("Health (locally computed)");
+        expect(frame).not.toContain("First Look");
+    });
+    it("shows tool count and zero cloud deps in Act 3", () => {
+        const { lastFrame } = renderStartup({
+            steps: [],
+            firstBoot: false,
+            ready: true,
+            localMode: true,
+            toolCount: 11,
+        });
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("11 tools ready");
+        expect(frame).toContain("offline-capable");
+    });
+    it("shows agent invitation with entity name in Local Mode", () => {
+        const { lastFrame } = renderStartup({
+            steps: [],
+            firstBoot: false,
+            ready: true,
+            localMode: true,
+            invitationEntity: "processPayment",
+        });
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("What depends on processPayment?");
+    });
+    it("shows default invitation when no entity", () => {
+        const { lastFrame } = renderStartup({
+            steps: [],
+            firstBoot: false,
+            ready: true,
+            localMode: true,
+        });
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("Show me the highest-impact functions in this codebase");
+    });
+    it("never shows deep link in Local Mode", () => {
+        const { lastFrame } = renderStartup({
+            steps: [],
+            firstBoot: false,
+            ready: true,
+            localMode: true,
+            deepLink: "https://app.unerr.dev/r/repo_123",
+        });
+        // Deep link is in state but Local Mode Act 3 doesn't render it
+        const frame = lastFrame() ?? "";
+        expect(frame).not.toContain("Health details");
+        expect(frame).not.toContain("Proxy ready. Serving MCP on stdio");
+    });
+    it("does not show standard Act 3 when in local mode", () => {
+        const { lastFrame } = renderStartup({
+            steps: [],
+            firstBoot: false,
+            ready: true,
+            localMode: true,
+            proxyMode: "full",
+        });
+        const frame = lastFrame() ?? "";
+        expect(frame).not.toContain("Proxy ready");
+    });
+});
+// ── SessionSummaryCard Local Mode ─────────────────────────────────
+describe("SessionSummaryCard Local Mode (L7.2)", () => {
+    it("renders all-local tool calls with 100% progress bar", () => {
+        const stats = makeLocalStats();
+        const { lastFrame } = renderWithTheme(React.createElement(SessionSummaryCard, { stats }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("25 (all local)");
+        expect(frame).toContain("Local rate");
+    });
+    it("shows caught section when violations exist", () => {
+        const stats = makeLocalStats();
+        const { lastFrame } = renderWithTheme(React.createElement(SessionSummaryCard, { stats }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("Caught:");
+        expect(frame).toContain("2 convention violations before commit");
+        expect(frame).toContain("1 chokepoint modification");
+    });
+    it("shows Intelligence Applied section", () => {
+        const stats = makeLocalStats();
+        const { lastFrame } = renderWithTheme(React.createElement(SessionSummaryCard, { stats }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("Intelligence Applied:");
+        expect(frame).toContain("3 blast radius computations");
+        expect(frame).toContain("5 community contexts injected");
+        expect(frame).toContain("2 correction patterns applied");
+    });
+    it("shows Token Discipline section", () => {
+        const stats = makeLocalStats();
+        const { lastFrame } = renderWithTheme(React.createElement(SessionSummaryCard, { stats }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("Token Discipline:");
+        expect(frame).toContain("12.0k tokens saved via smart truncation");
+        expect(frame).toContain("4 responses budget-trimmed");
+    });
+    it("shows Semantic Intelligence when BYO-LLM used", () => {
+        const stats = makeLocalStats();
+        const { lastFrame } = renderWithTheme(React.createElement(SessionSummaryCard, { stats }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("Semantic Intelligence:");
+        expect(frame).toContain("7 queries via local embeddings");
+    });
+    it("shows Network Isolation section with firewall sealed", () => {
+        const stats = makeLocalStats();
+        const { lastFrame } = renderWithTheme(React.createElement(SessionSummaryCard, { stats }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("Network Isolation:");
+        expect(frame).toContain("Outbound: 0 calls (firewall sealed)");
+        expect(frame).toContain("Blocked attempts: 0 (clean)");
+    });
+    it("shows latency advantage when accumulated and latency samples exist", () => {
+        const stats = makeLocalStats();
+        // Populate latency samples so localP is non-null
+        for (let i = 0; i < 10; i++) {
+            stats.latency.localSamples[i] = 3.0;
+        }
+        stats.latency.localCursor = 10;
+        stats.latency.localTotalSamples = 10;
+        const { lastFrame } = renderWithTheme(React.createElement(SessionSummaryCard, { stats }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("4.8s saved vs remote");
+    });
+    it("never shows dollar savings in Local Mode (TL-19)", () => {
+        const stats = makeLocalStats();
+        const { lastFrame } = renderWithTheme(React.createElement(SessionSummaryCard, { stats }));
+        const frame = lastFrame() ?? "";
+        expect(frame).not.toContain("$");
+        expect(frame).not.toContain("Saved:");
+    });
+    it("never shows deep link in Local Mode", () => {
+        const stats = makeLocalStats();
+        const { lastFrame } = renderWithTheme(React.createElement(SessionSummaryCard, {
+            stats,
+            deepLink: "https://app.unerr.dev/r/repo_123",
+        }));
+        const frame = lastFrame() ?? "";
+        expect(frame).not.toContain("Session →");
+        expect(frame).not.toContain("unerr.dev");
+    });
+    it("renders compact line for short sessions (<=10 calls)", () => {
+        const stats = makeLocalStats();
+        stats.toolCallsLocal = 5;
+        const { lastFrame } = renderWithTheme(React.createElement(SessionSummaryCard, { stats }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("unerr local session:");
+        expect(frame).toContain("5 tool calls (all local)");
+    });
+    it("renders empty box for zero tool calls", () => {
+        const stats = makeLocalStats();
+        stats.toolCallsLocal = 0;
+        const { lastFrame } = renderWithTheme(React.createElement(SessionSummaryCard, { stats }));
+        const frame = lastFrame() ?? "";
+        // Should be basically empty
+        expect(frame).not.toContain("Tool calls");
+        expect(frame).not.toContain("unerr local session");
+    });
+    it("shows cumulative This week line when >1 session", () => {
+        const stats = makeLocalStats();
+        const { lastFrame } = renderWithTheme(React.createElement(SessionSummaryCard, {
+            stats,
+            cumulativeLocal: {
+                weekStartDate: "2026-04-13",
+                totalSessions: 5,
+                totalToolCalls: 120,
+                totalTokensSaved: 45000,
+                totalViolationsCaught: 8,
+                totalCorrectionsApplied: 3,
+                totalFilesIndexed: 200,
+                totalSemanticSearches: 15,
+                avgLatencyP50: 2.1,
+            },
+        }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("This week:");
+        expect(frame).toContain("5 sessions");
+        expect(frame).toContain("45k tokens saved");
+        expect(frame).toContain("8 caught");
+    });
+});
+// ── Latency Advantage ─────────────────────────────────────────────
+describe("Latency advantage (L7.3)", () => {
+    it("recordLatencyAdvantage accumulates correctly", () => {
+        const lm = createLocalModeStats();
+        recordLatencyAdvantage(lm, 195); // 5ms actual → 195ms saved
+        recordLatencyAdvantage(lm, 198); // 2ms actual → 198ms saved
+        expect(lm.cumulativeLatencySavedMs).toBe(393);
+    });
+    it("cumulativeLatencySavedMs starts at 0", () => {
+        const lm = createLocalModeStats();
+        expect(lm.cumulativeLatencySavedMs).toBe(0);
+    });
+});
+// ── StartupRenderer Local Mode ────────────────────────────────────
+describe("StartupRenderer Local Mode (L7.4)", () => {
+    let tmpDir;
+    let origCwd;
+    beforeEach(() => {
+        tmpDir = path.join(os.tmpdir(), `unerr-l7-test-${Date.now()}`);
+        fs.mkdirSync(path.join(tmpDir, ".unerr", "state"), { recursive: true });
+        origCwd = process.cwd();
+        process.chdir(tmpDir);
+    });
+    afterEach(() => {
+        process.chdir(origCwd);
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("setLocalMode suppresses deep link in setHealth", async () => {
+        const { StartupRenderer } = await import("../proxy/startup-renderer.js");
+        const renderer = new StartupRenderer();
+        renderer.setLocalMode(true);
+        renderer.setHealth({
+            grade: "B",
+            totalEntities: 100,
+            totalEdges: 50,
+            totalRules: 5,
+            deadFunctionCount: 0,
+            highRiskEntities: [],
+            score: 80,
+        }, "repo_test");
+        // Access internal state to verify no deep link
+        // @ts-expect-error accessing private for test
+        expect(renderer.state.deepLink).toBeUndefined();
+        // @ts-expect-error accessing private for test
+        expect(renderer.state.localMode).toBe(true);
+    });
+    it("setLocalMode suppresses deep link in setReady", async () => {
+        const { StartupRenderer } = await import("../proxy/startup-renderer.js");
+        const renderer = new StartupRenderer();
+        renderer.setLocalMode(true);
+        // @ts-expect-error accessing private for test
+        renderer.repoId = "repo_test";
+        renderer.setReady("local");
+        // @ts-expect-error accessing private for test
+        expect(renderer.state.deepLink).toBeUndefined();
+    });
+    it("setToolCount sets the tool count", async () => {
+        const { StartupRenderer } = await import("../proxy/startup-renderer.js");
+        const renderer = new StartupRenderer();
+        renderer.setToolCount(11);
+        // @ts-expect-error accessing private for test
+        expect(renderer.state.toolCount).toBe(11);
+    });
+    it("setByoLlmStatus sets BYO-LLM fields", async () => {
+        const { StartupRenderer } = await import("../proxy/startup-renderer.js");
+        const renderer = new StartupRenderer();
+        renderer.setByoLlmStatus("connected", "ollama", "nomic-embed-text");
+        // @ts-expect-error accessing private for test
+        expect(renderer.state.byoLlmStatus).toBe("connected");
+        // @ts-expect-error accessing private for test
+        expect(renderer.state.byoLlmProvider).toBe("ollama");
+        // @ts-expect-error accessing private for test
+        expect(renderer.state.byoLlmModel).toBe("nomic-embed-text");
+    });
+    it("setLocalIndexStats sets indexing stats", async () => {
+        const { StartupRenderer } = await import("../proxy/startup-renderer.js");
+        const renderer = new StartupRenderer();
+        renderer.setLocalIndexStats({
+            fileCount: 100,
+            entityCount: 500,
+            edgeCount: 300,
+            indexingTimeMs: 1200,
+            communityCount: 12,
+            conventionCount: 8,
+            ruleCount: 5,
+        });
+        // @ts-expect-error accessing private for test
+        expect(renderer.state.localIndexStats?.fileCount).toBe(100);
+        // @ts-expect-error accessing private for test
+        expect(renderer.state.localIndexStats?.entityCount).toBe(500);
+    });
+});