pi-mega-compact 0.11.3 → 0.11.5

package/dist/extensions/dashboard-server-s32.test.js

@@ -1,181 +0,0 @@
-/**
- * dashboard-server.test.ts — S32 game-state API + settings strip tests.
- *
- * GET/PUT /api/game-state round-trips the game_state SQLite row through the
- * real server subprocess (spawn + waitFor + fetch), and the HTML template
- * carries the data-theme attribute + settings strip + theme CSS-var blocks.
- */
-import { test, describe } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { spawn } from "node:child_process";
-import { dashboardHtml } from "./dashboard-server/html.js";
-import { setGameState, getGameState } from "../src/store/sqlite.js";
-const SERVER_ENTRY = new URL("./dashboard-server.js", import.meta.url).pathname;
-function waitFor(cond, timeoutMs = 6000) {
-    const start = Date.now();
-    return new Promise((resolve, reject) => {
-        const tick = async () => {
-            if (await cond())
-                return resolve();
-            if (Date.now() - start > timeoutMs)
-                return reject(new Error("timeout"));
-            setTimeout(tick, 50);
-        };
-        tick();
-    });
-}
-function freshDir(prefix) {
-    return mkdtempSync(join(tmpdir(), prefix));
-}
-async function withServer(port, dir, fn) {
-    process.env.MEGACOMPACT_DASHBOARD_PORT = port;
-    const child = spawn(process.execPath, [SERVER_ENTRY, dir], { stdio: "ignore" });
-    try {
-        await waitFor(async () => {
-            try {
-                const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
-                const res = await fetch(`http://localhost:${raw.port}/api/version`);
-                return res.ok;
-            }
-            catch {
-                return false;
-            }
-        });
-        const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
-        return await fn(raw.port);
-    }
-    finally {
-        child.kill("SIGTERM");
-        delete process.env.MEGACOMPACT_DASHBOARD_PORT;
-        rmSync(dir, { recursive: true, force: true });
-    }
-}
-describe("S32 /api/game-state", () => {
-    test("GET returns the current game_state row (seeded via setGameState)", async () => {
-        const dir = freshDir("dash-gs-get-");
-        setGameState({ game_mode_on: true, theme: "retro", tui_display_mode: "minimal" }, dir);
-        await withServer("19330", dir, async (port) => {
-            const gs = (await fetch(`http://localhost:${port}/api/game-state`).then((r) => r.json()));
-            assert.equal(gs.game_mode_on, true);
-            assert.equal(gs.theme, "retro");
-            assert.equal(gs.tui_display_mode, "minimal");
-        });
-    });
-    test("PUT {theme:'retro'} -> 200 and getGameState(dir).theme === 'retro'", async () => {
-        const dir = freshDir("dash-gs-theme-");
-        await withServer("19331", dir, async (port) => {
-            const res = await fetch(`http://localhost:${port}/api/game-state`, {
-                method: "PUT",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ theme: "retro" }),
-            });
-            assert.equal(res.status, 200);
-            const body = (await res.json());
-            assert.equal(body.theme, "retro");
-            // And the authoritative DB read reflects the write.
-            assert.equal(getGameState(dir).theme, "retro");
-        });
-    });
-    test("PUT invalid theme 'bogus' -> 400 and row unchanged", async () => {
-        const dir = freshDir("dash-gs-invalid-");
-        setGameState({ theme: "orange-bold" }, dir);
-        const before = getGameState(dir).theme;
-        await withServer("19332", dir, async (port) => {
-            const res = await fetch(`http://localhost:${port}/api/game-state`, {
-                method: "PUT",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ theme: "bogus" }),
-            });
-            assert.equal(res.status, 400);
-        });
-        assert.equal(getGameState(dir).theme, before, "row unchanged after invalid PUT");
-    });
-    test("PUT body 'null' (valid-but-non-object JSON) -> 400, server stays up (audit P1)", async () => {
-        const dir = freshDir("dash-gs-nullobj-");
-        setGameState({ theme: "amber-mono" }, dir);
-        const before = getGameState(dir).theme;
-        await withServer("19335", dir, async (port) => {
-            // A valid-JSON-but-non-object body must NOT crash the detached server
-            // (audit P1: unhandled TypeError on patch.game_mode_on deref).
-            const res = await fetch(`http://localhost:${port}/api/game-state`, {
-                method: "PUT",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify(null),
-            });
-            assert.equal(res.status, 400, "non-object JSON -> 400, not a crash");
-            const body = (await res.json());
-            assert.equal(body.error, "invalid_patch_object");
-            // Server must still be up — a follow-up GET must succeed.
-            const follow = await fetch(`http://localhost:${port}/api/game-state`);
-            assert.equal(follow.status, 200, "server survived the non-object PUT");
-        });
-        assert.equal(getGameState(dir).theme, before, "row unchanged after non-object PUT");
-    });
-    test("PUT body '[]' (array) -> 400, server stays up", async () => {
-        const dir = freshDir("dash-gs-arr-");
-        await withServer("19336", dir, async (port) => {
-            const res = await fetch(`http://localhost:${port}/api/game-state`, {
-                method: "PUT",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify([]),
-            });
-            assert.equal(res.status, 400);
-            const follow = await fetch(`http://localhost:${port}/api/game-state`);
-            assert.equal(follow.status, 200, "server survived the array PUT");
-        });
-    });
-    test("PUT {tui_display_mode:'minimal'} round-trips", async () => {
-        const dir = freshDir("dash-gs-tui-");
-        await withServer("19333", dir, async (port) => {
-            const res = await fetch(`http://localhost:${port}/api/game-state`, {
-                method: "PUT",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ tui_display_mode: "minimal" }),
-            });
-            assert.equal(res.status, 200);
-            const body = (await res.json());
-            assert.equal(body.tui_display_mode, "minimal");
-            assert.equal(getGameState(dir).tui_display_mode, "minimal");
-        });
-    });
-    test("PUT {game_mode_on:true} round-trips", async () => {
-        const dir = freshDir("dash-gs-mode-");
-        await withServer("19334", dir, async (port) => {
-            const res = await fetch(`http://localhost:${port}/api/game-state`, {
-                method: "PUT",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ game_mode_on: true }),
-            });
-            assert.equal(res.status, 200);
-            const body = (await res.json());
-            assert.equal(body.game_mode_on, true);
-            assert.equal(getGameState(dir).game_mode_on, true);
-        });
-    });
-});
-describe("S32 dashboard HTML skin", () => {
-    test("carries data-theme on <html> + settings strip + theme CSS-var blocks", () => {
-        const html = dashboardHtml("custom");
-        // default transparent theme attribute on <html>
-        assert.match(html, /<html lang="en" data-theme="transparent">/);
-        // settings strip with the three controls
-        assert.match(html, /<div class="settings-strip">/);
-        assert.match(html, /id="set-game-mode"/);
-        assert.match(html, /id="set-theme"/);
-        assert.match(html, /id="set-tui-mode"/);
-        // all 6 theme ids appear as :root[data-theme="<id>"] override blocks
-        for (const id of ["transparent", "retro", "orange-bold", "cyan-neon", "amber-mono", "grayscale"]) {
-            assert.ok(html.includes(`:root[data-theme="${id}"]{`), `${id} data-theme block present`);
-        }
-        // core CSS vars defined in the base :root
-        assert.match(html, /--bg: #0d1117;/);
-        assert.match(html, /--fg: #c9d1d9;/);
-        assert.match(html, /--accent: #3fb950;/);
-        assert.match(html, /--mega: #f0883e;/);
-        // body uses the themed var (not a hardcoded hex)
-        assert.match(html, /body\s*\{[^}]*background: var\(--bg\)/);
-    });
-});

package/dist/extensions/dashboard-server.test.js

@@ -1,339 +0,0 @@
-/**
- * dashboard-server.test.ts — unit tests for the standalone HTTP dashboard server.
- *
- * Tests the core logic (snapshot building, API responses) without requiring
- * a live pi session or model.
- */
-import { test, describe } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, writeFileSync, readFileSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { spawn } from "node:child_process";
-// ---------------------------------------------------------------------------
-// helpers
-// ---------------------------------------------------------------------------
-function tmpDir() {
-    return mkdtempSync(join(tmpdir(), "dashboard-test-"));
-}
-function writeSnapshot(dir, data) {
-    writeFileSync(join(dir, "snapshot.json"), JSON.stringify(data, null, 2));
-}
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-describe("snapshot.json reading", () => {
-    test("returns valid snapshot when file exists", () => {
-        const dir = tmpDir();
-        const snapshot = {
-            updatedAt: new Date().toISOString(),
-            tier: "medium",
-            version: 1,
-            config: { activeTier: "medium" },
-            session: { id: "test-123", state: "running", persistedThisSession: true },
-            context: { tokens: 50000, percent: 50, contextWindow: 100000 },
-            trigger: { armed: true, ready: false, currentTokens: 50000, thresholdTokens: 100000 },
-            store: { checkpointCount: 3, totalTokenEstimate: 15000 },
-        };
-        writeSnapshot(dir, snapshot);
-        const content = readFileSync(join(dir, "snapshot.json"), "utf-8");
-        const parsed = JSON.parse(content);
-        assert.equal(parsed.tier, "medium");
-        assert.equal(parsed.session.id, "test-123");
-        assert.equal(parsed.context.percent, 50);
-        assert.equal(parsed.store.checkpointCount, 3);
-        rmSync(dir, { recursive: true });
-    });
-    test("handles missing snapshot.json gracefully", () => {
-        const dir = tmpDir();
-        const snapshotPath = join(dir, "snapshot.json");
-        assert.equal(existsSync(snapshotPath), false);
-        rmSync(dir, { recursive: true });
-    });
-});
-describe("dashboard.json (compact snapshot)", () => {
-    test("round-trips correctly", () => {
-        const dir = tmpDir();
-        const data = {
-            updatedAt: "2025-01-01T00:00:00.000Z",
-            tier: "mega",
-            version: 1,
-            config: { activeTier: "mega", thresholdTokens: 10000000 },
-            session: { id: "abc", state: "running", persistedThisSession: false },
-            context: { tokens: null, percent: null, contextWindow: 200000 },
-            trigger: { armed: false, ready: false, currentTokens: null, thresholdTokens: 10000000 },
-            store: { checkpointCount: 0, totalTokenEstimate: 0 },
-        };
-        writeFileSync(join(dir, "dashboard.json"), JSON.stringify(data));
-        const content = readFileSync(join(dir, "dashboard.json"), "utf-8");
-        const parsed = JSON.parse(content);
-        assert.equal(parsed.tier, "mega");
-        assert.equal(parsed.config.thresholdTokens, 10000000);
-        assert.equal(parsed.context.tokens, null);
-        rmSync(dir, { recursive: true });
-    });
-});
-describe("events.log (JSONL)", () => {
-    test("parses multiple JSONL lines", () => {
-        const dir = tmpDir();
-        const events = [
-            { ts: "2025-01-01T00:00:00.000Z", type: "compact_start", trigger: "auto", tier: "medium", sessionId: "s1" },
-            { ts: "2025-01-01T00:00:01.000Z", type: "compact_end", trigger: "auto", durationMs: 1500, mode: "mega", fromTokens: 100000, toTokens: 5000 },
-            { ts: "2025-01-01T00:00:02.000Z", type: "checkpoint_persisted", checkpointId: "chk_1", totalCheckpoints: 1 },
-        ];
-        writeFileSync(join(dir, "events.log"), events.map((e) => JSON.stringify(e)).join("\n") + "\n");
-        const lines = readFileSync(join(dir, "events.log"), "utf-8").trim().split("\n");
-        assert.equal(lines.length, 3);
-        const parsed = lines.map((l) => JSON.parse(l));
-        assert.equal(parsed[0].type, "compact_start");
-        assert.equal(parsed[1].durationMs, 1500);
-        assert.equal(parsed[2].checkpointId, "chk_1");
-        rmSync(dir, { recursive: true });
-    });
-    test("ignores empty lines", () => {
-        const dir = tmpDir();
-        writeFileSync(join(dir, "events.log"), '{"type":"test"}\n\n\n{"type":"test2"}\n');
-        const lines = readFileSync(join(dir, "events.log"), "utf-8").trim().split("\n").filter(Boolean);
-        assert.equal(lines.length, 2);
-        rmSync(dir, { recursive: true });
-    });
-});
-describe("port.pid file", () => {
-    test("round-trips port and pid", () => {
-        const dir = tmpDir();
-        const info = { port: 3847, pid: 12345 };
-        writeFileSync(join(dir, "port.pid"), JSON.stringify(info));
-        const content = readFileSync(join(dir, "port.pid"), "utf-8");
-        const parsed = JSON.parse(content);
-        assert.equal(parsed.port, 3847);
-        assert.equal(parsed.pid, 12345);
-        rmSync(dir, { recursive: true });
-    });
-});
-// ---------------------------------------------------------------------------
-// Multi-repo dashboard (S19 / Phase 5b) — launch the real server subprocess,
-// seed the machine-wide repo_registry, and assert /api/index returns every repo
-// plus the aggregate summary the Summary + All-repos tabs render.
-// ---------------------------------------------------------------------------
-describe("multi-repo /api/index (S19)", () => {
-    test("lists all repos from the global index with an aggregate summary", async () => {
-        const dir = mkdtempSync(join(tmpdir(), "dash-index-"));
-        const indexDir = mkdtempSync(join(tmpdir(), "index-"));
-        // The server reads MEGACOMPACT_INDEX_DIR for the machine-wide registry.
-        process.env.MEGACOMPACT_INDEX_DIR = indexDir;
-        process.env.MEGACOMPACT_DASHBOARD_PORT = "19321"; // private base, non-colliding
-        const { upsertRepoRegistry } = await import("../src/store/sqlite.js");
-        upsertRepoRegistry({ repoRoot: "/home/u/repoA", displayName: "repoA", stateDir: join(dir, "a"), checkpointCount: 3, tokensSaved: 1000, compressedOriginalBytes: 0 }, indexDir);
-        upsertRepoRegistry({ repoRoot: "/home/u/repoB", displayName: "repoB", stateDir: join(dir, "b"), checkpointCount: 5, tokensSaved: 2000, compressedOriginalBytes: 0 }, indexDir);
-        const child = spawn(process.execPath, [SERVER_ENTRY, dir], { stdio: "ignore" });
-        try {
-            await waitFor(async () => {
-                try {
-                    const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
-                    const res = await fetch(`http://localhost:${raw.port}/api/version`);
-                    return res.ok;
-                }
-                catch {
-                    return false;
-                }
-            });
-            const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
-            const idx = (await fetch(`http://localhost:${raw.port}/api/index`).then((r) => r.json()));
-            const names = idx.repos.map((r) => r.displayName).sort();
-            assert.deepEqual(names, ["repoA", "repoB"], "both repos from the global index");
-            assert.equal(idx.summary.totalRepos, 2, "repo count");
-            assert.equal(idx.summary.totalCheckpoints, 8, "3 + 5 checkpoints");
-            assert.equal(idx.summary.totalTokensSaved, 3000, "1000 + 2000 tokens saved");
-        }
-        finally {
-            child.kill("SIGTERM");
-            delete process.env.MEGACOMPACT_INDEX_DIR;
-            delete process.env.MEGACOMPACT_DASHBOARD_PORT;
-            rmSync(dir, { recursive: true, force: true });
-            rmSync(indexDir, { recursive: true, force: true });
-        }
-    });
-    test("/api/repos filters by ?active=Nh and /api/summary counts activeRepos", async () => {
-        const dir = mkdtempSync(join(tmpdir(), "dash-active-"));
-        const indexDir = mkdtempSync(join(tmpdir(), "index-active-"));
-        process.env.MEGACOMPACT_INDEX_DIR = indexDir;
-        process.env.MEGACOMPACT_DASHBOARD_PORT = "19322";
-        const { upsertRepoRegistry } = await import("../src/store/sqlite.js");
-        // Fresh repo, last_seen = now
-        upsertRepoRegistry({ repoRoot: "/home/u/fresh", displayName: "fresh", stateDir: dir, checkpointCount: 1, tokensSaved: 100, compressedOriginalBytes: 0, lastSeen: Math.floor(Date.now() / 1000) }, indexDir);
-        // Stale repo, last_seen = 90 days ago — must be filtered out by ?active=24h.
-        const longAgo = Math.floor(Date.now() / 1000) - 90 * 86_400;
-        upsertRepoRegistry({ repoRoot: "/home/u/stale", displayName: "stale", stateDir: dir, checkpointCount: 2, tokensSaved: 200, compressedOriginalBytes: 0, lastSeen: longAgo }, indexDir);
-        const child = spawn(process.execPath, [SERVER_ENTRY, dir], { stdio: "ignore" });
-        try {
-            await waitFor(async () => {
-                try {
-                    const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
-                    const res = await fetch(`http://localhost:${raw.port}/api/version`);
-                    return res.ok;
-                }
-                catch {
-                    return false;
-                }
-            });
-            const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
-            const allRepos = (await fetch(`http://localhost:${raw.port}/api/repos`).then((r) => r.json()));
-            assert.equal(allRepos.count, 2, "unfiltered list has both repos");
-            const activeRepos = (await fetch(`http://localhost:${raw.port}/api/repos?active=24h`).then((r) => r.json()));
-            assert.equal(activeRepos.count, 1, "active=24h drops the 90-day-old repo");
-            assert.equal(activeRepos.repos[0].displayName, "fresh");
-            const summary = (await fetch(`http://localhost:${raw.port}/api/summary`).then((r) => r.json()));
-            assert.equal(summary.activeRepos, 1, "summary counts only fresh repo as active");
-            assert.equal(summary.totalRepos, 2, "summary counts both repos total");
-        }
-        finally {
-            child.kill("SIGTERM");
-            delete process.env.MEGACOMPACT_INDEX_DIR;
-            delete process.env.MEGACOMPACT_DASHBOARD_PORT;
-            rmSync(dir, { recursive: true, force: true });
-            rmSync(indexDir, { recursive: true, force: true });
-        }
-    });
-});
-describe("multi-repo /api/servers (active cache-hit stats)", () => {
-    test("returns active repos with live dashboard.json cache-hit/compaction stats", async () => {
-        const dir = mkdtempSync(join(tmpdir(), "dash-servers-"));
-        const indexDir = mkdtempSync(join(tmpdir(), "index-servers-"));
-        process.env.MEGACOMPACT_INDEX_DIR = indexDir;
-        process.env.MEGACOMPACT_DASHBOARD_PORT = "19323";
-        const { upsertRepoRegistry } = await import("../src/store/sqlite.js");
-        const activeState = mkdtempSync(join(tmpdir(), "srv-active-"));
-        writeFileSync(join(activeState, "dashboard.json"), JSON.stringify({
-            updatedAt: new Date().toISOString(),
-            tier: "high",
-            context: { tokens: 5000, percent: 0.42, contextWindow: 12000 },
-            session: { id: "s1", state: "idle" },
-            cacheHits: { session: 3, total: 7, sessionTokensSaved: 1200, totalTokensSaved: 9000 },
-            compacts: { session: 2, total: 5 },
-            timeSaved: { compact: { sessionSec: 1.5, totalSec: 4 }, cacheHit: { sessionSec: 0.6, totalSec: 4.5 } },
-        }, null, 2));
-        upsertRepoRegistry({ repoRoot: "/home/u/active", displayName: "active", stateDir: activeState, checkpointCount: 4, tokensSaved: 9000, compressedOriginalBytes: 0, lastSeen: Math.floor(Date.now() / 1000), modelName: "gpt-4o", providerName: "OpenAI" }, indexDir);
-        const staleState = mkdtempSync(join(tmpdir(), "srv-stale-"));
-        writeFileSync(join(staleState, "dashboard.json"), JSON.stringify({ updatedAt: new Date().toISOString(), tier: "low" }, null, 2));
-        const longAgo = Math.floor(Date.now() / 1000) - 7 * 86_400;
-        upsertRepoRegistry({ repoRoot: "/home/u/stale", displayName: "stale", stateDir: staleState, checkpointCount: 1, tokensSaved: 100, compressedOriginalBytes: 0, lastSeen: longAgo }, indexDir);
-        const child = spawn(process.execPath, [SERVER_ENTRY, dir], { stdio: "ignore" });
-        try {
-            await waitFor(async () => {
-                try {
-                    const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
-                    const res = await fetch(`http://localhost:${raw.port}/api/version`);
-                    return res.ok;
-                }
-                catch {
-                    return false;
-                }
-            });
-            const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
-            const body = (await fetch(`http://localhost:${raw.port}/api/servers`).then((r) => r.json()));
-            assert.equal(body.servers.length, 1, "only the active repo is returned");
-            const s = body.servers[0];
-            assert.equal(s.displayName, "active");
-            assert.equal(s.tier, "high");
-            assert.equal(s.model, "gpt-4o");
-            assert.equal(s.provider, "OpenAI");
-            assert.equal(s.contextPct, 0.42);
-            assert.equal(s.state, "idle");
-            assert.deepEqual(s.cacheHits, { session: 3, total: 7, sessionTokensSaved: 1200, totalTokensSaved: 9000 });
-            assert.deepEqual(s.compacts, { session: 2, total: 5 });
-            const ts = s.timeSaved;
-            assert.equal(ts.compact.sessionSec, 1.5);
-            assert.equal(ts.cacheHit.sessionSec, 0.6);
-        }
-        finally {
-            child.kill("SIGTERM");
-            delete process.env.MEGACOMPACT_INDEX_DIR;
-            delete process.env.MEGACOMPACT_DASHBOARD_PORT;
-            rmSync(dir, { recursive: true, force: true });
-            rmSync(indexDir, { recursive: true, force: true });
-        }
-    });
-});
-// ---------------------------------------------------------------------------
-// Lifecycle integration — launch the compiled server as a real subprocess
-// (the same way the /dashboard command spawns it) and assert the two failure
-// modes that historically produced a silent "failed to start":
-//   1. a stale port.pid pointing at a dead port is dropped, and the server
-//      binds fresh (instead of returning the dead port);
-//   2. a module-load crash is captured to the launch log instead of going
-//      silent under stdio:"ignore".
-// ---------------------------------------------------------------------------
-const SERVER_ENTRY = new URL("./dashboard-server.js", import.meta.url).pathname;
-// Tests run in parallel across files and a killed run can leave a server bound
-// to 9320. Use a private, non-colliding base so this file never races the
-// mega-compact.test.js dashboard tests (which scan a DIFFERENT base) and never
-// collides with a leftover production server on 9320.
-process.env.MEGACOMPACT_DASHBOARD_PORT = "19320";
-function waitFor(cond, timeoutMs = 6000) {
-    const start = Date.now();
-    return new Promise((resolve, reject) => {
-        const tick = async () => {
-            if (await cond())
-                return resolve();
-            if (Date.now() - start > timeoutMs)
-                return reject(new Error("timeout"));
-            setTimeout(tick, 50);
-        };
-        tick();
-    });
-}
-describe("server lifecycle", () => {
-    test("drops a stale port.pid and binds a fresh port", async () => {
-        const dir = mkdtempSync(join(tmpdir(), "dash-stale-"));
-        // A marker claiming a port where nothing is listening — use the test's own
-        // private base + 5 so the dead port is inside the server's scan range.
-        const deadPort = 19325;
-        writeFileSync(join(dir, "port.pid"), JSON.stringify({ port: deadPort, pid: 999999 }));
-        const child = spawn(process.execPath, [SERVER_ENTRY, dir], { stdio: "ignore" });
-        try {
-            // Wait for the server to actually be live (not just any port.pid — the
-            // stale marker already exists at t=0 and would pass a naive check).
-            await waitFor(async () => {
-                try {
-                    const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
-                    const res = await fetch(`http://localhost:${raw.port}/api/version`);
-                    return res.ok;
-                }
-                catch {
-                    return false;
-                }
-            });
-            const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
-            assert.equal(typeof raw.port, "number");
-            assert.notEqual(raw.port, deadPort, "should not reuse the dead port from the stale marker");
-            // And a real server must answer on it.
-            const res = await fetch(`http://localhost:${raw.port}/api/version`);
-            assert.equal(res.ok, true);
-        }
-        finally {
-            child.kill("SIGTERM");
-            rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    test("writes a dashboard.log with startup lines", async () => {
-        const dir = mkdtempSync(join(tmpdir(), "dash-log-"));
-        const child = spawn(process.execPath, [SERVER_ENTRY, dir], { stdio: "ignore" });
-        try {
-            await waitFor(() => {
-                try {
-                    return /server running/.test(readFileSync(join(dir, "dashboard.log"), "utf-8"));
-                }
-                catch {
-                    return false;
-                }
-            });
-            const log = readFileSync(join(dir, "dashboard.log"), "utf-8");
-            assert.match(log, /\[mega-compact\]\[dashboard\]/);
-            assert.match(log, /server running/);
-        }
-        finally {
-            child.kill("SIGTERM");
-            rmSync(dir, { recursive: true, force: true });
-        }
-    });
-});