@lsctech/polaris 0.1.0

package/dist/loop/parent.test.js

@@ -0,0 +1,738 @@
+"use strict";
+/**
+ * Unit tests for the scheduler-only parent loop (src/loop/parent.ts).
+ *
+ * Uses a mock adapter that returns valid compact JSON; verifies that:
+ * - The parent loops N times then halts at budget exhaustion.
+ * - Each iteration dispatches exactly one child (no inline child work).
+ * - ADAPTER HANDOFF semantics: dispatch + continue, not halt.
+ * - Blocked children halt immediately with a clear blocker description.
+ * - Cluster-complete halts cleanly when all children are done.
+ */
+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 index_js_1 = require("./index.js");
+const run_bootstrap_js_1 = require("./run-bootstrap.js");
+function makeMockAdapter(responses, calls = []) {
+    let callIndex = 0;
+    return {
+        name: "mock",
+        async dispatch(packet, options) {
+            calls.push({ packet, options });
+            const base = responses[callIndex] ?? responses[responses.length - 1];
+            callIndex += 1;
+            // Rewrite child_id in the summary to match the dispatched child so the
+            // parent loop's mismatch guard doesn't reject a valid mock result.
+            try {
+                const parsed = JSON.parse(base.summary ?? "{}");
+                if ("child_id" in parsed) {
+                    return { ...base, summary: JSON.stringify({ ...parsed, child_id: packet.active_child }) };
+                }
+            }
+            catch {
+                // Summary is not JSON — leave as-is
+            }
+            return base;
+        },
+    };
+}
+// ── Test fixtures ────────────────────────────────────────────────────────────
+const SUCCESS_RESULT = {
+    exit_code: 0,
+    provider_used: "mock",
+    command_run: "mock-worker",
+    summary: JSON.stringify({ child_id: "POL-99", status: "done", commit: "abc1234" }),
+};
+const BLOCKED_RESULT = {
+    exit_code: 0,
+    provider_used: "mock",
+    command_run: "mock-worker",
+    summary: JSON.stringify({
+        child_id: "POL-99",
+        status: "blocked",
+        blocker: "Waiting for POL-98 to merge",
+    }),
+};
+const ERROR_RESULT = {
+    exit_code: 1,
+    provider_used: "mock",
+    command_run: "mock-worker",
+    summary: "Worker process exited with code 1",
+};
+const SUCCESS_RESULT_NO_COMMIT = {
+    exit_code: 0,
+    provider_used: "mock",
+    command_run: "mock-worker",
+    summary: JSON.stringify({ child_id: "POL-99", status: "done" }),
+};
+// ── Test helpers ─────────────────────────────────────────────────────────────
+function makeStateFile(dir, overrides = {}) {
+    const stateFile = (0, node_path_1.join)(dir, "current-state.json");
+    const openChildren = overrides.open_children ?? ["POL-100", "POL-101", "POL-102"];
+    const state = {
+        schema_version: "1.0",
+        run_id: "test-run-001",
+        cluster_id: "POL-99",
+        skill: "polaris-run",
+        artifact_dir: dir,
+        branch: "feature/test",
+        current_step_id: "03-execute-child",
+        step_cursor: "dispatching",
+        status: "executing",
+        session_type: "implementation",
+        active_child: "",
+        last_commit: "",
+        next_open_child: openChildren[0] ?? null,
+        completed_children: overrides.completed_children ?? [],
+        open_children: openChildren,
+        open_children_meta: {},
+        context_budget: {
+            children_completed: overrides.children_completed ?? 0,
+            files_touched_total: 0,
+            max_children_per_session: overrides.max_children_per_session ?? 3,
+        },
+        dispatch_boundary: { dispatch_epoch: 0, continue_epoch: 0, last_dispatched_child: null },
+        run_bootstrap_seal: (0, run_bootstrap_js_1.createBootstrapSeal)("test-run-001", "POL-99", openChildren),
+        updated_at: new Date().toISOString(),
+    };
+    (0, node_fs_1.writeFileSync)(stateFile, JSON.stringify(state, null, 2), "utf-8");
+    return stateFile;
+}
+function makeStateFileWithMeta(dir, openChildren, meta, maxChildren = 10) {
+    const stateFile = (0, node_path_1.join)(dir, "current-state.json");
+    const state = {
+        schema_version: "1.0",
+        run_id: "test-run-001",
+        cluster_id: "POL-99",
+        skill: "polaris-run",
+        artifact_dir: dir,
+        branch: "feature/test",
+        current_step_id: "03-execute-child",
+        step_cursor: "dispatching",
+        status: "executing",
+        session_type: "implementation",
+        active_child: "",
+        last_commit: "",
+        next_open_child: openChildren[0] ?? null,
+        completed_children: [],
+        open_children: openChildren,
+        open_children_meta: meta,
+        context_budget: {
+            children_completed: 0,
+            files_touched_total: 0,
+            max_children_per_session: maxChildren,
+        },
+        dispatch_boundary: { dispatch_epoch: 0, continue_epoch: 0, last_dispatched_child: null },
+        run_bootstrap_seal: (0, run_bootstrap_js_1.createBootstrapSeal)("test-run-001", "POL-99", openChildren),
+        updated_at: new Date().toISOString(),
+    };
+    (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 configureCommandForTest(command, output) {
+    command.exitOverride();
+    command.configureOutput({
+        writeOut: (value) => {
+            output.stdout += value;
+        },
+        writeErr: (value) => {
+            output.stderr += value;
+        },
+    });
+    for (const child of command.commands) {
+        configureCommandForTest(child, output);
+    }
+}
+async function runLoopCommand(command, argv) {
+    const output = { stdout: "", stderr: "" };
+    let exitCode = 0;
+    const originalExit = process.exit;
+    const originalStdoutWrite = process.stdout.write;
+    const originalStderrWrite = process.stderr.write;
+    configureCommandForTest(command, output);
+    process.stdout.write = ((chunk) => {
+        output.stdout += String(chunk);
+        return true;
+    });
+    process.stderr.write = ((chunk) => {
+        output.stderr += String(chunk);
+        return true;
+    });
+    process.exit = ((code) => {
+        exitCode = typeof code === "number" ? code : 0;
+        throw new Error("process.exit called");
+    });
+    try {
+        await command.parseAsync(["node", "polaris", ...argv], { from: "node" });
+    }
+    catch (error) {
+        if (!(error instanceof Error && "exitCode" in error) &&
+            !(error instanceof Error && error.message === "process.exit called")) {
+            throw error;
+        }
+        if (error instanceof Error && "exitCode" in error) {
+            exitCode = Number(error.exitCode);
+        }
+    }
+    finally {
+        process.exit = originalExit;
+        process.stdout.write = originalStdoutWrite;
+        process.stderr.write = originalStderrWrite;
+    }
+    return { ...output, exitCode };
+}
+// ── Mock registry so tests can inject a mock adapter ────────────────────────
+vitest_1.vi.mock("./adapters/registry.js", () => ({
+    createAdapter: vitest_1.vi.fn(),
+}));
+vitest_1.vi.mock("../config/loader.js", () => ({
+    loadConfig: vitest_1.vi.fn(() => ({
+        orchestration: {
+            mode: "auto",
+            notification_format: "verbose",
+            auto_finalize: false,
+        },
+        execution: {
+            adapter: "mock",
+            providers: { mock: { command: "mock-worker" } },
+            rotation: ["mock"],
+        },
+    })),
+}));
+const registry_js_1 = require("./adapters/registry.js");
+// ── Tests ────────────────────────────────────────────────────────────────────
+(0, vitest_1.describe)("runParentLoop", () => {
+    let tmpDir;
+    (0, vitest_1.beforeEach)(() => {
+        tmpDir = (0, node_path_1.join)((0, node_os_1.tmpdir)(), `polaris-parent-test-${Date.now()}`);
+        (0, node_fs_1.mkdirSync)((0, node_path_1.join)(tmpDir, "runs", "test-run-001"), { recursive: true });
+        vitest_1.vi.clearAllMocks();
+    });
+    (0, vitest_1.afterEach)(() => {
+        try {
+            (0, node_fs_1.rmSync)(tmpDir, { recursive: true, force: true });
+        }
+        catch {
+            // ignore cleanup errors
+        }
+    });
+    (0, vitest_1.it)("loops N times then halts at budget exhaustion", async () => {
+        // Budget: 3 max children, 0 completed, 3 open children
+        const calls = [];
+        const mockAdapter = makeMockAdapter([SUCCESS_RESULT, SUCCESS_RESULT, SUCCESS_RESULT], calls);
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(mockAdapter);
+        const stateFile = makeStateFile(tmpDir, {
+            open_children: ["POL-100", "POL-101", "POL-102"],
+            children_completed: 0,
+            max_children_per_session: 2, // budget of 2, 3 children → exhaust after 2
+        });
+        const result = await (0, parent_js_1.runParentLoop)({
+            stateFile,
+            repoRoot: tmpDir,
+        });
+        (0, vitest_1.expect)(result.haltReason).toBe("budget-exhausted");
+        (0, vitest_1.expect)(result.childrenDispatched).toBe(2);
+        // Adapter dispatched exactly 2 children before budget was exhausted
+        (0, vitest_1.expect)(calls).toHaveLength(2);
+        (0, vitest_1.expect)(calls[0].packet.active_child).toBe("POL-100");
+        (0, vitest_1.expect)(calls[1].packet.active_child).toBe("POL-101");
+    });
+    (0, vitest_1.it)("dispatches each child exactly once (no inline child work)", async () => {
+        const calls = [];
+        const mockAdapter = makeMockAdapter([SUCCESS_RESULT, SUCCESS_RESULT, SUCCESS_RESULT], calls);
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(mockAdapter);
+        const stateFile = makeStateFile(tmpDir, {
+            open_children: ["POL-100", "POL-101", "POL-102"],
+            children_completed: 0,
+            max_children_per_session: 10,
+        });
+        const result = await (0, parent_js_1.runParentLoop)({ stateFile, repoRoot: tmpDir });
+        // All 3 children done, no budget exhaustion
+        (0, vitest_1.expect)(result.haltReason).toBe("cluster-complete");
+        (0, vitest_1.expect)(result.childrenDispatched).toBe(3);
+        // Each child dispatched exactly once
+        const dispatchedIds = calls.map((c) => c.packet.active_child);
+        (0, vitest_1.expect)(dispatchedIds).toEqual(["POL-100", "POL-101", "POL-102"]);
+    });
+    (0, vitest_1.it)("appends run-started to the global ledger on entry", async () => {
+        const calls = [];
+        const mockAdapter = makeMockAdapter([SUCCESS_RESULT], calls);
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(mockAdapter);
+        const stateFile = makeStateFile(tmpDir, {
+            open_children: ["POL-100"],
+            children_completed: 0,
+            max_children_per_session: 10,
+        });
+        await (0, parent_js_1.runParentLoop)({ stateFile, repoRoot: tmpDir });
+        const events = (0, node_fs_1.readFileSync)((0, node_path_1.join)(tmpDir, ".polaris", "runs", "ledger.jsonl"), "utf-8")
+            .trim()
+            .split("\n")
+            .map((line) => JSON.parse(line));
+        (0, vitest_1.expect)(events[0]).toMatchObject({
+            event: "run-started",
+            run_id: "test-run-001",
+            run_type: "implement",
+            cluster_id: "POL-99",
+            issue_id: null,
+            branch: "feature/test",
+            status: "running",
+            completed_children: [],
+            open_children: ["POL-100"],
+            next_child: "POL-100",
+            last_commit: null,
+            pr_url: null,
+        });
+    });
+    (0, vitest_1.it)("ADAPTER HANDOFF: dispatch + continue, not halt", async () => {
+        // Verify that after each dispatch the loop continues to the next child
+        const calls = [];
+        const mockAdapter = makeMockAdapter([SUCCESS_RESULT, SUCCESS_RESULT], calls);
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(mockAdapter);
+        const stateFile = makeStateFile(tmpDir, {
+            open_children: ["POL-100", "POL-101"],
+            children_completed: 0,
+            max_children_per_session: 10,
+        });
+        const result = await (0, parent_js_1.runParentLoop)({ stateFile, repoRoot: tmpDir });
+        // The loop continued after the first dispatch (ADAPTER HANDOFF = continue)
+        (0, vitest_1.expect)(result.haltReason).toBe("cluster-complete");
+        (0, vitest_1.expect)(calls).toHaveLength(2);
+    });
+    (0, vitest_1.it)("halts after one successful child in supervised mode", async () => {
+        const calls = [];
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(makeMockAdapter([SUCCESS_RESULT, SUCCESS_RESULT], calls));
+        const { loadConfig } = await import("../config/loader.js");
+        vitest_1.vi.mocked(loadConfig).mockReturnValueOnce({
+            orchestration: {
+                mode: "supervised",
+                notification_format: "verbose",
+                auto_finalize: false,
+            },
+            execution: {
+                adapter: "mock",
+                providers: { mock: { command: "mock-worker" } },
+                rotation: ["mock"],
+            },
+        });
+        const stateFile = makeStateFile(tmpDir, {
+            open_children: ["POL-100", "POL-101"],
+            children_completed: 0,
+            max_children_per_session: 10,
+        });
+        const result = await (0, parent_js_1.runParentLoop)({ stateFile, repoRoot: tmpDir });
+        (0, vitest_1.expect)(result.haltReason).toBe("supervised-mode-child-complete");
+        (0, vitest_1.expect)(result.childrenDispatched).toBe(1);
+        (0, vitest_1.expect)(calls).toHaveLength(1);
+    });
+    (0, vitest_1.it)("continues through eligible children in auto mode", async () => {
+        const calls = [];
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(makeMockAdapter([SUCCESS_RESULT, SUCCESS_RESULT], calls));
+        const { loadConfig } = await import("../config/loader.js");
+        vitest_1.vi.mocked(loadConfig).mockReturnValueOnce({
+            orchestration: {
+                mode: "auto",
+                notification_format: "verbose",
+                auto_finalize: false,
+            },
+            execution: {
+                adapter: "mock",
+                providers: { mock: { command: "mock-worker" } },
+                rotation: ["mock"],
+            },
+        });
+        const stateFile = makeStateFile(tmpDir, {
+            open_children: ["POL-100", "POL-101"],
+            children_completed: 0,
+            max_children_per_session: 10,
+        });
+        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(2);
+        (0, vitest_1.expect)(calls).toHaveLength(2);
+    });
+    (0, vitest_1.it)("halts immediately when a child reports blocked", async () => {
+        const calls = [];
+        const mockAdapter = makeMockAdapter([BLOCKED_RESULT], calls);
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(mockAdapter);
+        const stateFile = makeStateFile(tmpDir, {
+            open_children: ["POL-100", "POL-101"],
+            children_completed: 0,
+            max_children_per_session: 10,
+        });
+        const result = await (0, parent_js_1.runParentLoop)({ stateFile, repoRoot: tmpDir });
+        (0, vitest_1.expect)(result.haltReason).toBe("blocked");
+        (0, vitest_1.expect)(result.haltingChild).toBe("POL-100");
+        (0, vitest_1.expect)(result.message).toContain("POL-98 to merge");
+        // Only one dispatch attempt before halt
+        (0, vitest_1.expect)(calls).toHaveLength(1);
+        // POL-101 never dispatched
+        (0, vitest_1.expect)(calls[0].packet.active_child).toBe("POL-100");
+    });
+    (0, vitest_1.it)("halts on worker error with non-zero exit code", async () => {
+        const calls = [];
+        const mockAdapter = makeMockAdapter([ERROR_RESULT], calls);
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(mockAdapter);
+        const stateFile = makeStateFile(tmpDir, {
+            open_children: ["POL-100"],
+            children_completed: 0,
+            max_children_per_session: 10,
+        });
+        const result = await (0, parent_js_1.runParentLoop)({ stateFile, repoRoot: tmpDir });
+        (0, vitest_1.expect)(result.haltReason).toBe("worker-error");
+        (0, vitest_1.expect)(result.haltingChild).toBe("POL-100");
+    });
+    (0, vitest_1.it)("halts cleanly with cluster-complete when all children are done", async () => {
+        const mockAdapter = makeMockAdapter([SUCCESS_RESULT]);
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(mockAdapter);
+        const stateFile = makeStateFile(tmpDir, {
+            open_children: ["POL-100"],
+            children_completed: 0,
+            max_children_per_session: 10,
+        });
+        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)(result.message).toContain("Cluster complete");
+    });
+    (0, vitest_1.it)("does not double-count when worker already persisted child completion", async () => {
+        const stateFile = makeStateFile(tmpDir, {
+            open_children: ["POL-100"],
+            children_completed: 0,
+            max_children_per_session: 10,
+        });
+        const mockAdapter = {
+            name: "mock",
+            async dispatch() {
+                const state = JSON.parse((0, node_fs_1.readFileSync)(stateFile, "utf-8"));
+                const contextBudget = state.context_budget;
+                (0, node_fs_1.writeFileSync)(stateFile, JSON.stringify({
+                    ...state,
+                    open_children: [],
+                    completed_children: ["POL-100"],
+                    context_budget: {
+                        ...contextBudget,
+                        children_completed: 1,
+                    },
+                    next_open_child: null,
+                    status: "cluster-complete",
+                }, null, 2), "utf-8");
+                return {
+                    exit_code: 0,
+                    provider_used: "mock",
+                    command_run: "mock-worker",
+                    summary: JSON.stringify({ child_id: "POL-100", status: "done", commit: "abc1234" }),
+                };
+            },
+        };
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(mockAdapter);
+        const result = await (0, parent_js_1.runParentLoop)({ stateFile, repoRoot: tmpDir });
+        const finalState = JSON.parse((0, node_fs_1.readFileSync)(stateFile, "utf-8"));
+        (0, vitest_1.expect)(result.haltReason).toBe("cluster-complete");
+        (0, vitest_1.expect)(result.childrenDispatched).toBe(1);
+        (0, vitest_1.expect)(finalState.completed_children).toEqual(["POL-100"]);
+        (0, vitest_1.expect)(finalState.context_budget.children_completed).toBe(1);
+    });
+    (0, vitest_1.it)("returns state-invalid when current-state.json is malformed", async () => {
+        const stateFile = (0, node_path_1.join)(tmpDir, "current-state.json");
+        (0, node_fs_1.writeFileSync)(stateFile, '{"not_valid": true}', "utf-8");
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(makeMockAdapter([SUCCESS_RESULT]));
+        const result = await (0, parent_js_1.runParentLoop)({ stateFile, repoRoot: tmpDir });
+        (0, vitest_1.expect)(result.haltReason).toBe("state-invalid");
+        (0, vitest_1.expect)(result.childrenDispatched).toBe(0);
+    });
+    (0, vitest_1.it)("passes the correct bootstrap packet to the adapter", async () => {
+        const calls = [];
+        const mockAdapter = makeMockAdapter([SUCCESS_RESULT], calls);
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(mockAdapter);
+        const stateFile = makeStateFile(tmpDir, {
+            open_children: ["POL-100"],
+            children_completed: 0,
+            max_children_per_session: 10,
+        });
+        await (0, parent_js_1.runParentLoop)({ stateFile, repoRoot: tmpDir });
+        // Parent now dispatches compiled WorkerPackets (schema_version 2.1)
+        // instead of raw v1 BootstrapPackets. WorkerPacket is a structural
+        // superset of BootstrapPacket so all adapter contracts remain valid.
+        (0, vitest_1.expect)(calls[0].packet).toMatchObject({
+            schema_version: "2.1",
+            run_id: "test-run-001",
+            cluster_id: "POL-99",
+            active_child: "POL-100",
+            // parent.ts normalizes via realpathSync to resolve macOS /var → /private/var symlinks
+            state_file: (0, node_fs_1.realpathSync)(stateFile),
+        });
+    });
+    (0, vitest_1.it)("halts with analyze-parent when cluster root title starts with 'ANALYZE:'", async () => {
+        const calls = [];
+        const mockAdapter = makeMockAdapter([SUCCESS_RESULT], calls);
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(mockAdapter);
+        const stateFile = makeStateFileWithMeta(tmpDir, ["POL-100"], { "POL-99": { title: "ANALYZE: Split execution architecture" } });
+        const result = await (0, parent_js_1.runParentLoop)({ stateFile, repoRoot: tmpDir });
+        (0, vitest_1.expect)(result.haltReason).toBe("analyze-parent");
+        (0, vitest_1.expect)(result.childrenDispatched).toBe(0);
+        (0, vitest_1.expect)(result.message).toBe("polaris-run targets IMPLEMENT parents, not ANALYZE issues. Run polaris-analyze first to create an IMPLEMENT parent.");
+        (0, vitest_1.expect)(calls).toHaveLength(0);
+    });
+    (0, vitest_1.it)("halts with analyze-parent when cluster root has 'analyze' label", async () => {
+        const calls = [];
+        const mockAdapter = makeMockAdapter([SUCCESS_RESULT], calls);
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(mockAdapter);
+        const stateFile = makeStateFileWithMeta(tmpDir, ["POL-100"], { "POL-99": { title: "Plan issue hierarchy", labels: ["analyze"] } });
+        const result = await (0, parent_js_1.runParentLoop)({ stateFile, repoRoot: tmpDir });
+        (0, vitest_1.expect)(result.haltReason).toBe("analyze-parent");
+        (0, vitest_1.expect)(calls).toHaveLength(0);
+    });
+    // ── Analyze-drift guardrail tests ──────────────────────────────────────────
+    (0, vitest_1.it)("halts with analyze-drift when next child title starts with 'Analyze:'", async () => {
+        const mockAdapter = makeMockAdapter([SUCCESS_RESULT]);
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(mockAdapter);
+        const stateFile = makeStateFileWithMeta(tmpDir, ["POL-200"], { "POL-200": { title: "Analyze: scheduler behavior" } });
+        const result = await (0, parent_js_1.runParentLoop)({ stateFile, repoRoot: tmpDir });
+        (0, vitest_1.expect)(result.haltReason).toBe("analyze-drift");
+        (0, vitest_1.expect)(result.haltingChild).toBe("POL-200");
+        (0, vitest_1.expect)(result.message).toContain("POL-200");
+        (0, vitest_1.expect)(result.message).toContain("allow_analyze_children");
+    });
+    (0, vitest_1.it)("halts with analyze-drift when next child title starts with 'polaris-analyze'", async () => {
+        const mockAdapter = makeMockAdapter([SUCCESS_RESULT]);
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(mockAdapter);
+        const stateFile = makeStateFileWithMeta(tmpDir, ["POL-200"], { "POL-200": { title: "polaris-analyze worker adapters" } });
+        const result = await (0, parent_js_1.runParentLoop)({ stateFile, repoRoot: tmpDir });
+        (0, vitest_1.expect)(result.haltReason).toBe("analyze-drift");
+        (0, vitest_1.expect)(result.haltingChild).toBe("POL-200");
+    });
+    (0, vitest_1.it)("halts with analyze-drift when next child has 'analyze' label", async () => {
+        const mockAdapter = makeMockAdapter([SUCCESS_RESULT]);
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(mockAdapter);
+        const stateFile = makeStateFileWithMeta(tmpDir, ["POL-200"], { "POL-200": { labels: ["analyze", "spike"] } });
+        const result = await (0, parent_js_1.runParentLoop)({ stateFile, repoRoot: tmpDir });
+        (0, vitest_1.expect)(result.haltReason).toBe("analyze-drift");
+        (0, vitest_1.expect)(result.haltingChild).toBe("POL-200");
+    });
+    (0, vitest_1.it)("does NOT halt for an implementation/fix child", async () => {
+        const mockAdapter = makeMockAdapter([SUCCESS_RESULT]);
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(mockAdapter);
+        const stateFile = makeStateFileWithMeta(tmpDir, ["POL-200"], { "POL-200": { title: "Implement: add budget guardrail", labels: ["feature"] } });
+        const result = await (0, parent_js_1.runParentLoop)({ stateFile, repoRoot: tmpDir });
+        (0, vitest_1.expect)(result.haltReason).toBe("cluster-complete");
+    });
+    (0, vitest_1.it)("does NOT halt when allowAnalyzeChildren flag is set", async () => {
+        const mockAdapter = makeMockAdapter([SUCCESS_RESULT]);
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(mockAdapter);
+        const stateFile = makeStateFileWithMeta(tmpDir, ["POL-200"], { "POL-200": { title: "Analyze: scheduler behavior" } });
+        const result = await (0, parent_js_1.runParentLoop)({
+            stateFile,
+            repoRoot: tmpDir,
+            allowAnalyzeChildren: true,
+        });
+        (0, vitest_1.expect)(result.haltReason).toBe("cluster-complete");
+    });
+    (0, vitest_1.it)("does NOT halt when budget.allow_analyze_children is true in config", async () => {
+        const mockAdapter = makeMockAdapter([SUCCESS_RESULT]);
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(mockAdapter);
+        // Override config mock to include allow_analyze_children: true
+        const { loadConfig } = await import("../config/loader.js");
+        vitest_1.vi.mocked(loadConfig).mockReturnValueOnce({
+            orchestration: {
+                mode: "auto",
+                notification_format: "verbose",
+                auto_finalize: false,
+            },
+            execution: {
+                adapter: "mock",
+                providers: { mock: { command: "mock-worker" } },
+                rotation: ["mock"],
+            },
+            budget: {
+                allow_analyze_children: true,
+            },
+        });
+        const stateFile = makeStateFileWithMeta(tmpDir, ["POL-200"], { "POL-200": { title: "Analyze: scheduler behavior" } });
+        const result = await (0, parent_js_1.runParentLoop)({ stateFile, repoRoot: tmpDir });
+        (0, vitest_1.expect)(result.haltReason).toBe("cluster-complete");
+    });
+    (0, vitest_1.it)("uses the agent-subtask adapter when orchestration_mode is ephemeral", async () => {
+        const calls = [];
+        const mockAdapter = makeMockAdapter([SUCCESS_RESULT], calls);
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(mockAdapter);
+        const { loadConfig } = await import("../config/loader.js");
+        vitest_1.vi.mocked(loadConfig).mockReturnValueOnce({
+            orchestration: {
+                mode: "auto",
+                notification_format: "verbose",
+                auto_finalize: false,
+            },
+            execution: {
+                adapter: "terminal-cli",
+                providers: { terminal: { command: "terminal-worker" } },
+                rotation: ["terminal"],
+            },
+        });
+        const stateFile = makeStateFile(tmpDir, {
+            open_children: ["POL-100"],
+            children_completed: 0,
+            max_children_per_session: 10,
+        });
+        const state = JSON.parse((0, node_fs_1.readFileSync)(stateFile, "utf-8"));
+        (0, node_fs_1.writeFileSync)(stateFile, JSON.stringify({ ...state, orchestration_mode: "ephemeral" }, null, 2), "utf-8");
+        await (0, parent_js_1.runParentLoop)({ stateFile, repoRoot: tmpDir });
+        (0, vitest_1.expect)(registry_js_1.createAdapter).toHaveBeenCalledWith("agent-subtask", vitest_1.expect.objectContaining({ adapter: "agent-subtask" }));
+        (0, vitest_1.expect)(calls[0].options.provider).toBe("agent-subtask");
+    });
+    (0, vitest_1.it)("uses the configured adapter when orchestration_mode is persistent-parent", async () => {
+        const calls = [];
+        const mockAdapter = makeMockAdapter([SUCCESS_RESULT], calls);
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(mockAdapter);
+        const stateFile = makeStateFile(tmpDir, {
+            open_children: ["POL-100"],
+            children_completed: 0,
+            max_children_per_session: 10,
+        });
+        const state = JSON.parse((0, node_fs_1.readFileSync)(stateFile, "utf-8"));
+        (0, node_fs_1.writeFileSync)(stateFile, JSON.stringify({ ...state, orchestration_mode: "persistent-parent" }, null, 2), "utf-8");
+        await (0, parent_js_1.runParentLoop)({ stateFile, repoRoot: tmpDir });
+        (0, vitest_1.expect)(registry_js_1.createAdapter).toHaveBeenCalledWith("mock", vitest_1.expect.objectContaining({ adapter: "mock" }));
+        (0, vitest_1.expect)(calls[0].options.provider).toBe("mock");
+    });
+    (0, vitest_1.it)("omits undefined commit hashes from terse completion output", async () => {
+        const calls = [];
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(makeMockAdapter([SUCCESS_RESULT_NO_COMMIT], calls));
+        const stateFile = makeStateFile(tmpDir, {
+            open_children: ["POL-100"],
+            children_completed: 0,
+            max_children_per_session: 10,
+        });
+        let stdout = "";
+        const originalStdoutWrite = process.stdout.write;
+        process.stdout.write = ((chunk) => {
+            stdout += String(chunk);
+            return true;
+        });
+        try {
+            const { loadConfig } = await import("../config/loader.js");
+            vitest_1.vi.mocked(loadConfig).mockReturnValueOnce({
+                orchestration: {
+                    mode: "auto",
+                    notification_format: "terse",
+                    auto_finalize: false,
+                },
+                execution: {
+                    adapter: "mock",
+                    providers: { mock: { command: "mock-worker" } },
+                    rotation: ["mock"],
+                },
+            });
+            await (0, parent_js_1.runParentLoop)({ stateFile, repoRoot: tmpDir });
+        }
+        finally {
+            process.stdout.write = originalStdoutWrite;
+        }
+        (0, vitest_1.expect)(stdout).toContain("[POLARIS] COMPLETE POL-100");
+        (0, vitest_1.expect)(stdout).not.toContain("undefined");
+        (0, vitest_1.expect)(stdout).not.toContain("(commit:");
+    });
+    (0, vitest_1.it)("records an explicit auto-finalize handoff in auto mode", async () => {
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(makeMockAdapter([SUCCESS_RESULT]));
+        const stateFile = makeStateFile(tmpDir, {
+            open_children: [],
+            completed_children: ["POL-100"],
+            children_completed: 1,
+            max_children_per_session: 10,
+        });
+        const { loadConfig } = await import("../config/loader.js");
+        vitest_1.vi.mocked(loadConfig).mockReturnValueOnce({
+            orchestration: {
+                mode: "auto",
+                notification_format: "verbose",
+                auto_finalize: true,
+            },
+            execution: {
+                adapter: "mock",
+                providers: { mock: { command: "mock-worker" } },
+                rotation: ["mock"],
+            },
+        });
+        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.message).toContain("Auto-finalize handoff requested");
+        const telemetry = readJsonLines((0, node_path_1.join)(tmpDir, "runs", "test-run-001", "telemetry.jsonl"));
+        (0, vitest_1.expect)(telemetry).toEqual(vitest_1.expect.arrayContaining([
+            vitest_1.expect.objectContaining({ event: "cluster-complete" }),
+            vitest_1.expect.objectContaining({
+                event: "auto-finalize-requested",
+                next_action: "polaris finalize run",
+            }),
+        ]));
+    });
+    (0, vitest_1.it)("CLI loop run dry-run with a valid state file runs to cluster-complete and exits 0", async () => {
+        const calls = [];
+        const mockAdapter = makeMockAdapter([SUCCESS_RESULT], calls);
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(mockAdapter);
+        const stateFile = makeStateFile(tmpDir, {
+            open_children: ["POL-100"],
+            children_completed: 0,
+            max_children_per_session: 10,
+        });
+        const command = (0, index_js_1.createLoopCommand)({ repoRoot: tmpDir });
+        const result = await runLoopCommand(command, [
+            "run",
+            "POL-99",
+            "--state-file",
+            stateFile,
+            "--adapter",
+            "mock",
+            "--provider",
+            "mock",
+            "--dry-run",
+        ]);
+        (0, vitest_1.expect)(result.exitCode).toBe(0);
+        (0, vitest_1.expect)(result.stdout).toContain("Polaris parent loop halted: cluster-complete");
+        (0, vitest_1.expect)(result.stdout).toContain("Cluster complete");
+        (0, vitest_1.expect)(calls).toHaveLength(1);
+        (0, vitest_1.expect)(calls[0].options).toMatchObject({ provider: "mock", dryRun: true });
+    });
+    (0, vitest_1.it)("CLI loop run exits 1 when state file is invalid", async () => {
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(makeMockAdapter([SUCCESS_RESULT]));
+        const stateFile = (0, node_path_1.join)(tmpDir, "current-state.json");
+        (0, node_fs_1.writeFileSync)(stateFile, '{"not_valid": true}', "utf-8");
+        const command = (0, index_js_1.createLoopCommand)({ repoRoot: tmpDir });
+        const result = await runLoopCommand(command, [
+            "run",
+            "POL-99",
+            "--state-file",
+            stateFile,
+            "--dry-run",
+        ]);
+        (0, vitest_1.expect)(result.exitCode).toBe(1);
+        (0, vitest_1.expect)(result.stderr).toContain("Polaris parent loop halted: state-invalid");
+        (0, vitest_1.expect)(result.stderr).toContain("current-state.json is invalid");
+    });
+    (0, vitest_1.it)("CLI loop run exits 1 with an ANALYZE parent message", async () => {
+        const calls = [];
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(makeMockAdapter([SUCCESS_RESULT], calls));
+        const stateFile = makeStateFileWithMeta(tmpDir, ["POL-100"], { "POL-99": { title: "ANALYZE: Split execution architecture" } });
+        const command = (0, index_js_1.createLoopCommand)({ repoRoot: tmpDir });
+        const result = await runLoopCommand(command, [
+            "run",
+            "POL-99",
+            "--state-file",
+            stateFile,
+            "--dry-run",
+        ]);
+        (0, vitest_1.expect)(result.exitCode).toBe(1);
+        (0, vitest_1.expect)(result.stderr).toContain("Polaris parent loop halted: analyze-parent");
+        (0, vitest_1.expect)(result.stderr).toContain("polaris-run targets IMPLEMENT parents");
+        (0, vitest_1.expect)(calls).toHaveLength(0);
+    });
+});