@lsctech/polaris 0.1.0

package/dist/loop/provider-sealed-packet.test.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const parent_js_1 = require("./parent.js");
+const run_bootstrap_js_1 = require("./run-bootstrap.js");
+vitest_1.vi.mock("./adapters/registry.js", () => ({
+    createAdapter: vitest_1.vi.fn(),
+}));
+vitest_1.vi.mock("../config/loader.js", () => ({
+    loadConfig: vitest_1.vi.fn(() => ({
+        execution: {
+            adapter: "terminal-cli",
+            providers: { "agent-subtask": { command: "native-subtask" } },
+            rotation: ["terminal-cli"],
+        },
+        budget: {
+            max_children_per_session: 5,
+            allow_analyze_children: false,
+        },
+    })),
+}));
+const registry_js_1 = require("./adapters/registry.js");
+function writeState(dir, overrides) {
+    const stateFile = (0, node_path_1.join)(dir, "current-state.json");
+    const runId = "sealed-packet-smoke-run";
+    const clusterId = overrides["cluster_id"] ?? "POL-197";
+    const openChildren = overrides["open_children"] ?? [];
+    const state = {
+        schema_version: "1.0",
+        run_id: runId,
+        cluster_id: clusterId,
+        skill: "polaris-run",
+        artifact_dir: dir,
+        branch: "feature/pol-197",
+        current_step_id: "03-execute-child",
+        step_cursor: "dispatching",
+        status: "executing",
+        session_type: "implementation",
+        active_child: "",
+        last_commit: "",
+        next_open_child: null,
+        completed_children: [],
+        open_children: [],
+        open_children_meta: {},
+        context_budget: {
+            children_completed: 0,
+            files_touched_total: 0,
+            max_children_per_session: 5,
+        },
+        dispatch_boundary: { dispatch_epoch: 0, continue_epoch: 0, last_dispatched_child: null },
+        run_bootstrap_seal: (0, run_bootstrap_js_1.createBootstrapSeal)(runId, clusterId, openChildren),
+        updated_at: "2026-05-26T00:00:00.000Z",
+        ...overrides,
+    };
+    (0, node_fs_1.writeFileSync)(stateFile, JSON.stringify(state, null, 2), "utf-8");
+    return stateFile;
+}
+function readJsonLines(path) {
+    return (0, node_fs_1.readFileSync)(path, "utf-8")
+        .trim()
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => JSON.parse(line));
+}
+function makeSealedPacketAdapter(calls, resultFilePath) {
+    return {
+        name: "agent-subtask",
+        async dispatch(packet, options) {
+            calls.push({ packet, options });
+            // Simulate the worker writing its sealed result to the file
+            const workerPacket = packet;
+            if (workerPacket.result_file_contract?.result_file) {
+                const sealedResult = {
+                    run_id: workerPacket.run_id,
+                    child_id: workerPacket.active_child,
+                    status: "success",
+                    commit: "sealed-commit-123",
+                    validation: { message: "sealed packet validation passed" },
+                };
+                (0, node_fs_1.writeFileSync)(workerPacket.result_file_contract.result_file, JSON.stringify(sealedResult, null, 2), "utf-8");
+            }
+            const dispatchResult = {
+                exit_code: 0,
+                provider_used: "agent-subtask",
+                command_run: `agent-subtask:${packet.active_child}`,
+                // No summary returned for sealed packets, result is in file
+                summary: "",
+            };
+            return dispatchResult;
+        },
+    };
+}
+(0, vitest_1.describe)("provider smoke tests for sealed local packets", () => {
+    let tmpDir;
+    (0, vitest_1.beforeEach)(() => {
+        tmpDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "polaris-sealed-packet-smoke-"));
+        (0, node_fs_1.mkdirSync)((0, node_path_1.join)(tmpDir, "runs", "sealed-packet-smoke-run"), { recursive: true });
+        vitest_1.vi.clearAllMocks();
+    });
+    (0, vitest_1.afterEach)(() => {
+        (0, node_fs_1.rmSync)(tmpDir, { recursive: true, force: true });
+    });
+    (0, vitest_1.it)("dispatches a child with a sealed packet contract and processes its result file", async () => {
+        const calls = [];
+        const childId = "POL-200";
+        const resultFilePath = (0, node_path_1.join)(tmpDir, "runs", "sealed-packet-smoke-run", `${childId}-result.json`);
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(makeSealedPacketAdapter(calls, resultFilePath));
+        const stateFile = writeState(tmpDir, {
+            orchestration_mode: "ephemeral",
+            open_children: [childId],
+            next_open_child: childId,
+            open_children_meta: {
+                [childId]: {
+                    title: "IMPLEMENT: Sealed Packet Test Child",
+                    result_file: resultFilePath,
+                },
+            },
+        });
+        const result = await (0, parent_js_1.runParentLoop)({ stateFile, repoRoot: tmpDir });
+        (0, vitest_1.expect)(result.haltReason).toBe("cluster-complete");
+        (0, vitest_1.expect)(result.childrenDispatched).toBe(1);
+        (0, vitest_1.expect)(registry_js_1.createAdapter).toHaveBeenCalledWith("agent-subtask", vitest_1.expect.objectContaining({ adapter: "agent-subtask" }));
+        (0, vitest_1.expect)(calls).toHaveLength(1);
+        const dispatchedPacket = calls[0].packet;
+        (0, vitest_1.expect)(dispatchedPacket.active_child).toBe(childId);
+        (0, vitest_1.expect)(dispatchedPacket.result_file_contract?.result_file).toBe(resultFilePath);
+        // Verify the mock worker wrote the sealed result file
+        (0, vitest_1.expect)((0, node_fs_1.readFileSync)(resultFilePath, "utf-8")).toBe(JSON.stringify({
+            run_id: "sealed-packet-smoke-run",
+            child_id: childId,
+            status: "success",
+            commit: "sealed-commit-123",
+            validation: { message: "sealed packet validation passed" },
+        }, null, 2));
+        // Verify parent processed the sealed result and updated state and telemetry
+        const updatedState = JSON.parse((0, node_fs_1.readFileSync)(stateFile, "utf-8"));
+        (0, vitest_1.expect)(updatedState.status).toBe("cluster-complete");
+        (0, vitest_1.expect)(updatedState.completed_children).toEqual([childId]);
+        (0, vitest_1.expect)(updatedState.open_children).toEqual([]);
+        (0, vitest_1.expect)(updatedState.next_open_child).toBeNull();
+        (0, vitest_1.expect)(updatedState.last_commit).toBe("sealed-commit-123");
+        (0, vitest_1.expect)(updatedState.context_budget).toMatchObject({ children_completed: 1 });
+        const telemetry = readJsonLines((0, node_path_1.join)(tmpDir, "runs", "sealed-packet-smoke-run", "telemetry.jsonl"));
+        (0, vitest_1.expect)(telemetry).toEqual(vitest_1.expect.arrayContaining([
+            vitest_1.expect.objectContaining({
+                event: "child-dispatched",
+                child_id: childId,
+                adapter: "agent-subtask",
+                orchestration_mode: "ephemeral",
+                provider: "agent-subtask",
+            }),
+            vitest_1.expect.objectContaining({
+                event: "child-complete",
+                child_id: childId,
+                children_completed: 1,
+                validation_summary: { message: "sealed packet validation passed" },
+                commit_hash: "sealed-commit-123",
+            }),
+        ]));
+    });
+});

