@lsctech/polaris 0.1.0

package/dist/loop/dispatch.test.js

@@ -0,0 +1,499 @@
+"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 dispatch_js_1 = require("./dispatch.js");
+const checkpoint_js_1 = require("./checkpoint.js");
+const run_bootstrap_js_1 = require("./run-bootstrap.js");
+function makeTestDir() {
+    const dir = (0, node_path_1.join)((0, node_os_1.tmpdir)(), `polaris-dispatch-test-${Date.now()}-${Math.random().toString(16).slice(2)}`);
+    (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    (0, node_fs_1.mkdirSync)((0, node_path_1.join)(dir, ".git"), { recursive: true });
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(dir, ".git", "HEAD"), "ref: refs/heads/test-branch\n");
+    return dir;
+}
+function baseState(overrides = {}) {
+    return {
+        schema_version: "1.0",
+        run_id: "pol-142-session-1",
+        cluster_id: "POL-142",
+        session_type: "implement",
+        branch: "test-branch",
+        active_child: "",
+        completed_children: ["POL-144"],
+        open_children: ["POL-145", "POL-146"],
+        open_children_meta: {
+            "POL-145": { title: "Add dispatch command", labels: ["implement"] },
+            "POL-146": { title: "Parent delivery", labels: ["implement"] },
+        },
+        step_cursor: "checkpoint",
+        context_budget: { children_completed: 1, max_children_per_session: 3 },
+        status: "running",
+        next_open_child: "POL-145",
+        dispatch_boundary: { dispatch_epoch: 1, continue_epoch: 1, last_dispatched_child: "POL-144" },
+        run_bootstrap_seal: (0, run_bootstrap_js_1.createBootstrapSeal)("pol-142-session-1", "POL-142", ["POL-145", "POL-146"]),
+        ...overrides,
+    };
+}
+function writeState(dir, state) {
+    const stateFile = (0, node_path_1.join)(dir, ".taskchain_artifacts", "polaris-run", "current-state.json");
+    (0, node_fs_1.mkdirSync)((0, node_path_1.join)(dir, ".taskchain_artifacts", "polaris-run"), { recursive: true });
+    (0, node_fs_1.writeFileSync)(stateFile, JSON.stringify(state, null, 2), "utf-8");
+    return stateFile;
+}
+function captureStdout(fn) {
+    const chunks = [];
+    const originalWrite = process.stdout.write.bind(process.stdout);
+    process.stdout.write = (chunk) => {
+        chunks.push(chunk.toString());
+        return true;
+    };
+    try {
+        fn();
+    }
+    finally {
+        process.stdout.write = originalWrite;
+    }
+    return chunks.join("");
+}
+function expectDispatchError(fn) {
+    const chunks = [];
+    const exitSpy = vitest_1.vi.spyOn(process, "exit").mockImplementation(() => {
+        throw new Error("process.exit called");
+    });
+    const originalWrite = process.stderr.write.bind(process.stderr);
+    process.stderr.write = (chunk) => {
+        chunks.push(chunk.toString());
+        return true;
+    };
+    try {
+        (0, vitest_1.expect)(fn).toThrow("process.exit called");
+        (0, vitest_1.expect)(exitSpy).toHaveBeenCalledWith(1);
+    }
+    finally {
+        process.stderr.write = originalWrite;
+        exitSpy.mockRestore();
+    }
+    return chunks.join("");
+}
+(0, vitest_1.describe)("runLoopDispatch", () => {
+    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)("dispatches first open child when no --child is specified", () => {
+        const stateFile = writeState(testDir, baseState());
+        const output = captureStdout(() => (0, dispatch_js_1.runLoopDispatch)({ repoRoot: testDir, stateFile }));
+        const packet = JSON.parse(output);
+        const updated = (0, checkpoint_js_1.readState)(stateFile);
+        (0, vitest_1.expect)(packet.schema_version).toBe("2.1");
+        (0, vitest_1.expect)(packet.active_child).toBe("POL-145");
+        (0, vitest_1.expect)(updated.active_child).toBe("POL-145");
+        (0, vitest_1.expect)(updated.open_children).toEqual(["POL-145", "POL-146"]);
+    });
+    (0, vitest_1.it)("dispatches named child when --child is specified", () => {
+        const stateFile = writeState(testDir, baseState());
+        const output = captureStdout(() => (0, dispatch_js_1.runLoopDispatch)({ repoRoot: testDir, stateFile, childId: "POL-146" }));
+        const packet = JSON.parse(output);
+        const updated = (0, checkpoint_js_1.readState)(stateFile);
+        (0, vitest_1.expect)(packet.active_child).toBe("POL-146");
+        (0, vitest_1.expect)(packet.instructions.issue_context).toMatchObject({ id: "POL-146" });
+        (0, vitest_1.expect)(updated.active_child).toBe("POL-146");
+    });
+    (0, vitest_1.it)("errors when active_child is already set", () => {
+        const stateFile = writeState(testDir, baseState({ active_child: "POL-145" }));
+        const stderr = expectDispatchError(() => (0, dispatch_js_1.runLoopDispatch)({ repoRoot: testDir, stateFile }));
+        (0, vitest_1.expect)(stderr).toContain("active_child is already set");
+    });
+    (0, vitest_1.it)("errors when open_children is empty", () => {
+        const stateFile = writeState(testDir, baseState({ completed_children: ["POL-144", "POL-145"], open_children: [] }));
+        const stderr = expectDispatchError(() => (0, dispatch_js_1.runLoopDispatch)({ repoRoot: testDir, stateFile }));
+        (0, vitest_1.expect)(stderr).toContain("no open children");
+    });
+    (0, vitest_1.it)("claims active_child without advancing completion state", () => {
+        const stateFile = writeState(testDir, baseState());
+        captureStdout(() => (0, dispatch_js_1.runLoopDispatch)({ repoRoot: testDir, stateFile }));
+        const updated = (0, checkpoint_js_1.readState)(stateFile);
+        (0, vitest_1.expect)(updated.active_child).toBe("POL-145");
+        (0, vitest_1.expect)(updated.completed_children).toEqual(["POL-144"]);
+        (0, vitest_1.expect)(updated.open_children).toEqual(["POL-145", "POL-146"]);
+        (0, vitest_1.expect)(updated.status).toBe("running");
+    });
+    (0, vitest_1.it)("emits exactly one child-dispatched JSONL event", () => {
+        const artifactDir = (0, node_path_1.join)(testDir, ".taskchain_artifacts", "polaris-run");
+        const stateFile = writeState(testDir, baseState({ artifact_dir: artifactDir }));
+        captureStdout(() => (0, dispatch_js_1.runLoopDispatch)({ repoRoot: testDir, stateFile }));
+        const telemetryFile = (0, node_path_1.join)(artifactDir, "runs", "pol-142-session-1", "telemetry.jsonl");
+        (0, vitest_1.expect)((0, node_fs_1.existsSync)(telemetryFile)).toBe(true);
+        const events = (0, node_fs_1.readFileSync)(telemetryFile, "utf-8")
+            .trim()
+            .split("\n")
+            .map((line) => JSON.parse(line))
+            .filter((event) => event.event === "child-dispatched");
+        (0, vitest_1.expect)(events).toHaveLength(1);
+        (0, vitest_1.expect)(events[0]).toMatchObject({
+            run_id: "pol-142-session-1",
+            child_id: "POL-145",
+        });
+    });
+    (0, vitest_1.it)("appends child-dispatched to the global ledger and creates it when absent", () => {
+        const artifactDir = (0, node_path_1.join)(testDir, ".taskchain_artifacts", "polaris-run");
+        const stateFile = writeState(testDir, baseState({ artifact_dir: artifactDir }));
+        captureStdout(() => (0, dispatch_js_1.runLoopDispatch)({ repoRoot: testDir, stateFile }));
+        const ledgerFile = (0, node_path_1.join)(testDir, ".polaris", "runs", "ledger.jsonl");
+        (0, vitest_1.expect)((0, node_fs_1.existsSync)(ledgerFile)).toBe(true);
+        const events = (0, node_fs_1.readFileSync)(ledgerFile, "utf-8")
+            .trim()
+            .split("\n")
+            .map((line) => JSON.parse(line));
+        (0, vitest_1.expect)(events).toHaveLength(1);
+        (0, vitest_1.expect)(events[0]).toMatchObject({
+            event: "child-dispatched",
+            run_id: "pol-142-session-1",
+            run_type: "implement",
+            cluster_id: "POL-142",
+            issue_id: "POL-145",
+            branch: "test-branch",
+            status: "child-dispatched",
+            completed_children: ["POL-144"],
+            open_children: ["POL-145", "POL-146"],
+            next_child: "POL-145",
+            last_commit: null,
+            pr_url: null,
+            dispatch_epoch: 2,
+        });
+    });
+    // ── REGRESSION TESTS: Dispatch durable evidence ─────────────────────────────
+    (0, vitest_1.it)("writes packet artifact to cluster-scoped layout", () => {
+        const stateFile = writeState(testDir, baseState());
+        captureStdout(() => (0, dispatch_js_1.runLoopDispatch)({ repoRoot: testDir, stateFile }));
+        // Check that packet was written to cluster-scoped directory
+        const clusterPacketDir = (0, node_path_1.join)(testDir, ".polaris", "clusters", "POL-142", "packets");
+        (0, vitest_1.expect)((0, node_fs_1.existsSync)(clusterPacketDir)).toBe(true);
+        // Get the actual dispatched state to find the packet path
+        const updated = (0, checkpoint_js_1.readState)(stateFile);
+        const dispatchRecord = updated.open_children_meta?.["POL-145"]?.dispatch_record;
+        (0, vitest_1.expect)(dispatchRecord).toBeDefined();
+        (0, vitest_1.expect)(dispatchRecord?.packet_path).toBeDefined();
+        const absolutePacketPath = (0, node_path_1.resolve)(testDir, dispatchRecord?.packet_path);
+        (0, vitest_1.expect)((0, node_fs_1.existsSync)(absolutePacketPath)).toBe(true);
+        // Read the packet and verify it contains expected fields
+        const packet = JSON.parse((0, node_fs_1.readFileSync)(absolutePacketPath, "utf-8"));
+        (0, vitest_1.expect)(packet.schema_version).toBe("2.1");
+        (0, vitest_1.expect)(packet.active_child).toBe("POL-145");
+        (0, vitest_1.expect)(packet.run_id).toBe("pol-142-session-1");
+        (0, vitest_1.expect)(packet.cluster_id).toBe("POL-142");
+    });
+    (0, vitest_1.it)("records dispatch_record with packet and result paths in open_children_meta", () => {
+        const stateFile = writeState(testDir, baseState());
+        captureStdout(() => (0, dispatch_js_1.runLoopDispatch)({ repoRoot: testDir, stateFile }));
+        const updated = (0, checkpoint_js_1.readState)(stateFile);
+        const childMeta = updated.open_children_meta?.["POL-145"];
+        (0, vitest_1.expect)(childMeta).toBeDefined();
+        (0, vitest_1.expect)(childMeta?.dispatch_record).toBeDefined();
+        const dispatchRecord = childMeta?.dispatch_record;
+        (0, vitest_1.expect)(dispatchRecord?.child_id).toBe("POL-145");
+        (0, vitest_1.expect)(dispatchRecord?.run_id).toBe("pol-142-session-1");
+        (0, vitest_1.expect)(dispatchRecord?.cluster_id).toBe("POL-142");
+        (0, vitest_1.expect)(dispatchRecord?.status).toBe("dispatched");
+        // Verify paths are set and exist
+        (0, vitest_1.expect)(dispatchRecord?.packet_path).toBeDefined();
+        (0, vitest_1.expect)((0, node_fs_1.existsSync)((0, node_path_1.resolve)(testDir, dispatchRecord?.packet_path))).toBe(true);
+        // Verify expected result path is set (won't exist yet - worker creates it)
+        (0, vitest_1.expect)(dispatchRecord?.expected_result_path).toBeDefined();
+        (0, vitest_1.expect)(dispatchRecord?.expected_result_path).toContain("results");
+        (0, vitest_1.expect)(dispatchRecord?.expected_result_path).toContain("POL-145");
+    });
+    (0, vitest_1.it)("telemetry includes packet_path and expected_result_path", () => {
+        const artifactDir = (0, node_path_1.join)(testDir, ".taskchain_artifacts", "polaris-run");
+        const stateFile = writeState(testDir, baseState({ artifact_dir: artifactDir }));
+        captureStdout(() => (0, dispatch_js_1.runLoopDispatch)({ repoRoot: testDir, stateFile }));
+        const telemetryFile = (0, node_path_1.join)(artifactDir, "runs", "pol-142-session-1", "telemetry.jsonl");
+        (0, vitest_1.expect)((0, node_fs_1.existsSync)(telemetryFile)).toBe(true);
+        const events = (0, node_fs_1.readFileSync)(telemetryFile, "utf-8")
+            .trim()
+            .split("\n")
+            .map((line) => JSON.parse(line))
+            .filter((event) => event.event === "child-dispatched");
+        (0, vitest_1.expect)(events).toHaveLength(1);
+        (0, vitest_1.expect)(events[0].packet_path).toBeDefined();
+        (0, vitest_1.expect)(events[0].expected_result_path).toBeDefined();
+        (0, vitest_1.expect)(events[0].packet_path).toContain("POL-142");
+        (0, vitest_1.expect)(events[0].packet_path).toContain("packets");
+    });
+    // ── DISPATCH MODE TESTS ────────────────────────────────────────────────────
+    (0, vitest_1.it)("records delegated dispatch mode when no provider specified", () => {
+        const stateFile = writeState(testDir, baseState());
+        captureStdout(() => (0, dispatch_js_1.runLoopDispatch)({ repoRoot: testDir, stateFile }));
+        const updated = (0, checkpoint_js_1.readState)(stateFile);
+        const dispatchRecord = updated.open_children_meta?.["POL-145"]?.dispatch_record;
+        (0, vitest_1.expect)(dispatchRecord).toBeDefined();
+        (0, vitest_1.expect)(dispatchRecord?.dispatch_mode).toBe("delegated");
+        (0, vitest_1.expect)(dispatchRecord?.runtime_state).toBe("delegated");
+        (0, vitest_1.expect)(dispatchRecord?.provider).toBeUndefined();
+    });
+    (0, vitest_1.it)("records direct-worker dispatch mode when provider is specified", () => {
+        const stateFile = writeState(testDir, baseState());
+        captureStdout(() => (0, dispatch_js_1.runLoopDispatch)({
+            repoRoot: testDir,
+            stateFile,
+            provider: "copilot"
+        }));
+        const updated = (0, checkpoint_js_1.readState)(stateFile);
+        const dispatchRecord = updated.open_children_meta?.["POL-145"]?.dispatch_record;
+        (0, vitest_1.expect)(dispatchRecord).toBeDefined();
+        (0, vitest_1.expect)(dispatchRecord?.dispatch_mode).toBe("direct-worker");
+        (0, vitest_1.expect)(dispatchRecord?.runtime_state).toBe("packet-created");
+        (0, vitest_1.expect)(dispatchRecord?.provider).toBe("copilot");
+    });
+    (0, vitest_1.it)("emits dispatch_mode and runtime_state in telemetry", () => {
+        const artifactDir = (0, node_path_1.join)(testDir, ".taskchain_artifacts", "polaris-run");
+        const stateFile = writeState(testDir, baseState({ artifact_dir: artifactDir }));
+        captureStdout(() => (0, dispatch_js_1.runLoopDispatch)({
+            repoRoot: testDir,
+            stateFile,
+            provider: "gemini"
+        }));
+        const telemetryFile = (0, node_path_1.join)(artifactDir, "runs", "pol-142-session-1", "telemetry.jsonl");
+        const events = (0, node_fs_1.readFileSync)(telemetryFile, "utf-8")
+            .trim()
+            .split("\n")
+            .map((line) => JSON.parse(line))
+            .filter((event) => event.event === "child-dispatched");
+        (0, vitest_1.expect)(events).toHaveLength(1);
+        (0, vitest_1.expect)(events[0].dispatch_mode).toBe("direct-worker");
+        (0, vitest_1.expect)(events[0].runtime_state).toBe("packet-created");
+        (0, vitest_1.expect)(events[0].provider).toBe("gemini");
+    });
+    // ── DELEGATED ASSIGNMENT TESTS (POL-220) ──────────────────────────────────
+    (0, vitest_1.it)("escalation path: emits all fallback telemetry events and sets pending-escalation when no subagent available", () => {
+        const artifactDir = (0, node_path_1.join)(testDir, ".taskchain_artifacts", "polaris-run");
+        const stateFile = writeState(testDir, baseState({ artifact_dir: artifactDir }));
+        // No subagent dispatcher registered — escalation path
+        captureStdout(() => (0, dispatch_js_1.runLoopDispatch)({ repoRoot: testDir, stateFile }));
+        const telemetryFile = (0, node_path_1.join)(artifactDir, "runs", "pol-142-session-1", "telemetry.jsonl");
+        const allEvents = (0, node_fs_1.readFileSync)(telemetryFile, "utf-8")
+            .trim()
+            .split("\n")
+            .map((line) => JSON.parse(line));
+        const attemptedEvents = allEvents.filter((e) => e.event === "worker-assignment-attempted");
+        const failedEvents = allEvents.filter((e) => e.event === "worker-assignment-failed");
+        const escalationEvents = allEvents.filter((e) => e.event === "escalation-initiated");
+        // Three attempts: subagent, external-process, human-handoff
+        (0, vitest_1.expect)(attemptedEvents).toHaveLength(3);
+        (0, vitest_1.expect)(attemptedEvents[0].assignment_type).toBe("subagent");
+        (0, vitest_1.expect)(attemptedEvents[1].assignment_type).toBe("external-process");
+        (0, vitest_1.expect)(attemptedEvents[2].assignment_type).toBe("human-handoff");
+        // Three failures
+        (0, vitest_1.expect)(failedEvents).toHaveLength(3);
+        (0, vitest_1.expect)(failedEvents[0].reason).toBe("no-subagent-support");
+        (0, vitest_1.expect)(failedEvents[1].reason).toBe("provider-unavailable");
+        (0, vitest_1.expect)(failedEvents[2].reason).toBe("provider-unavailable");
+        // One escalation-initiated
+        (0, vitest_1.expect)(escalationEvents).toHaveLength(1);
+        (0, vitest_1.expect)(escalationEvents[0].reason).toBeDefined();
+        (0, vitest_1.expect)(escalationEvents[0].recommended_action).toBe("manual-dispatch");
+        // All events have required base fields
+        for (const ev of [...attemptedEvents, ...failedEvents, ...escalationEvents]) {
+            (0, vitest_1.expect)(ev.event_id).toBeDefined();
+            (0, vitest_1.expect)(ev.dispatch_id).toBeDefined();
+            (0, vitest_1.expect)(ev.run_id).toBe("pol-142-session-1");
+            (0, vitest_1.expect)(ev.child_id).toBe("POL-145");
+            (0, vitest_1.expect)(ev.timestamp).toBeDefined();
+        }
+    });
+    (0, vitest_1.it)("escalation path: sets pending-escalation in worker_assignment on dispatch_record", () => {
+        const stateFile = writeState(testDir, baseState());
+        // No subagent dispatcher registered
+        captureStdout(() => (0, dispatch_js_1.runLoopDispatch)({ repoRoot: testDir, stateFile }));
+        const updated = (0, checkpoint_js_1.readState)(stateFile);
+        const dispatchRecord = updated.open_children_meta?.["POL-145"]?.dispatch_record;
+        (0, vitest_1.expect)(dispatchRecord?.worker_assignment).toBeDefined();
+        (0, vitest_1.expect)(dispatchRecord?.worker_assignment?.assignment_type).toBe("pending-escalation");
+        (0, vitest_1.expect)(dispatchRecord?.worker_assignment?.assigned_at).toBeDefined();
+        (0, vitest_1.expect)(dispatchRecord?.worker_assignment?.escalation_reason).toBeDefined();
+        (0, vitest_1.expect)(dispatchRecord?.session_id).toBeNull();
+        (0, vitest_1.expect)(dispatchRecord?.attachment_capable).toBe(false);
+        (0, vitest_1.expect)(dispatchRecord?.runtime_state).toBe("delegated");
+    });
+    (0, vitest_1.it)("successful subagent assignment: sets worker_assignment with subagent session_id", () => {
+        const stateFile = writeState(testDir, baseState());
+        // Register a mock subagent dispatcher
+        const mockDispatcher = vitest_1.vi.fn().mockResolvedValue(JSON.stringify({ child_id: "POL-145", status: "done", validation_summary: "ok", next_action: "continue" }));
+        globalThis.__POLARIS_AGENT_SUBTASK_DISPATCH__ = mockDispatcher;
+        try {
+            captureStdout(() => (0, dispatch_js_1.runLoopDispatch)({ repoRoot: testDir, stateFile }));
+            const updated = (0, checkpoint_js_1.readState)(stateFile);
+            const dispatchRecord = updated.open_children_meta?.["POL-145"]?.dispatch_record;
+            (0, vitest_1.expect)(dispatchRecord?.worker_assignment).toBeDefined();
+            (0, vitest_1.expect)(dispatchRecord?.worker_assignment?.assignment_type).toBe("subagent");
+            (0, vitest_1.expect)(dispatchRecord?.worker_assignment?.assigned_at).toBeDefined();
+            (0, vitest_1.expect)(dispatchRecord?.worker_assignment?.subagent_session_id).toBeDefined();
+            (0, vitest_1.expect)(typeof dispatchRecord?.worker_assignment?.subagent_session_id).toBe("string");
+            (0, vitest_1.expect)(dispatchRecord?.session_id).toBe(dispatchRecord?.worker_assignment?.subagent_session_id);
+            (0, vitest_1.expect)(dispatchRecord?.attachment_capable).toBe(false);
+            (0, vitest_1.expect)(dispatchRecord?.runtime_state).toBe("delegated");
+        }
+        finally {
+            delete globalThis.__POLARIS_AGENT_SUBTASK_DISPATCH__;
+        }
+    });
+    (0, vitest_1.it)("successful subagent assignment: emits worker-assignment-attempted and worker-assigned events", () => {
+        const artifactDir = (0, node_path_1.join)(testDir, ".taskchain_artifacts", "polaris-run");
+        const stateFile = writeState(testDir, baseState({ artifact_dir: artifactDir }));
+        const mockDispatcher = vitest_1.vi.fn().mockResolvedValue(JSON.stringify({ child_id: "POL-145", status: "done", validation_summary: "ok", next_action: "continue" }));
+        globalThis.__POLARIS_AGENT_SUBTASK_DISPATCH__ = mockDispatcher;
+        try {
+            captureStdout(() => (0, dispatch_js_1.runLoopDispatch)({ repoRoot: testDir, stateFile }));
+            const telemetryFile = (0, node_path_1.join)(artifactDir, "runs", "pol-142-session-1", "telemetry.jsonl");
+            const allEvents = (0, node_fs_1.readFileSync)(telemetryFile, "utf-8")
+                .trim()
+                .split("\n")
+                .map((line) => JSON.parse(line));
+            const attemptedEvents = allEvents.filter((e) => e.event === "worker-assignment-attempted");
+            const assignedEvents = allEvents.filter((e) => e.event === "worker-assigned");
+            const failedEvents = allEvents.filter((e) => e.event === "worker-assignment-failed");
+            const escalationEvents = allEvents.filter((e) => e.event === "escalation-initiated");
+            // Only one attempt (subagent succeeds)
+            (0, vitest_1.expect)(attemptedEvents).toHaveLength(1);
+            (0, vitest_1.expect)(attemptedEvents[0].assignment_type).toBe("subagent");
+            // One assigned event
+            (0, vitest_1.expect)(assignedEvents).toHaveLength(1);
+            (0, vitest_1.expect)(assignedEvents[0].assignment_type).toBe("subagent");
+            (0, vitest_1.expect)(assignedEvents[0].subagent_session_id).toBeDefined();
+            // No failures or escalations
+            (0, vitest_1.expect)(failedEvents).toHaveLength(0);
+            (0, vitest_1.expect)(escalationEvents).toHaveLength(0);
+        }
+        finally {
+            delete globalThis.__POLARIS_AGENT_SUBTASK_DISPATCH__;
+        }
+    });
+    (0, vitest_1.it)("direct-worker mode: no assignment events emitted (provider specified)", () => {
+        const artifactDir = (0, node_path_1.join)(testDir, ".taskchain_artifacts", "polaris-run");
+        const stateFile = writeState(testDir, baseState({ artifact_dir: artifactDir }));
+        captureStdout(() => (0, dispatch_js_1.runLoopDispatch)({ repoRoot: testDir, stateFile, provider: "copilot" }));
+        const telemetryFile = (0, node_path_1.join)(artifactDir, "runs", "pol-142-session-1", "telemetry.jsonl");
+        const allEvents = (0, node_fs_1.readFileSync)(telemetryFile, "utf-8")
+            .trim()
+            .split("\n")
+            .map((line) => JSON.parse(line));
+        const assignmentEvents = allEvents.filter((e) => ["worker-assignment-attempted", "worker-assigned", "worker-assignment-failed", "escalation-initiated"].includes(e.event));
+        (0, vitest_1.expect)(assignmentEvents).toHaveLength(0);
+    });
+    (0, vitest_1.it)("direct-worker mode: no worker_assignment on dispatch_record", () => {
+        const stateFile = writeState(testDir, baseState());
+        captureStdout(() => (0, dispatch_js_1.runLoopDispatch)({ repoRoot: testDir, stateFile, provider: "copilot" }));
+        const updated = (0, checkpoint_js_1.readState)(stateFile);
+        const dispatchRecord = updated.open_children_meta?.["POL-145"]?.dispatch_record;
+        (0, vitest_1.expect)(dispatchRecord?.worker_assignment).toBeUndefined();
+    });
+    // ── Role context tests (POL-227 / POL-230) ──────────────────────────────────
+    (0, vitest_1.it)("impl packet includes worker role_context", () => {
+        const stateFile = writeState(testDir, baseState());
+        const output = captureStdout(() => (0, dispatch_js_1.runLoopDispatch)({ repoRoot: testDir, stateFile }));
+        const packet = JSON.parse(output);
+        (0, vitest_1.expect)(packet.role_context).toBeDefined();
+        (0, vitest_1.expect)(packet.role_context.role).toBe("worker");
+        (0, vitest_1.expect)(packet.role_context.role_authority).toBe("implementation");
+        (0, vitest_1.expect)(packet.role_context.may_implement).toBe(true);
+        (0, vitest_1.expect)(packet.role_context.may_assign_workers).toBe(false);
+        (0, vitest_1.expect)(Array.isArray(packet.role_context.prohibited_actions)).toBe(true);
+    });
+    (0, vitest_1.it)("dispatch record includes role fields from packet role_context", () => {
+        const stateFile = writeState(testDir, baseState());
+        captureStdout(() => (0, dispatch_js_1.runLoopDispatch)({ repoRoot: testDir, stateFile }));
+        const updated = (0, checkpoint_js_1.readState)(stateFile);
+        const dr = updated.open_children_meta?.["POL-145"]?.dispatch_record;
+        (0, vitest_1.expect)(dr?.role).toBe("worker");
+        (0, vitest_1.expect)(dr?.role_authority).toBe("implementation");
+        (0, vitest_1.expect)(dr?.may_implement).toBe(true);
+        (0, vitest_1.expect)(dr?.session_type).toBe("implementation");
+    });
+    // ── Config provider routing (POL-228 scenario 2) ────────────────────────────
+    (0, vitest_1.it)("uses config provider as direct-worker when no --provider flag", () => {
+        // Write a polaris config with a configured provider
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(testDir, "polaris.config.json"), JSON.stringify({ execution: { adapter: "terminal-cli", providers: { codex: { command: "codex" } }, rotation: ["codex"] } }), "utf-8");
+        const stateFile = writeState(testDir, baseState());
+        const output = captureStdout(() => (0, dispatch_js_1.runLoopDispatch)({ repoRoot: testDir, stateFile }));
+        const packet = JSON.parse(output);
+        const updated = (0, checkpoint_js_1.readState)(stateFile);
+        const dr = updated.open_children_meta?.["POL-145"]?.dispatch_record;
+        (0, vitest_1.expect)(dr?.dispatch_mode).toBe("direct-worker");
+        (0, vitest_1.expect)(dr?.provider).toBe("codex");
+        (0, vitest_1.expect)(packet.role_context.role).toBe("worker");
+    });
+    // ── Acknowledgment timeout detection (POL-228 scenario B + E) ───────────────
+    (0, vitest_1.it)("checkAcknowledgmentTimeout returns null when no active child", () => {
+        const stateFile = writeState(testDir, baseState());
+        const result = (0, dispatch_js_1.checkAcknowledgmentTimeout)({ stateFile, repoRoot: testDir });
+        (0, vitest_1.expect)(result).toBeNull();
+    });
+    (0, vitest_1.it)("checkAcknowledgmentTimeout detects no-acknowledgment timeout", () => {
+        const pastTime = new Date(Date.now() - 60_000).toISOString(); // 60s ago
+        const stateFile = writeState(testDir, baseState({
+            active_child: "POL-145",
+            open_children_meta: {
+                "POL-145": {
+                    title: "Test child",
+                    dispatch_record: {
+                        dispatch_id: "test-dispatch-001",
+                        child_id: "POL-145",
+                        run_id: "pol-142-session-1",
+                        cluster_id: "POL-142",
+                        packet_path: "/tmp/packet.json",
+                        expected_result_path: "/tmp/result.json",
+                        dispatched_at: pastTime,
+                        status: "dispatched",
+                        dispatch_mode: "direct-worker",
+                        runtime_state: "launching",
+                        worker_id: "worker-001", // Has worker_id but no first_heartbeat_at
+                    },
+                },
+            },
+        }));
+        const result = (0, dispatch_js_1.checkAcknowledgmentTimeout)({
+            stateFile,
+            repoRoot: testDir,
+            launchToFirstHeartbeatMs: 30_000,
+        });
+        (0, vitest_1.expect)(result).not.toBeNull();
+        (0, vitest_1.expect)(result?.orphaned).toBe(true);
+        (0, vitest_1.expect)(result?.reason).toBe("no-acknowledgment");
+        (0, vitest_1.expect)(result?.childId).toBe("POL-145");
+    });
+    (0, vitest_1.it)("checkAcknowledgmentTimeout returns not-orphaned for fresh dispatch", () => {
+        const stateFile = writeState(testDir, baseState({
+            active_child: "POL-145",
+            open_children_meta: {
+                "POL-145": {
+                    title: "Test child",
+                    dispatch_record: {
+                        dispatch_id: "test-dispatch-001",
+                        child_id: "POL-145",
+                        run_id: "pol-142-session-1",
+                        cluster_id: "POL-142",
+                        packet_path: "/tmp/packet.json",
+                        expected_result_path: "/tmp/result.json",
+                        dispatched_at: new Date().toISOString(), // Just dispatched
+                        status: "dispatched",
+                        dispatch_mode: "direct-worker",
+                        runtime_state: "launching",
+                        worker_id: "worker-001",
+                    },
+                },
+            },
+        }));
+        const result = (0, dispatch_js_1.checkAcknowledgmentTimeout)({
+            stateFile,
+            repoRoot: testDir,
+            launchToFirstHeartbeatMs: 30_000,
+        });
+        (0, vitest_1.expect)(result?.orphaned).toBe(false);
+    });
+});

