@lsctech/polaris 0.1.0

package/dist/loop/worker-packet.js

@@ -0,0 +1,406 @@
+"use strict";
+/**
+ * Compiled worker packet for delegated-chain execution.
+ *
+ * Instead of workers ingesting the full Polaris skill on each dispatch,
+ * the parent compiles a WorkerPacket containing pre-baked instructions,
+ * allowed scope, and lifecycle teardown rules. Workers read the packet
+ * and execute immediately — no skill re-ingestion required.
+ *
+ * WorkerPacket extends BootstrapPacket so all existing adapters that
+ * accept BootstrapPacket transparently accept WorkerPacket.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STARTUP_RETURN_CONTRACT = exports.PREFLIGHT_RETURN_CONTRACT = exports.WORKER_PROHIBITED_WRITE_PATHS = exports.FINALIZE_RETURN_CONTRACT = exports.IMPL_RETURN_CONTRACT = void 0;
+exports.roleContextForWorkerRole = roleContextForWorkerRole;
+exports.isWorkerPacket = isWorkerPacket;
+exports.getWorkerCommitPolicy = getWorkerCommitPolicy;
+exports.compileStartupPacket = compileStartupPacket;
+exports.compileImplPacket = compileImplPacket;
+exports.compileFinalizePacket = compileFinalizePacket;
+exports.compilePreflightPacket = compilePreflightPacket;
+const worker_prompt_js_1 = require("./worker-prompt.js");
+const body_parser_js_1 = require("./body-parser.js");
+const WORKER_ROLE_CONTEXT = {
+    role: 'worker',
+    role_authority: 'implementation',
+    may_implement: true,
+    may_assign_workers: false,
+    prohibited_actions: [
+        'modify-cluster-plan',
+        'dispatch-children',
+        'polaris-loop-dispatch',
+        'polaris-loop-continue',
+    ],
+};
+const FOREMAN_ROLE_CONTEXT = {
+    role: 'foreman',
+    role_authority: 'coordination-only',
+    may_implement: false,
+    may_assign_workers: true,
+    prohibited_actions: [
+        'inline-implementation',
+        'scope-expansion',
+        'skip-checkpoint',
+    ],
+};
+const ANALYSIS_ROLE_CONTEXT = {
+    role: 'analyst',
+    role_authority: 'analysis',
+    may_implement: false,
+    may_assign_workers: false,
+    prohibited_actions: [
+        'modify-cluster-plan',
+        'dispatch-children',
+        'polaris-loop-dispatch',
+        'polaris-loop-continue',
+        'inline-implementation',
+    ],
+};
+const LIBRARIAN_ROLE_CONTEXT = {
+    role: 'librarian',
+    role_authority: 'documentation',
+    may_implement: false,
+    may_assign_workers: false,
+    prohibited_actions: [
+        'modify-cluster-plan',
+        'dispatch-children',
+        'polaris-loop-dispatch',
+        'polaris-loop-continue',
+        'inline-implementation',
+    ],
+};
+function roleContextForWorkerRole(workerRole) {
+    switch (workerRole) {
+        case 'impl':
+        case 'validation':
+        case 'repair':
+            return WORKER_ROLE_CONTEXT;
+        case 'analysis':
+            return ANALYSIS_ROLE_CONTEXT;
+        case 'librarian':
+            return LIBRARIAN_ROLE_CONTEXT;
+        case 'startup':
+        case 'finalize':
+        case 'preflight':
+        default:
+            return FOREMAN_ROLE_CONTEXT;
+    }
+}
+/** Type guard: returns true when packet is a compiled WorkerPacket. */
+function isWorkerPacket(packet) {
+    const p = packet;
+    // Accept both '2.0' (legacy) and '2.1' (dispatch contract) schema versions
+    // role_context is not required for backward compat with packets that predate this field
+    const isV2 = (packet.schema_version === '2.0' || packet.schema_version === '2.1') &&
+        typeof p['worker_role'] === 'string' &&
+        typeof p['instructions'] === 'object' && p['instructions'] !== null && !Array.isArray(p['instructions']) &&
+        typeof p['lifecycle'] === 'object' && p['lifecycle'] !== null &&
+        Array.isArray(p['return_contract']);
+    if (!isV2) {
+        return false;
+    }
+    // result_file_contract is required on every v2.1 packet.
+    const rfc = p.result_file_contract;
+    if (rfc === null || rfc === undefined || typeof rfc !== 'object' || Array.isArray(rfc)) {
+        return false;
+    }
+    const rfcRecord = rfc;
+    return typeof rfcRecord.result_file === 'string';
+}
+// ── Return contracts ──────────────────────────────────────────────────────────
+exports.IMPL_RETURN_CONTRACT = [
+    'child_id',
+    'status',
+    'commit',
+    'validation',
+    'next_recommended_action',
+];
+exports.FINALIZE_RETURN_CONTRACT = [
+    'run_id',
+    'status',
+    'pr_url',
+    'commit',
+    'next_recommended_action',
+];
+exports.WORKER_PROHIBITED_WRITE_PATHS = [
+    ".taskchain_artifacts/",
+    ".polaris/clusters/",
+    ".polaris/runs/",
+    "**/telemetry.jsonl",
+];
+function getWorkerCommitPolicy(packet) {
+    return {
+        allowedScope: [...packet.instructions.allowed_scope],
+        prohibitedWritePaths: [...(packet.prohibited_write_paths ?? [])],
+    };
+}
+exports.PREFLIGHT_RETURN_CONTRACT = [
+    'status',
+    'checks_passed',
+    'blockers',
+    'next_recommended_action',
+];
+exports.STARTUP_RETURN_CONTRACT = [
+    'run_id',
+    'status',
+    'execution_plan',
+    'first_child',
+    'next_recommended_action',
+];
+// ── Lifecycle helpers ─────────────────────────────────────────────────────────
+function defaultLifecycle(maxConcurrent, cleanupOnExit) {
+    return {
+        terminate_after_completion: true,
+        max_concurrent: maxConcurrent,
+        cleanup_on_exit: cleanupOnExit,
+    };
+}
+/**
+ * Build a compiled startup worker packet.
+ * Startup workers prepare tracker/graph/config/run-state evidence; the parent
+ * consumes the sealed result before selecting the first implementation child.
+ */
+function compileStartupPacket(input) {
+    const steps = [
+        `Sync or import tracker data for cluster ${input.clusterId} when configured.`,
+        `Build or refresh the local execution graph for ${input.clusterId}.`,
+        `Validate Polaris config and the execution provider roster.`,
+        `Prepare run ledger/state evidence for ${input.runId}.`,
+        `Select the execution plan and first child without implementing it.`,
+        `Write compact startup JSON to stdout (fields: ${exports.STARTUP_RETURN_CONTRACT.join(', ')}).`,
+        `TERMINATE SESSION IMMEDIATELY.`,
+    ];
+    return {
+        schema_version: '2.1',
+        worker_role: 'startup',
+        run_id: input.runId,
+        cluster_id: input.clusterId,
+        active_child: '',
+        state_file: input.stateFile,
+        telemetry_file: input.telemetryFile,
+        instructions: {
+            primary_goal: `Startup cluster ${input.clusterId} for run ${input.runId}: sync tracker data, refresh graph, ` +
+                `validate config/providers, and return the first executable dispatch plan.`,
+            steps,
+            allowed_scope: [
+                '.taskchain_artifacts/**',
+                '.polaris/runs/**',
+                '.polaris/map/**',
+            ],
+            validation_commands: [],
+        },
+        lifecycle: defaultLifecycle(input.maxConcurrentWorkers ?? 1, 'commit-and-exit'),
+        return_contract: exports.STARTUP_RETURN_CONTRACT,
+        prompt_mode: 'full',
+        prompt_metrics: { mode: 'full', char_count: 0, estimated_tokens: 0 },
+        role_context: roleContextForWorkerRole('startup'),
+        result_file_contract: {
+            result_file: input.resultFile,
+            result_required_fields: Object.fromEntries([
+                ['run_id', input.runId],
+                ['cluster_id', input.clusterId],
+                ['child_id', '<active_child from packet>'],
+                ...exports.STARTUP_RETURN_CONTRACT.map(key => [key, `<${key}>`]),
+            ]),
+        },
+        context: {
+            branch: input.branch,
+            worker_role: 'startup',
+        },
+    };
+}
+/**
+ * Create a compiled implementation (impl) WorkerPacket for executing a single child task.
+ *
+ * If `input.issueContext.body` is present, `allowed_scope`, `validation_commands`, and requirement
+ * text are derived from the parsed body when corresponding explicit fields are not provided.
+ *
+ * @param input - Configuration and contextual data (run/cluster/child identifiers, file paths,
+ *   optional issueContext, scope/validation overrides, concurrency, prompt mode, and optional
+ *   result file) used to construct the packet
+ * @returns A WorkerPacket pre-populated with instructions, lifecycle, prompt data, role context,
+ *   and the IMPL return contract suitable for an implementation worker
+ */
+function compileImplPacket(input) {
+    const childRef = input.issueContext?.id ?? input.childId;
+    const childTitle = input.issueContext?.title ?? input.childId;
+    const promptMode = input.promptMode ?? 'compact';
+    // Derive scope/validation/requirements from body when not explicitly provided.
+    const bodyParsed = input.issueContext?.body ? (0, body_parser_js_1.parseIssueBody)(input.issueContext.body) : null;
+    const resolvedScope = input.allowedScope?.length
+        ? input.allowedScope
+        : bodyParsed?.scope ?? [];
+    const resolvedValidation = input.validationCommands?.length
+        ? input.validationCommands
+        : bodyParsed?.validationCommands ?? [];
+    const resolvedRequirements = input.issueContext?.key_requirements.length
+        ? input.issueContext.key_requirements
+        : bodyParsed?.requirements ?? [];
+    const requirementLines = resolvedRequirements.map((r, i) => `   ${i + 1}. ${r}`);
+    const bodyLines = input.issueContext?.body
+        ? [`Issue description:\n${input.issueContext.body}`]
+        : [];
+    const steps = [
+        `Verify: read ${input.stateFile} and confirm active_child === "${input.childId}".`,
+        `Implement ${childRef}: "${childTitle}".`,
+        ...bodyLines,
+        ...(requirementLines.length > 0 ? [`Requirements:`, ...requirementLines] : []),
+        `Run validation commands and confirm all pass.`,
+        `Create exactly ONE git commit: [${input.childId}] ${childTitle}.`,
+        `Do NOT modify open_children or completed_children in ${input.stateFile}. The parent runtime (loop continue) owns that state transition.`,
+        `Append a telemetry event to ${input.telemetryFile}.`,
+        `Write compact return JSON to stdout (fields: ${exports.IMPL_RETURN_CONTRACT.join(', ')}).`,
+        `TERMINATE SESSION IMMEDIATELY. Do not select or execute the next child.`,
+    ];
+    // Build compact or full prompt; primary_goal uses the structured template.
+    const promptResult = (0, worker_prompt_js_1.buildPromptFromPacketInput)({
+        issueId: input.childId,
+        title: childTitle,
+        worktree: '.',
+        branch: input.branch,
+        stateFile: input.stateFile,
+        telemetryFile: input.telemetryFile,
+        issueContext: input.issueContext,
+        allowedScope: resolvedScope,
+        validationCommands: resolvedValidation,
+        mode: promptMode,
+    });
+    return {
+        schema_version: '2.1',
+        worker_role: 'impl',
+        run_id: input.runId,
+        cluster_id: input.clusterId,
+        active_child: input.childId,
+        state_file: input.stateFile,
+        telemetry_file: input.telemetryFile,
+        instructions: {
+            primary_goal: promptResult.prompt,
+            steps,
+            allowed_scope: resolvedScope,
+            validation_commands: resolvedValidation,
+            issue_context: input.issueContext,
+        },
+        lifecycle: defaultLifecycle(input.maxConcurrentWorkers ?? 1, 'commit-and-exit'),
+        return_contract: exports.IMPL_RETURN_CONTRACT,
+        prompt_mode: promptMode,
+        prompt_metrics: promptResult.metrics,
+        role_context: roleContextForWorkerRole('impl'),
+        prohibited_write_paths: exports.WORKER_PROHIBITED_WRITE_PATHS,
+        result_file_contract: {
+            result_file: input.resultFile,
+            result_required_fields: Object.fromEntries([
+                ['run_id', input.runId],
+                ['cluster_id', input.clusterId],
+                ['child_id', input.childId],
+                ...exports.IMPL_RETURN_CONTRACT.map(key => [key, `<${key}>`]),
+            ]),
+        },
+        context: {
+            branch: input.branch,
+            worker_role: 'impl',
+        },
+    };
+}
+/**
+ * Build a compiled finalize worker packet.
+ * Delegates the 12-step delivery sequence to a disposable finalize worker.
+ */
+function compileFinalizePacket(input) {
+    const targetBranch = input.targetBranch ?? 'main';
+    const steps = [
+        `Read ${input.stateFile} — confirm status is "cluster-complete" (open_children is empty).`,
+        `Run polaris map validate.`,
+        `Run polaris finalize run --state-file ${input.stateFile} --skip-delivery (local validation only).`,
+        `Push branch "${input.branch}" to origin.`,
+        `Create PR targeting "${targetBranch}".`,
+        `Write PR URL to ${input.stateFile}.`,
+        `Update Linear parent issue ${input.clusterId} to Done.`,
+        `Append finalize telemetry events to ${input.telemetryFile}.`,
+        `Write compact finalize JSON to stdout (fields: ${exports.FINALIZE_RETURN_CONTRACT.join(', ')}).`,
+        `TERMINATE SESSION IMMEDIATELY.`,
+    ];
+    return {
+        schema_version: '2.1',
+        worker_role: 'finalize',
+        run_id: input.runId,
+        cluster_id: input.clusterId,
+        active_child: '',
+        state_file: input.stateFile,
+        telemetry_file: input.telemetryFile,
+        instructions: {
+            primary_goal: `Finalize cluster ${input.clusterId} on branch "${input.branch}" and create PR targeting "${targetBranch}". ` +
+                `This is a delivery-only pass — no implementation work.`,
+            steps,
+            allowed_scope: ['**/*'],
+            validation_commands: ['npm run build', 'npm test'],
+        },
+        lifecycle: defaultLifecycle(input.maxConcurrentWorkers ?? 1, 'commit-and-exit'),
+        return_contract: exports.FINALIZE_RETURN_CONTRACT,
+        prompt_mode: 'full',
+        prompt_metrics: { mode: 'full', char_count: 0, estimated_tokens: 0 },
+        role_context: roleContextForWorkerRole('finalize'),
+        result_file_contract: {
+            result_file: input.resultFile,
+            result_required_fields: Object.fromEntries([
+                ['run_id', input.runId],
+                ['cluster_id', input.clusterId],
+                ['child_id', '<active_child from packet>'],
+                ...exports.FINALIZE_RETURN_CONTRACT.map(key => [key, `<${key}>`]),
+            ]),
+        },
+        context: {
+            branch: input.branch,
+            worker_role: 'finalize',
+            target_branch: targetBranch,
+        },
+    };
+}
+/**
+ * Build a compiled preflight worker packet.
+ * Preflight validates state, branch, and map integrity before the first impl dispatch.
+ */
+function compilePreflightPacket(input) {
+    const steps = [
+        `Read ${input.stateFile} and validate schema (required fields, correct types).`,
+        `Confirm current git branch is "${input.branch}".`,
+        `Confirm working tree has no unexpected dirty files.`,
+        `Confirm active_child is empty (no orphaned worker claims in state).`,
+        `Run polaris map validate.`,
+        `Write compact preflight JSON to stdout (fields: ${exports.PREFLIGHT_RETURN_CONTRACT.join(', ')}).`,
+        `TERMINATE SESSION IMMEDIATELY.`,
+    ];
+    return {
+        schema_version: '2.1',
+        worker_role: 'preflight',
+        run_id: input.runId,
+        cluster_id: input.clusterId,
+        active_child: '',
+        state_file: input.stateFile,
+        telemetry_file: input.telemetryFile,
+        instructions: {
+            primary_goal: `Preflight check for cluster ${input.clusterId}: validate state integrity, branch, and map before impl dispatch.`,
+            steps,
+            allowed_scope: [],
+            validation_commands: [],
+        },
+        lifecycle: defaultLifecycle(input.maxConcurrentWorkers ?? 1, 'exit-immediately'),
+        return_contract: exports.PREFLIGHT_RETURN_CONTRACT,
+        prompt_mode: 'full',
+        prompt_metrics: { mode: 'full', char_count: 0, estimated_tokens: 0 },
+        role_context: roleContextForWorkerRole('preflight'),
+        result_file_contract: {
+            result_file: input.resultFile,
+            result_required_fields: Object.fromEntries([
+                ['run_id', input.runId],
+                ['cluster_id', input.clusterId],
+                ['child_id', '<active_child from packet>'],
+                ...exports.PREFLIGHT_RETURN_CONTRACT.map(key => [key, `<${key}>`]),
+            ]),
+        },
+        context: {
+            branch: input.branch,
+            worker_role: 'preflight',
+        },
+    };
+}