package/dist/loop/resume.js

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLoopResume = runLoopResume;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+const loader_js_1 = require("../config/loader.js");
+const checkpoint_js_1 = require("./checkpoint.js");
+const store_js_1 = require("../cluster-state/store.js");
+const ledger_js_1 = require("./ledger.js");
+function readPacket(bootstrapDir, runId) {
+    let entries;
+    try {
+        entries = (0, node_fs_1.readdirSync)(bootstrapDir).filter((f) => f.endsWith(".json"));
+    }
+    catch {
+        throw new Error(`Cannot read bootstrap directory: ${bootstrapDir}`);
+    }
+    if (entries.length === 0) {
+        throw new Error(`No bootstrap packets found in ${bootstrapDir}`);
+    }
+    let target;
+    if (runId) {
+        const matches = entries.filter((f) => f.startsWith(`${runId}-`)).sort();
+        if (matches.length === 0) {
+            throw new Error(`No bootstrap packet found for run_id "${runId}" in ${bootstrapDir}`);
+        }
+        target = matches.at(-1);
+    }
+    else {
+        // Pick the most recently written packet (last alphabetically by timestamp suffix)
+        target = entries.sort().at(-1);
+    }
+    const raw = (0, node_fs_1.readFileSync)((0, node_path_1.join)(bootstrapDir, target), "utf-8");
+    return JSON.parse(raw);
+}
+function verifyBranch(branch, repoRoot) {
+    try {
+        (0, node_child_process_1.execFileSync)("git", ["rev-parse", "--verify", branch], {
+            cwd: repoRoot,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+    }
+    catch {
+        throw new Error(`branch not found: ${branch}`);
+    }
+}
+function computeStateSha(stateFile) {
+    const content = (0, node_fs_1.readFileSync)(stateFile, "utf-8");
+    return (0, node_crypto_1.createHash)("sha256").update(content).digest("hex");
+}
+const COMPLETED_CHILD_STATUSES = new Set(["done", "finalized"]);
+const OPEN_CHILD_STATUSES = new Set([
+    "ready",
+    "claimed",
+    "dispatched",
+    "running",
+    "blocked",
+    "reviewed",
+]);
+function findClusterStateForPacket(repoRoot, packet) {
+    const clustersDir = (0, node_path_1.resolve)(repoRoot, ".polaris", "clusters");
+    const hints = new Set([packet.last_completed_child, ...packet.open_children].filter((value) => typeof value === "string" && value.length > 0));
+    let entries;
+    try {
+        entries = (0, node_fs_1.readdirSync)(clustersDir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name);
+    }
+    catch {
+        throw new Error(`cannot reconstruct state: no cluster-state.json found under ${clustersDir}`);
+    }
+    const matches = entries
+        .map((clusterId) => ({
+        state: (0, store_js_1.readClusterStateSync)(clusterId, repoRoot),
+        score: 0,
+    }))
+        .filter((candidate) => candidate.state !== null)
+        .map((candidate) => ({
+        ...candidate,
+        score: candidate.state.child_states.filter((child) => hints.has(child.id)).length,
+    }))
+        .filter((candidate) => candidate.score > 0)
+        .sort((a, b) => b.score - a.score);
+    if (matches.length === 0) {
+        throw new Error("cannot reconstruct state: no cluster-state.json matches the bootstrap packet children");
+    }
+    if (matches.length > 1 && matches[0].score === matches[1].score) {
+        throw new Error("cannot reconstruct state: multiple cluster-state.json files match the bootstrap packet children");
+    }
+    return matches[0].state;
+}
+function rebuildLoopStateFromClusterState(packet, clusterState, repoRoot) {
+    const clusterChildren = new Set(clusterState.child_states.map((child) => child.id));
+    const completedChildren = clusterState.child_states
+        .filter((child) => COMPLETED_CHILD_STATUSES.has(child.status))
+        .map((child) => child.id);
+    const openChildren = packet.open_children.filter((childId) => clusterChildren.has(childId));
+    const fallbackOpenChildren = openChildren.length > 0
+        ? openChildren
+        : clusterState.child_states
+            .filter((child) => OPEN_CHILD_STATUSES.has(child.status))
+            .map((child) => child.id);
+    const activeChild = fallbackOpenChildren.find((childId) => {
+        const status = clusterState.child_states.find((child) => child.id === childId)?.status;
+        return status === "claimed" || status === "dispatched" || status === "running";
+    }) ??
+        fallbackOpenChildren[0] ??
+        packet.last_completed_child;
+    const lastCommit = clusterState.commits[packet.last_completed_child] ??
+        Object.values(clusterState.commits).at(-1);
+    return {
+        schema_version: "1.0",
+        run_id: packet.run_id,
+        cluster_id: clusterState.cluster_id,
+        branch: packet.branch,
+        session_type: "implement",
+        active_child: activeChild,
+        completed_children: completedChildren,
+        open_children: fallbackOpenChildren,
+        step_cursor: packet.last_completed_step,
+        context_budget: {
+            children_completed: packet.context_budget.children_completed,
+        },
+        status: "running",
+        last_commit: lastCommit,
+        next_open_child: fallbackOpenChildren[0] ?? null,
+        artifact_dir: (0, node_path_1.resolve)(repoRoot, ".taskchain_artifacts", "polaris-run"),
+    };
+}
+function resolveResumeState(repoRoot, packet, stateFile) {
+    if ((0, node_fs_1.existsSync)(stateFile)) {
+        return {
+            packet,
+            state: (0, checkpoint_js_1.readState)(stateFile),
+            stateFile,
+        };
+    }
+    const clusterState = findClusterStateForPacket(repoRoot, packet);
+    const rebuiltState = rebuildLoopStateFromClusterState(packet, clusterState, repoRoot);
+    const rebuiltSha = (0, checkpoint_js_1.writeStateAtomic)(stateFile, rebuiltState);
+    const emittedPacket = {
+        ...packet,
+        artifact_pointers: {
+            ...packet.artifact_pointers,
+            current_state: (0, node_path_1.relative)(repoRoot, stateFile),
+        },
+        current_state_sha: rebuiltSha,
+    };
+    return {
+        packet: emittedPacket,
+        state: rebuiltState,
+        stateFile,
+    };
+}
+function getHeadSha(repoRoot) {
+    try {
+        return (0, node_child_process_1.execFileSync)("git", ["rev-parse", "HEAD"], {
+            cwd: repoRoot,
+            encoding: "utf-8",
+        }).trim();
+    }
+    catch {
+        return "";
+    }
+}
+function normalizeRunType(sessionType) {
+    return sessionType === "analyze" ? "analyze" : "implement";
+}
+function ledgerLastCommit(state) {
+    return state.last_commit && state.last_commit.length > 0 ? state.last_commit : null;
+}
+function appendResumedLedgerEvent(repoRoot, packet, state) {
+    const completedChildren = Array.isArray(state.completed_children)
+        ? state.completed_children
+        : [];
+    const openChildren = Array.isArray(state.open_children)
+        ? state.open_children
+        : packet.open_children;
+    new ledger_js_1.LedgerWriter((0, node_path_1.join)(repoRoot, ledger_js_1.DEFAULT_LEDGER_PATH)).append({
+        schema_version: 1,
+        event_id: (0, node_crypto_1.randomUUID)(),
+        event: "run-resumed",
+        run_id: packet.run_id,
+        run_type: normalizeRunType(state.session_type),
+        cluster_id: state.cluster_id ?? null,
+        issue_id: state.active_child || null,
+        branch: state.branch ?? packet.branch,
+        status: "running",
+        completed_children: completedChildren,
+        open_children: openChildren,
+        next_child: state.next_open_child ?? openChildren[0] ?? null,
+        last_commit: ledgerLastCommit(state),
+        pr_url: null,
+        timestamp: new Date().toISOString(),
+        resume_source: "bootstrap",
+        resume_reason: "polaris loop resume selected bootstrap packet",
+    });
+}
+function runLoopResume(options) {
+    const { runId, repoRoot } = options;
+    const config = (0, loader_js_1.loadConfig)(repoRoot);
+    const bootstrapDir = (0, node_path_1.resolve)(repoRoot, config.loop.bootstrapOutputPath ?? ".polaris/bootstrap");
+    // Step 1: Read bootstrap packet
+    let packet;
+    try {
+        packet = readPacket(bootstrapDir, runId);
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+    // Step 2: Verify branch exists
+    try {
+        verifyBranch(packet.branch, repoRoot);
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+    // Step 3: Verify current-state SHA
+    const stateFile = options.stateFile ??
+        (packet.artifact_pointers.current_state.startsWith("/")
+            ? packet.artifact_pointers.current_state
+            : (0, node_path_1.resolve)(repoRoot, packet.artifact_pointers.current_state));
+    let resumePacket = packet;
+    let resumeState;
+    try {
+        const resolved = resolveResumeState(repoRoot, packet, stateFile);
+        resumePacket = resolved.packet;
+        resumeState = resolved.state;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+        return;
+    }
+    const actualSha = computeStateSha(stateFile);
+    if (actualSha !== resumePacket.current_state_sha) {
+        // A SHA mismatch normally means the state drifted after the bootstrap
+        // packet was written — "state packet stale".
+        //
+        // Exception: `loop abort` legitimately rewrites current-state.json after
+        // the packet is recorded (it clears active_child, balances dispatch epochs,
+        // and sets status to "blocked").  Resume is safe when the state is
+        // blocked-idle: no active dispatch and no outstanding worker.
+        if (resumeState.status === "blocked") {
+            if (resumeState.active_child && resumeState.active_child !== "") {
+                console.error("cannot resume: status is blocked with active_child set — resolve the active dispatch first");
+                process.exit(1);
+            }
+            const boundary = resumeState.dispatch_boundary;
+            if (!boundary) {
+                console.error("cannot resume: status is blocked but dispatch_boundary is missing — state is inconsistent");
+                process.exit(1);
+            }
+            if (boundary.dispatch_epoch !== boundary.continue_epoch) {
+                console.error("cannot resume: status is blocked with unbalanced dispatch boundary — a dispatch is still pending");
+                process.exit(1);
+            }
+            // Blocked-idle: safe to proceed. Step 5 below will clear the blocked status.
+        }
+        else {
+            console.error("state packet stale — re-run `polaris loop status` to verify current state");
+            process.exit(1);
+        }
+    }
+    // Step 4: Check allowBranchDivergence
+    const allowDivergence = config.loop.allowBranchDivergence ?? false;
+    if (!allowDivergence && packet.base_commit_sha) {
+        const headSha = getHeadSha(repoRoot);
+        if (headSha && headSha !== packet.base_commit_sha) {
+            console.error(`branch HEAD changed since checkpoint (expected ${packet.base_commit_sha}, got ${headSha})`);
+            process.exit(1);
+        }
+    }
+    // Step 5: Clear blocked status if state was blocked
+    let ledgerState = resumeState;
+    if (resumeState.status === "blocked") {
+        ledgerState = {
+            ...resumeState,
+            status: "running",
+            blocker: undefined,
+        };
+        const updatedSha = (0, checkpoint_js_1.writeStateAtomic)(stateFile, ledgerState);
+        resumePacket = {
+            ...resumePacket,
+            current_state_sha: updatedSha,
+        };
+    }
+    appendResumedLedgerEvent(repoRoot, resumePacket, ledgerState);
+    // Step 6: Emit bootstrap packet to stdout, exit 0
+    console.log(JSON.stringify(resumePacket, null, 2));
+}

package/dist/loop/resume.test.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+const resume_js_1 = require("./resume.js");
+function getHeadSha(dir) {
+    try {
+        return (0, node_child_process_1.execFileSync)("git", ["rev-parse", "HEAD"], { cwd: dir, encoding: "utf-8" }).trim();
+    }
+    catch {
+        return "";
+    }
+}
+function getCurrentBranch(dir) {
+    try {
+        return (0, node_child_process_1.execFileSync)("git", ["branch", "--show-current"], { cwd: dir, encoding: "utf-8" }).trim();
+    }
+    catch {
+        return "main";
+    }
+}
+function makeTestDir() {
+    const dir = (0, node_path_1.join)((0, node_os_1.tmpdir)(), `polaris-resume-test-${Date.now()}`);
+    (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    (0, node_child_process_1.execFileSync)("git", ["init"], { cwd: dir });
+    (0, node_child_process_1.execFileSync)("git", ["config", "user.email", "test@test.com"], { cwd: dir });
+    (0, node_child_process_1.execFileSync)("git", ["config", "user.name", "Test"], { cwd: dir });
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(dir, "README.md"), "test\n");
+    (0, node_child_process_1.execFileSync)("git", ["add", "."], { cwd: dir });
+    (0, node_child_process_1.execFileSync)("git", ["commit", "-m", "init"], { cwd: dir });
+    return dir;
+}
+function writeState(dir, state) {
+    const stateFile = (0, node_path_1.join)(dir, ".polaris", "runs", "current-state.json");
+    (0, node_fs_1.mkdirSync)((0, node_path_1.join)(dir, ".polaris", "runs"), { recursive: true });
+    const content = JSON.stringify(state, null, 2);
+    (0, node_fs_1.writeFileSync)(stateFile, content);
+    return stateFile;
+}
+function shaOf(content) {
+    return (0, node_crypto_1.createHash)("sha256").update(content).digest("hex");
+}
+function writePacket(dir, packet) {
+    const bootstrapDir = (0, node_path_1.join)(dir, ".polaris", "bootstrap");
+    (0, node_fs_1.mkdirSync)(bootstrapDir, { recursive: true });
+    const filename = `${packet.run_id}-2026-01-01T00-00-00-000Z.json`;
+    const path = (0, node_path_1.join)(bootstrapDir, filename);
+    (0, node_fs_1.writeFileSync)(path, JSON.stringify(packet, null, 2));
+    return path;
+}
+function makePacket(stateFile, stateContent, testDir, overrides = {}) {
+    const sha = shaOf(JSON.stringify(stateContent, null, 2));
+    return {
+        run_id: "pol-5-session-1",
+        skill: "bootstrap-run",
+        branch: getCurrentBranch(testDir),
+        base_commit_sha: getHeadSha(testDir),
+        last_completed_step: "checkpoint",
+        last_completed_child: "POL-23",
+        next_step: "03-execute-child",
+        open_children: ["POL-24"],
+        artifact_pointers: {
+            current_state: stateFile,
+            telemetry: "/tmp/telemetry.jsonl",
+        },
+        context_budget: { children_completed: 1, files_touched_total: 0, stop_threshold_remaining: 2 },
+        current_state_sha: sha,
+        resume_instructions: "Run polaris loop resume pol-5-session-1",
+        ...overrides,
+    };
+}
+(0, vitest_1.describe)("runLoopResume", () => {
+    let testDir;
+    (0, vitest_1.beforeEach)(() => {
+        testDir = makeTestDir();
+    });
+    (0, vitest_1.afterEach)(() => {
+        (0, node_fs_1.rmSync)(testDir, { recursive: true, force: true });
+    });
+    (0, vitest_1.it)("emits bootstrap packet JSON to stdout when all checks pass", () => {
+        const stateContent = { schema_version: "1.0", run_id: "pol-5-session-1" };
+        const stateFile = writeState(testDir, stateContent);
+        const packet = makePacket(stateFile, stateContent, testDir);
+        writePacket(testDir, packet);
+        const logs = [];
+        const origLog = console.log;
+        console.log = (...args) => logs.push(args.map(String).join(" "));
+        try {
+            (0, resume_js_1.runLoopResume)({ repoRoot: testDir, stateFile });
+        }
+        finally {
+            console.log = origLog;
+        }
+        const emitted = JSON.parse(logs.join("\n"));
+        (0, vitest_1.expect)(emitted.run_id).toBe("pol-5-session-1");
+        (0, vitest_1.expect)(emitted.current_state_sha).toBeTruthy();
+    });
+    (0, vitest_1.it)("selects packet by run_id when provided", () => {
+        const stateContent = { schema_version: "1.0", run_id: "pol-5-session-1" };
+        const stateFile = writeState(testDir, stateContent);
+        const packet = makePacket(stateFile, stateContent, testDir);
+        writePacket(testDir, packet);
+        const logs = [];
+        const origLog = console.log;
+        console.log = (...args) => logs.push(args.map(String).join(" "));
+        try {
+            (0, resume_js_1.runLoopResume)({ runId: "pol-5-session-1", repoRoot: testDir, stateFile });
+        }
+        finally {
+            console.log = origLog;
+        }
+        (0, vitest_1.expect)(logs.join("")).toContain("pol-5-session-1");
+    });
+    (0, vitest_1.it)("halts with exit 1 when current-state SHA does not match packet", () => {
+        const stateContent = { schema_version: "1.0", run_id: "pol-5-session-1" };
+        const stateFile = writeState(testDir, stateContent);
+        // Use a wrong SHA in the packet
+        const packet = makePacket(stateFile, stateContent, testDir, { current_state_sha: "wrongsha" });
+        writePacket(testDir, packet);
+        const exitSpy = vitest_1.vi.spyOn(process, "exit").mockImplementation(() => {
+            throw new Error("process.exit called");
+        });
+        const errSpy = vitest_1.vi.spyOn(console, "error").mockImplementation(() => { });
+        try {
+            (0, vitest_1.expect)(() => (0, resume_js_1.runLoopResume)({ repoRoot: testDir, stateFile })).toThrow();
+            (0, vitest_1.expect)(errSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining("state packet stale"));
+        }
+        finally {
+            exitSpy.mockRestore();
+            errSpy.mockRestore();
+        }
+    });
+    (0, vitest_1.it)("halts when no bootstrap packets exist", () => {
+        const stateContent = { schema_version: "1.0", run_id: "pol-5-session-1" };
+        const stateFile = writeState(testDir, stateContent);
+        (0, node_fs_1.mkdirSync)((0, node_path_1.join)(testDir, ".polaris", "bootstrap"), { recursive: true });
+        const exitSpy = vitest_1.vi.spyOn(process, "exit").mockImplementation(() => {
+            throw new Error("process.exit called");
+        });
+        const errSpy = vitest_1.vi.spyOn(console, "error").mockImplementation(() => { });
+        try {
+            (0, vitest_1.expect)(() => (0, resume_js_1.runLoopResume)({ repoRoot: testDir, stateFile })).toThrow();
+            (0, vitest_1.expect)(errSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining("No bootstrap packets found"));
+        }
+        finally {
+            exitSpy.mockRestore();
+            errSpy.mockRestore();
+        }
+    });
+    (0, vitest_1.it)("halts when run_id packet not found", () => {
+        const stateContent = { schema_version: "1.0", run_id: "pol-5-session-1" };
+        const stateFile = writeState(testDir, stateContent);
+        const packet = makePacket(stateFile, stateContent, testDir);
+        writePacket(testDir, packet);
+        const exitSpy = vitest_1.vi.spyOn(process, "exit").mockImplementation(() => {
+            throw new Error("process.exit called");
+        });
+        const errSpy = vitest_1.vi.spyOn(console, "error").mockImplementation(() => { });
+        try {
+            (0, vitest_1.expect)(() => (0, resume_js_1.runLoopResume)({ runId: "nonexistent-run", repoRoot: testDir, stateFile })).toThrow();
+            (0, vitest_1.expect)(errSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining("nonexistent-run"));
+        }
+        finally {
+            exitSpy.mockRestore();
+            errSpy.mockRestore();
+        }
+    });
+});