@lsctech/polaris 0.1.0

package/dist/loop/adapters/agent-subtask.test.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const agent_subtask_js_1 = require("./agent-subtask.js");
+const worker_packet_js_1 = require("../worker-packet.js");
+function makePacket(overrides = {}) {
+    return {
+        schema_version: "1.0",
+        run_id: "run-001",
+        cluster_id: "POL-105",
+        active_child: "POL-110",
+        state_file: "/repo/.taskchain_artifacts/polaris-run/current-state.json",
+        telemetry_file: "/repo/.taskchain_artifacts/polaris-run/runs/run-001/telemetry.jsonl",
+        context: { branch: "feature/pol-105" },
+        ...overrides,
+    };
+}
+(0, vitest_1.describe)("AgentSubtaskAdapter", () => {
+    (0, vitest_1.it)("dispatches an ephemeral bootstrap packet through the native subtask dispatcher", async () => {
+        const packet = makePacket();
+        const adapter = new agent_subtask_js_1.AgentSubtaskAdapter(async (request) => {
+            (0, vitest_1.expect)(request.packet).toEqual(packet);
+            (0, vitest_1.expect)(request.instructions).toContain("ephemeral");
+            (0, vitest_1.expect)(request.instructions).toContain("POL-110");
+            (0, vitest_1.expect)(request.returnContract).toEqual([
+                "child_id",
+                "status",
+                "commit_hash",
+                "validation_summary",
+                "next_action",
+                "warnings",
+            ]);
+            return {
+                child_id: "POL-110",
+                status: "done",
+                commit_hash: "abc1234",
+                validation_summary: "passed",
+                next_action: "resume-parent",
+                warnings: [],
+            };
+        });
+        const result = await adapter.dispatch(packet, { provider: "agent-subtask" });
+        (0, vitest_1.expect)(result).toMatchObject({
+            exit_code: 0,
+            provider_used: "agent-subtask",
+            command_run: "agent-subtask:POL-110",
+        });
+        (0, vitest_1.expect)(JSON.parse(result.summary ?? "{}")).toMatchObject({
+            child_id: "POL-110",
+            status: "done",
+            commit_hash: "abc1234",
+        });
+    });
+    (0, vitest_1.it)("returns a dispatch error result when native subtask dispatch fails", async () => {
+        const adapter = new agent_subtask_js_1.AgentSubtaskAdapter(async () => {
+            throw new Error("native dispatch unavailable");
+        });
+        const result = await adapter.dispatch(makePacket(), { provider: "agent-subtask" });
+        (0, vitest_1.expect)(result.exit_code).toBe(1);
+        (0, vitest_1.expect)(result.provider_used).toBe("agent-subtask");
+        (0, vitest_1.expect)(result.stderr).toContain("native dispatch unavailable");
+        (0, vitest_1.expect)(result.summary).toContain("native dispatch unavailable");
+    });
+});
+// ── WorkerPacket (compiled) dispatch ──────────────────────────────────────────
+const WORKER_PACKET_BASE = {
+    runId: "run-001",
+    clusterId: "POL-120",
+    branch: "feature/pol-120",
+    stateFile: "/repo/.taskchain_artifacts/polaris-run/current-state.json",
+    telemetryFile: "/repo/.taskchain_artifacts/polaris-run/runs/run-001/telemetry.jsonl",
+};
+(0, vitest_1.describe)("AgentSubtaskAdapter — compiled WorkerPacket", () => {
+    (0, vitest_1.it)("uses pre-compiled instructions from WorkerPacket instead of generating them", async () => {
+        const packet = (0, worker_packet_js_1.compileImplPacket)({ ...WORKER_PACKET_BASE, childId: "POL-121" });
+        let capturedInstructions = "";
+        const adapter = new agent_subtask_js_1.AgentSubtaskAdapter(async (request) => {
+            capturedInstructions = request.instructions;
+            return {
+                child_id: "POL-121",
+                status: "done",
+                commit_hash: "abc1234",
+                validation_summary: "passed",
+                next_action: "resume-parent",
+                warnings: [],
+            };
+        });
+        const result = await adapter.dispatch(packet, { provider: "agent-subtask" });
+        (0, vitest_1.expect)(result.exit_code).toBe(0);
+        // Compiled instructions must contain the primary_goal, not generic "ephemeral" boilerplate
+        (0, vitest_1.expect)(capturedInstructions).toContain(packet.instructions.primary_goal);
+        (0, vitest_1.expect)(capturedInstructions).toContain("impl");
+        (0, vitest_1.expect)(capturedInstructions).toContain("TERMINATE");
+    });
+    (0, vitest_1.it)("includes lifecycle teardown notice in compiled instructions", async () => {
+        const packet = (0, worker_packet_js_1.compileImplPacket)({ ...WORKER_PACKET_BASE, childId: "POL-121" });
+        let capturedInstructions = "";
+        const adapter = new agent_subtask_js_1.AgentSubtaskAdapter(async (request) => {
+            capturedInstructions = request.instructions;
+            return { child_id: "POL-121", status: "done" };
+        });
+        await adapter.dispatch(packet, { provider: "agent-subtask" });
+        (0, vitest_1.expect)(capturedInstructions).toContain("LIFECYCLE CONTRACT");
+        (0, vitest_1.expect)(capturedInstructions).toContain("TERMINATE THIS SESSION IMMEDIATELY");
+    });
+    (0, vitest_1.it)("uses the return_contract from WorkerPacket, not the legacy fallback", async () => {
+        const packet = (0, worker_packet_js_1.compileImplPacket)({ ...WORKER_PACKET_BASE, childId: "POL-121" });
+        let capturedContract = [];
+        const adapter = new agent_subtask_js_1.AgentSubtaskAdapter(async (request) => {
+            capturedContract = request.returnContract;
+            return { child_id: "POL-121", status: "done" };
+        });
+        await adapter.dispatch(packet, { provider: "agent-subtask" });
+        (0, vitest_1.expect)(capturedContract).toEqual(packet.return_contract);
+        // Compiled contract must not contain legacy-only fields
+        (0, vitest_1.expect)(capturedContract).not.toContain("commit_hash");
+    });
+    (0, vitest_1.it)("dispatches finalize worker with empty active_child correctly", async () => {
+        const packet = (0, worker_packet_js_1.compileFinalizePacket)(WORKER_PACKET_BASE);
+        const adapter = new agent_subtask_js_1.AgentSubtaskAdapter(async (request) => {
+            // Finalize worker returns run_id instead of child_id
+            (0, vitest_1.expect)(request.instructions).toContain("finalize");
+            return { run_id: "run-001", status: "done", pr_url: "https://example.com/pr/1" };
+        });
+        // Finalize packet has active_child = "" — validation should not check child_id mismatch
+        const result = await adapter.dispatch(packet, { provider: "agent-subtask" });
+        (0, vitest_1.expect)(result.exit_code).toBe(0);
+    });
+    (0, vitest_1.it)("accepts lifecycle sealed-result status values for finalize workers", async () => {
+        const packet = (0, worker_packet_js_1.compileFinalizePacket)(WORKER_PACKET_BASE);
+        const adapter = new agent_subtask_js_1.AgentSubtaskAdapter(async () => ({
+            run_id: "run-001",
+            role: "finalize",
+            status: "success",
+            tracker_reconciliation_ready: true,
+        }));
+        const result = await adapter.dispatch(packet, { provider: "agent-subtask" });
+        (0, vitest_1.expect)(result.exit_code).toBe(0);
+        (0, vitest_1.expect)(JSON.parse(result.summary ?? "{}")).toMatchObject({
+            role: "finalize",
+            status: "success",
+        });
+    });
+    (0, vitest_1.it)("returns exit_code 1 with error when no dispatcher is configured", async () => {
+        const packet = (0, worker_packet_js_1.compileImplPacket)({ ...WORKER_PACKET_BASE, childId: "POL-121" });
+        const adapter = new agent_subtask_js_1.AgentSubtaskAdapter(undefined);
+        const result = await adapter.dispatch(packet, { provider: "agent-subtask" });
+        (0, vitest_1.expect)(result.exit_code).toBe(1);
+        (0, vitest_1.expect)(result.stderr).toContain("unavailable");
+    });
+});