package/dist/loop/worker-packet.test.js

@@ -0,0 +1,243 @@
+"use strict";
+/**
+ * Unit tests for src/loop/worker-packet.ts
+ *
+ * Verifies compiled packet shape, type guard, and that no skill files are
+ * referenced (workers receive self-contained instructions).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const worker_packet_js_1 = require("./worker-packet.js");
+// ── Fixtures ──────────────────────────────────────────────────────────────────
+const 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",
+};
+// ── isWorkerPacket type guard ─────────────────────────────────────────────────
+(0, vitest_1.describe)("isWorkerPacket", () => {
+    (0, vitest_1.it)("returns false for a v1 BootstrapPacket", () => {
+        const v1 = {
+            schema_version: "1.0",
+            run_id: "run-001",
+            cluster_id: "POL-120",
+            active_child: "POL-121",
+            state_file: BASE.stateFile,
+            telemetry_file: BASE.telemetryFile,
+        };
+        (0, vitest_1.expect)((0, worker_packet_js_1.isWorkerPacket)(v1)).toBe(false);
+    });
+    (0, vitest_1.it)("returns true for a compiled WorkerPacket", () => {
+        const packet = (0, worker_packet_js_1.compileImplPacket)({ ...BASE, childId: "POL-121" });
+        (0, vitest_1.expect)((0, worker_packet_js_1.isWorkerPacket)(packet)).toBe(true);
+    });
+    (0, vitest_1.it)("returns true for a compiled WorkerPacket with result_file_contract", () => {
+        const packet = (0, worker_packet_js_1.compileImplPacket)({
+            ...BASE,
+            childId: "POL-121",
+            resultFile: "/tmp/result.json",
+        });
+        (0, vitest_1.expect)((0, worker_packet_js_1.isWorkerPacket)(packet)).toBe(true);
+    });
+    (0, vitest_1.it)("returns false if result_file_contract is malformed", () => {
+        const packet = (0, worker_packet_js_1.compileImplPacket)({ ...BASE, childId: "POL-121" });
+        packet.result_file_contract = { result_file: 123 };
+        (0, vitest_1.expect)((0, worker_packet_js_1.isWorkerPacket)(packet)).toBe(false);
+    });
+});
+// ── compileImplPacket ─────────────────────────────────────────────────────────
+(0, vitest_1.describe)("compileImplPacket", () => {
+    (0, vitest_1.it)("produces schema_version 2.1 and worker_role impl", () => {
+        const p = (0, worker_packet_js_1.compileImplPacket)({ ...BASE, childId: "POL-121" });
+        (0, vitest_1.expect)(p.schema_version).toBe("2.1");
+        (0, vitest_1.expect)(p.worker_role).toBe("impl");
+    });
+    (0, vitest_1.it)("sets active_child to the child ID (BootstrapPacket compat)", () => {
+        const p = (0, worker_packet_js_1.compileImplPacket)({ ...BASE, childId: "POL-121" });
+        (0, vitest_1.expect)(p.active_child).toBe("POL-121");
+    });
+    (0, vitest_1.it)("includes the child ID in steps and primary_goal", () => {
+        const p = (0, worker_packet_js_1.compileImplPacket)({ ...BASE, childId: "POL-121" });
+        (0, vitest_1.expect)(p.instructions.primary_goal).toContain("POL-121");
+        const stepsText = p.instructions.steps.join(" ");
+        (0, vitest_1.expect)(stepsText).toContain("POL-121");
+    });
+    (0, vitest_1.it)("embeds pre-compiled steps so workers do not re-ingest skills", () => {
+        const p = (0, worker_packet_js_1.compileImplPacket)({ ...BASE, childId: "POL-121" });
+        // Steps must not reference any skill file path
+        const stepsText = p.instructions.steps.join(" ");
+        (0, vitest_1.expect)(stepsText).not.toContain(".codex/skills");
+        (0, vitest_1.expect)(stepsText).not.toContain("chain.md");
+        // Steps must include one-child termination instruction
+        (0, vitest_1.expect)(stepsText.toUpperCase()).toContain("TERMINATE");
+    });
+    (0, vitest_1.it)("includes issue context requirements in steps when provided", () => {
+        const p = (0, worker_packet_js_1.compileImplPacket)({
+            ...BASE,
+            childId: "POL-121",
+            issueContext: {
+                id: "POL-121",
+                title: "Add validation layer",
+                key_requirements: ["Validate schema on load", "Emit error events"],
+            },
+        });
+        const stepsText = p.instructions.steps.join(" ");
+        (0, vitest_1.expect)(stepsText).toContain("Validate schema on load");
+        (0, vitest_1.expect)(stepsText).toContain("Emit error events");
+    });
+    (0, vitest_1.it)("respects allowedScope and validationCommands", () => {
+        const p = (0, worker_packet_js_1.compileImplPacket)({
+            ...BASE,
+            childId: "POL-121",
+            allowedScope: ["src/loop/**"],
+            validationCommands: ["npm test"],
+        });
+        (0, vitest_1.expect)(p.instructions.allowed_scope).toEqual(["src/loop/**"]);
+        (0, vitest_1.expect)(p.instructions.validation_commands).toEqual(["npm test"]);
+    });
+    (0, vitest_1.it)("has terminate_after_completion: true in lifecycle", () => {
+        const p = (0, worker_packet_js_1.compileImplPacket)({ ...BASE, childId: "POL-121" });
+        (0, vitest_1.expect)(p.lifecycle.terminate_after_completion).toBe(true);
+    });
+    (0, vitest_1.it)("defaults max_concurrent to 1", () => {
+        const p = (0, worker_packet_js_1.compileImplPacket)({ ...BASE, childId: "POL-121" });
+        (0, vitest_1.expect)(p.lifecycle.max_concurrent).toBe(1);
+    });
+    (0, vitest_1.it)("uses cleanup_on_exit: commit-and-exit", () => {
+        const p = (0, worker_packet_js_1.compileImplPacket)({ ...BASE, childId: "POL-121" });
+        (0, vitest_1.expect)(p.lifecycle.cleanup_on_exit).toBe("commit-and-exit");
+    });
+    (0, vitest_1.it)("return_contract matches IMPL_RETURN_CONTRACT", () => {
+        const p = (0, worker_packet_js_1.compileImplPacket)({ ...BASE, childId: "POL-121" });
+        (0, vitest_1.expect)(p.return_contract).toEqual(worker_packet_js_1.IMPL_RETURN_CONTRACT);
+    });
+    (0, vitest_1.it)("populates result_file_contract when resultFile is provided", () => {
+        const p = (0, worker_packet_js_1.compileImplPacket)({
+            ...BASE,
+            childId: "POL-121",
+            resultFile: "/tmp/result.json",
+        });
+        (0, vitest_1.expect)(p.result_file_contract).toEqual({ result_file: "/tmp/result.json" });
+    });
+    (0, vitest_1.it)("is a valid BootstrapPacket (has all required v1 fields)", () => {
+        const p = (0, worker_packet_js_1.compileImplPacket)({ ...BASE, childId: "POL-121" });
+        (0, vitest_1.expect)(typeof p.run_id).toBe("string");
+        (0, vitest_1.expect)(typeof p.cluster_id).toBe("string");
+        (0, vitest_1.expect)(typeof p.active_child).toBe("string");
+        (0, vitest_1.expect)(typeof p.state_file).toBe("string");
+        (0, vitest_1.expect)(typeof p.telemetry_file).toBe("string");
+    });
+});
+// ── compileFinalizePacket ─────────────────────────────────────────────────────
+(0, vitest_1.describe)("compileFinalizePacket", () => {
+    (0, vitest_1.it)("produces worker_role finalize with empty active_child", () => {
+        const p = (0, worker_packet_js_1.compileFinalizePacket)(BASE);
+        (0, vitest_1.expect)(p.worker_role).toBe("finalize");
+        (0, vitest_1.expect)(p.active_child).toBe("");
+    });
+    (0, vitest_1.it)("includes the target branch in steps", () => {
+        const p = (0, worker_packet_js_1.compileFinalizePacket)({ ...BASE, targetBranch: "main" });
+        const stepsText = p.instructions.steps.join(" ");
+        (0, vitest_1.expect)(stepsText).toContain("main");
+    });
+    (0, vitest_1.it)("defaults targetBranch to main", () => {
+        const p = (0, worker_packet_js_1.compileFinalizePacket)(BASE);
+        (0, vitest_1.expect)(p.instructions.primary_goal).toContain("main");
+    });
+    (0, vitest_1.it)("has terminate_after_completion: true", () => {
+        const p = (0, worker_packet_js_1.compileFinalizePacket)(BASE);
+        (0, vitest_1.expect)(p.lifecycle.terminate_after_completion).toBe(true);
+    });
+    (0, vitest_1.it)("return_contract matches FINALIZE_RETURN_CONTRACT", () => {
+        const p = (0, worker_packet_js_1.compileFinalizePacket)(BASE);
+        (0, vitest_1.expect)(p.return_contract).toEqual(worker_packet_js_1.FINALIZE_RETURN_CONTRACT);
+    });
+    (0, vitest_1.it)("populates result_file_contract when resultFile is provided", () => {
+        const p = (0, worker_packet_js_1.compileFinalizePacket)({ ...BASE, resultFile: "/tmp/result.json" });
+        (0, vitest_1.expect)(p.result_file_contract).toEqual({ result_file: "/tmp/result.json" });
+    });
+    (0, vitest_1.it)("does not reference skill files", () => {
+        const p = (0, worker_packet_js_1.compileFinalizePacket)(BASE);
+        const stepsText = p.instructions.steps.join(" ");
+        (0, vitest_1.expect)(stepsText).not.toContain(".codex/skills");
+    });
+});
+// ── compileStartupPacket ──────────────────────────────────────────────────────
+(0, vitest_1.describe)("compileStartupPacket", () => {
+    (0, vitest_1.it)("produces worker_role startup with empty active_child", () => {
+        const p = (0, worker_packet_js_1.compileStartupPacket)(BASE);
+        (0, vitest_1.expect)(p.worker_role).toBe("startup");
+        (0, vitest_1.expect)(p.active_child).toBe("");
+    });
+    (0, vitest_1.it)("return_contract matches STARTUP_RETURN_CONTRACT", () => {
+        const p = (0, worker_packet_js_1.compileStartupPacket)(BASE);
+        (0, vitest_1.expect)(p.return_contract).toEqual(worker_packet_js_1.STARTUP_RETURN_CONTRACT);
+    });
+});
+// ── compilePreflightPacket ────────────────────────────────────────────────────
+(0, vitest_1.describe)("compilePreflightPacket", () => {
+    (0, vitest_1.it)("produces worker_role preflight", () => {
+        const p = (0, worker_packet_js_1.compilePreflightPacket)(BASE);
+        (0, vitest_1.expect)(p.worker_role).toBe("preflight");
+    });
+    (0, vitest_1.it)("has empty active_child", () => {
+        const p = (0, worker_packet_js_1.compilePreflightPacket)(BASE);
+        (0, vitest_1.expect)(p.active_child).toBe("");
+    });
+    (0, vitest_1.it)("uses cleanup_on_exit: exit-immediately", () => {
+        const p = (0, worker_packet_js_1.compilePreflightPacket)(BASE);
+        (0, vitest_1.expect)(p.lifecycle.cleanup_on_exit).toBe("exit-immediately");
+    });
+    (0, vitest_1.it)("has empty allowed_scope (read-only check)", () => {
+        const p = (0, worker_packet_js_1.compilePreflightPacket)(BASE);
+        (0, vitest_1.expect)(p.instructions.allowed_scope).toEqual([]);
+    });
+    (0, vitest_1.it)("return_contract matches PREFLIGHT_RETURN_CONTRACT", () => {
+        const p = (0, worker_packet_js_1.compilePreflightPacket)(BASE);
+        (0, vitest_1.expect)(p.return_contract).toEqual(worker_packet_js_1.PREFLIGHT_RETURN_CONTRACT);
+    });
+    (0, vitest_1.it)("populates result_file_contract when resultFile is provided", () => {
+        const p = (0, worker_packet_js_1.compilePreflightPacket)({ ...BASE, resultFile: "/tmp/result.json" });
+        (0, vitest_1.expect)(p.result_file_contract).toEqual({ result_file: "/tmp/result.json" });
+    });
+});
+// ── Role context (POL-227) ────────────────────────────────────────────────────
+(0, vitest_1.describe)("role_context", () => {
+    (0, vitest_1.it)("impl packet has worker role context", () => {
+        const p = (0, worker_packet_js_1.compileImplPacket)({ ...BASE, childId: "POL-121" });
+        (0, vitest_1.expect)(p.role_context.role).toBe("worker");
+        (0, vitest_1.expect)(p.role_context.role_authority).toBe("implementation");
+        (0, vitest_1.expect)(p.role_context.may_implement).toBe(true);
+        (0, vitest_1.expect)(p.role_context.may_assign_workers).toBe(false);
+        (0, vitest_1.expect)(Array.isArray(p.role_context.prohibited_actions)).toBe(true);
+        (0, vitest_1.expect)(p.role_context.prohibited_actions.length).toBeGreaterThan(0);
+    });
+    (0, vitest_1.it)("startup packet has foreman role context", () => {
+        const p = (0, worker_packet_js_1.compileStartupPacket)(BASE);
+        (0, vitest_1.expect)(p.role_context.role).toBe("foreman");
+        (0, vitest_1.expect)(p.role_context.may_implement).toBe(false);
+        (0, vitest_1.expect)(p.role_context.may_assign_workers).toBe(true);
+    });
+    (0, vitest_1.it)("finalize packet has foreman role context", () => {
+        const p = (0, worker_packet_js_1.compileFinalizePacket)(BASE);
+        (0, vitest_1.expect)(p.role_context.role).toBe("foreman");
+        (0, vitest_1.expect)(p.role_context.may_implement).toBe(false);
+    });
+    (0, vitest_1.it)("preflight packet has foreman role context", () => {
+        const p = (0, worker_packet_js_1.compilePreflightPacket)(BASE);
+        (0, vitest_1.expect)(p.role_context.role).toBe("foreman");
+        (0, vitest_1.expect)(p.role_context.may_implement).toBe(false);
+    });
+});
+// ── WorkerPacket as BootstrapPacket ───────────────────────────────────────────
+(0, vitest_1.describe)("WorkerPacket structural compatibility", () => {
+    (0, vitest_1.it)("impl packet passes as BootstrapPacket (structural subtype)", () => {
+        const p = (0, worker_packet_js_1.compileImplPacket)({ ...BASE, childId: "POL-121" });
+        // Assign to BootstrapPacket — should compile without errors
+        const bp = p;
+        (0, vitest_1.expect)(bp.run_id).toBe("run-001");
+        (0, vitest_1.expect)(bp.active_child).toBe("POL-121");
+    });
+});