package/dist/loop/ephemeral-smoke.test.js

@@ -0,0 +1,160 @@
+"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 = "ephemeral-smoke-run";
+    const clusterId = overrides["cluster_id"] ?? "POL-105";
+    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-105",
+        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 makeAdapter(calls) {
+    const result = {
+        exit_code: 0,
+        provider_used: "agent-subtask",
+        command_run: "agent-subtask:POL-112",
+        summary: JSON.stringify({
+            child_id: "POL-112",
+            status: "done",
+            commit_hash: "abc1120",
+            validation_summary: "ephemeral smoke passed",
+            next_action: "resume-parent",
+        }),
+    };
+    return {
+        name: "agent-subtask",
+        async dispatch(packet, options) {
+            calls.push({ packet, options });
+            return result;
+        },
+    };
+}
+(0, vitest_1.describe)("ephemeral execution smoke", () => {
+    let tmpDir;
+    (0, vitest_1.beforeEach)(() => {
+        tmpDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "polaris-ephemeral-smoke-"));
+        (0, node_fs_1.mkdirSync)((0, node_path_1.join)(tmpDir, "runs", "ephemeral-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)("rejects an ANALYZE parent before dispatch", async () => {
+        const calls = [];
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(makeAdapter(calls));
+        const stateFile = writeState(tmpDir, {
+            cluster_id: "POL-200",
+            open_children: ["POL-201"],
+            next_open_child: "POL-201",
+            open_children_meta: {
+                "POL-200": { title: "ANALYZE: Ephemeral execution split" },
+                "POL-201": { title: "IMPLEMENT: unreachable child" },
+            },
+        });
+        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.expect)(registry_js_1.createAdapter).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)("dispatches one child through the ephemeral adapter and records state plus telemetry", async () => {
+        const calls = [];
+        vitest_1.vi.mocked(registry_js_1.createAdapter).mockReturnValue(makeAdapter(calls));
+        const stateFile = writeState(tmpDir, {
+            orchestration_mode: "ephemeral",
+            open_children: ["POL-112"],
+            next_open_child: "POL-112",
+            open_children_meta: {
+                "POL-105": { title: "IMPLEMENT: Issue hierarchy and ephemeral execution refactor" },
+                "POL-112": { title: "IMPLEMENT: Write Polaris ephemeral execution smoke test and validation harness" },
+            },
+        });
+        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);
+        (0, vitest_1.expect)(calls[0].packet.active_child).toBe("POL-112");
+        (0, vitest_1.expect)(calls[0].options.provider).toBe("agent-subtask");
+        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(["POL-112"]);
+        (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("abc1120");
+        (0, vitest_1.expect)(updatedState.context_budget).toMatchObject({ children_completed: 1 });
+        const telemetry = readJsonLines((0, node_path_1.join)(tmpDir, "runs", "ephemeral-smoke-run", "telemetry.jsonl"));
+        (0, vitest_1.expect)(telemetry).toEqual(vitest_1.expect.arrayContaining([
+            vitest_1.expect.objectContaining({
+                event: "child-dispatched",
+                child_id: "POL-112",
+                adapter: "agent-subtask",
+                orchestration_mode: "ephemeral",
+                provider: "agent-subtask",
+            }),
+            vitest_1.expect.objectContaining({
+                event: "child-complete",
+                child_id: "POL-112",
+                children_completed: 1,
+            }),
+        ]));
+    });
+});