package/dist/loop/adapters/cli-subtask-bridge.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installCliSubtaskBridge = installCliSubtaskBridge;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const loader_js_1 = require("../../config/loader.js");
+const terminal_cli_js_1 = require("./terminal-cli.js");
+function selectBridgeProvider(providers) {
+    const preferred = process.env.POLARIS_NATIVE_SUBTASK_PROVIDER?.trim();
+    if (preferred && preferred.length > 0 && Object.prototype.hasOwnProperty.call(providers, preferred)) {
+        return preferred;
+    }
+    if (Object.prototype.hasOwnProperty.call(providers, "copilot")) {
+        return "copilot";
+    }
+    return null;
+}
+function parseSummaryObject(summary) {
+    const trimmed = summary.trim();
+    if (trimmed.length === 0) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        const firstBrace = trimmed.indexOf("{");
+        const lastBrace = trimmed.lastIndexOf("}");
+        if (firstBrace >= 0 && lastBrace > firstBrace) {
+            const candidate = trimmed.slice(firstBrace, lastBrace + 1);
+            try {
+                const parsed = JSON.parse(candidate);
+                return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+                    ? parsed
+                    : null;
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    }
+}
+function normalizeSealedStatus(raw) {
+    const status = typeof raw === "string" ? raw.trim().toLowerCase() : "";
+    if (status === "done" || status === "success") {
+        return "success";
+    }
+    if (status === "blocked") {
+        return "blocked";
+    }
+    return "failure";
+}
+function writeSealedResultFromSummary(packet, parsedSummary) {
+    const resultFile = packet.result_file_contract?.result_file;
+    if (!resultFile) {
+        return;
+    }
+    const commit = (typeof parsedSummary["commit"] === "string" && parsedSummary["commit"]) ||
+        (typeof parsedSummary["commit_hash"] === "string" && parsedSummary["commit_hash"]) ||
+        undefined;
+    const validation = parsedSummary["validation"] ?? parsedSummary["validation_summary"];
+    const sealedResult = {
+        run_id: packet.run_id,
+        child_id: packet.active_child,
+        status: normalizeSealedStatus(parsedSummary["status"]),
+    };
+    if (commit) {
+        sealedResult["commit"] = commit;
+    }
+    if (validation !== undefined) {
+        sealedResult["validation"] = validation;
+    }
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(resultFile), { recursive: true });
+    (0, node_fs_1.writeFileSync)(resultFile, JSON.stringify(sealedResult, null, 2), "utf-8");
+}
+function installCliSubtaskBridge(repoRoot) {
+    const host = globalThis;
+    if (host.__POLARIS_AGENT_SUBTASK_DISPATCH__) {
+        return;
+    }
+    const config = (0, loader_js_1.loadConfig)(repoRoot);
+    const execution = config.execution;
+    if (!execution || !execution.providers) {
+        return;
+    }
+    const provider = selectBridgeProvider(execution.providers);
+    if (!provider) {
+        return;
+    }
+    const adapter = new terminal_cli_js_1.TerminalCliAdapter(execution);
+    host.__POLARIS_AGENT_SUBTASK_DISPATCH__ = async ({ packet }) => {
+        const result = await adapter.dispatch(packet, { provider });
+        const summary = result.summary ?? result.stdout ?? result.stderr ?? "";
+        if (result.exit_code !== 0) {
+            throw new Error(`CLI subtask bridge provider "${provider}" failed: ${summary || "no summary available"}`);
+        }
+        const parsedSummary = parseSummaryObject(summary);
+        if (!parsedSummary) {
+            throw new Error(`CLI subtask bridge provider "${provider}" returned non-JSON summary required for sealed result contract`);
+        }
+        writeSealedResultFromSummary(packet, parsedSummary);
+        return parsedSummary;
+    };
+}

package/dist/loop/adapters/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAdapter = exports.AgentSubtaskAdapter = exports.TerminalCliAdapter = void 0;
+var terminal_cli_js_1 = require("./terminal-cli.js");
+Object.defineProperty(exports, "TerminalCliAdapter", { enumerable: true, get: function () { return terminal_cli_js_1.TerminalCliAdapter; } });
+var agent_subtask_js_1 = require("./agent-subtask.js");
+Object.defineProperty(exports, "AgentSubtaskAdapter", { enumerable: true, get: function () { return agent_subtask_js_1.AgentSubtaskAdapter; } });
+var registry_js_1 = require("./registry.js");
+Object.defineProperty(exports, "createAdapter", { enumerable: true, get: function () { return registry_js_1.createAdapter; } });

package/dist/loop/adapters/registry.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAdapter = createAdapter;
+const agent_subtask_js_1 = require("./agent-subtask.js");
+const terminal_cli_js_1 = require("./terminal-cli.js");
+const SUPPORTED_ADAPTERS = ['terminal-cli', 'agent-subtask'];
+function createAdapter(adapterName, config) {
+    switch (adapterName) {
+        case 'terminal-cli':
+            return new terminal_cli_js_1.TerminalCliAdapter(config);
+        case 'agent-subtask':
+            return new agent_subtask_js_1.AgentSubtaskAdapter();
+        default:
+            throw new Error(`Unknown adapter "${adapterName}". ` +
+                `Supported adapters: ${SUPPORTED_ADAPTERS.join(', ')}.`);
+    }
+}