agent-dealer 1.2.7 → 1.2.9

package/bundle/server/dist/repository/worker-sessions.js

@@ -22,6 +22,7 @@ function rowToSession(row) {
         processPid: row.process_pid,
         processOwner: row.process_owner,
         processStartedAt: row.process_started_at,
+        deckCorrelationId: row.deck_correlation_id ?? null,
         createdAt: row.created_at,
         startedAt: row.started_at,
         heartbeatAt: row.heartbeat_at,
@@ -53,6 +54,9 @@ export function createWorkerSession(input) {
         process_pid: null,
         process_owner: null,
         process_started_at: null,
+        // NOT-305: one opaque Deck correlation UUID per session, persisted before spawn so
+        // every runtime launch config can carry it as observability metadata.
+        deck_correlation_id: uuid(),
         created_at: now,
         started_at: null,
         heartbeat_at: null,
@@ -63,17 +67,35 @@ export function createWorkerSession(input) {
     INSERT INTO worker_sessions (
       id, issue_id, role, round, agent_id, runtime, model, budget_json, worktree_path,
       input_sha, status, session_ref, log_path, exit_code, error_json, metadata_json,
-      profile_snapshot_json, process_pid, process_owner, process_started_at, created_at, started_at, heartbeat_at,
+      profile_snapshot_json, process_pid, process_owner, process_started_at, deck_correlation_id, created_at, started_at, heartbeat_at,
       completed_at, updated_at
     ) VALUES (
       @id, @issue_id, @role, @round, @agent_id, @runtime, @model, @budget_json, @worktree_path,
       @input_sha, @status, @session_ref, @log_path, @exit_code, @error_json, @metadata_json,
-      @profile_snapshot_json, @process_pid, @process_owner, @process_started_at, @created_at, @started_at, @heartbeat_at,
+      @profile_snapshot_json, @process_pid, @process_owner, @process_started_at, @deck_correlation_id, @created_at, @started_at, @heartbeat_at,
       @completed_at, @updated_at
     )
   `).run(row);
     return rowToSession(row);
 }
+/**
+ * NOT-305: returns the session's Deck correlation UUID, assigning and persisting one
+ * when a pre-feature row has none. New rows always carry one from creation; this only
+ * repairs rows written before the column existed so their launch configs and receipts
+ * still correlate. Returns null when the session does not exist.
+ */
+export function getOrAssignSessionCorrelationId(id) {
+    const current = getWorkerSession(id);
+    if (!current)
+        return null;
+    if (current.deckCorrelationId)
+        return current.deckCorrelationId;
+    const correlationId = uuid();
+    getDb()
+        .prepare("UPDATE worker_sessions SET deck_correlation_id = ?, updated_at = ? WHERE id = ?")
+        .run(correlationId, new Date().toISOString(), id);
+    return correlationId;
+}
 export function getWorkerSession(id) {
     const row = getDb().prepare("SELECT * FROM worker_sessions WHERE id = ?").get(id);
     return row ? rowToSession(row) : null;
@@ -165,6 +187,33 @@ export function recordSessionProcess(id, pid, owner, startTime = null) {
        WHERE id = ? AND status = 'running'`)
         .run(pid, owner, startTime, new Date().toISOString(), id);
 }
+/**
+ * NOT-307: shallow-merges `patch` into the session's `metadata_json` (read +
+ * JSON-merge + write; unparseable existing content restarts from `{}`). Works on
+ * any status — the Muse lane records stall evidence right after spawn, before the
+ * terminal `completeSession`. No-op for unknown ids; never throws for malformed
+ * JSON. Callers needing atomicity should not use this (it is best-effort evidence).
+ */
+export function mergeSessionMetadata(id, patch) {
+    const current = getWorkerSession(id);
+    if (!current)
+        return;
+    let base = {};
+    if (current.metadataJson) {
+        try {
+            const parsed = JSON.parse(current.metadataJson);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                base = parsed;
+            }
+        }
+        catch {
+            base = {};
+        }
+    }
+    getDb()
+        .prepare("UPDATE worker_sessions SET metadata_json = ?, updated_at = ? WHERE id = ?")
+        .run(JSON.stringify({ ...base, ...patch }), new Date().toISOString(), id);
+}
 /** Most recent still-running session for an issue — drives the Issue Detail live strip. */
 export function getActiveWorkerSessionForIssue(issueId) {
     const row = getDb()

package/bundle/server/dist/routes/human-actions.js

@@ -57,14 +57,16 @@ export async function registerHumanActionRoutes(app) {
         });
         if (!result.ok)
             return reply.status(result.code).send({ error: result.error });
-        // Reflect is a best-effort network call to Agent Deck (health check + a sequential
-        // fetch/propose round trip per playbook) — resolution has already committed above, so
-        // this must not hold the HTTP response hostage behind it: a slow/offline deck would
-        // otherwise risk a client timeout on an already-resolved action, whose retry then gets
-        // a spurious 409. Fire-and-forget; triggerIssueReflect never throws (it records its own
-        // outcome as artifacts), so there is nothing here to await or react to.
-        // triggerReflect is set after a successful merge-to-done (auto-merge or human complete).
-        if (result.triggerReflect && action.issueId) {
+        // NOT-305: completion evidence is a best-effort Deck read (receipts) plus at most
+        // one `signal_only` report per failure/correction trigger — resolution has already
+        // committed above, so this must not hold the HTTP response hostage behind it: a
+        // slow/offline deck would otherwise risk a client timeout on an already-resolved
+        // action, whose retry then gets a spurious 409. Fire-and-forget; triggerIssueReflect
+        // never throws (it records its own outcome as artifacts), so there is nothing here
+        // to await or react to. Fires for every instance-completing resolution (done AND
+        // closed): an attempts-exhausted close still owes its actual-use receipts and its
+        // exhaustion signal even though no merge follows.
+        if (result.instanceCompleted && action.issueId) {
             void triggerIssueReflect(action.issueId).catch(() => { });
         }
         return {

package/bundle/server/dist/routes/issues-execution-contract.test.js

@@ -0,0 +1,321 @@
+// NOT-306: Linear/Planner tickets compile into frozen execution contracts.
+// Web, API, and CLI creation all funnel through POST /api/issues, so these
+// route tests cover each intake path with its equivalent request shape while
+// the shared compiler owns the parsing (no page-local regex anywhere).
+import { test, before, after, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import Fastify from "fastify";
+process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-issue-contract-"));
+const { migrate, getDb } = await import("../db/index.js");
+const { BUILTIN_AGENT_CLAUDE_ID, BUILTIN_AGENT_CURSOR_ID } = await import("@agent-dealer/shared");
+const { registerIssueRoutes } = await import("./issues.js");
+const { getIssue } = await import("../repository/issues.js");
+const { claimWorkItem } = await import("../repository/work-items.js");
+const { listHumanActionsForIssue } = await import("../repository/human-actions.js");
+const { applyCompletion, resolveHumanActionAndAdvance, getTaskSnapshot } = await import("../coordinator/commands.js");
+const { ReviewerResult } = await import("../coordinator/reviewer-result.js");
+const { setAdmissionHealthCheckerForTests } = await import("../coordinator/admission.js");
+before(() => {
+    migrate();
+    setAdmissionHealthCheckerForTests(async () => ({ ok: true }));
+});
+after(() => setAdmissionHealthCheckerForTests(null));
+beforeEach(() => {
+    getDb().exec(`
+    DELETE FROM work_items;
+    DELETE FROM human_actions;
+    DELETE FROM workflow_events;
+    DELETE FROM worker_sessions;
+    DELETE FROM artifacts;
+    DELETE FROM workflow_instances;
+    DELETE FROM queue_entries;
+    DELETE FROM issues;
+  `);
+});
+async function buildApp() {
+    const app = Fastify();
+    await registerIssueRoutes(app);
+    return app;
+}
+/** Planner-authored Linear ticket carrying every contract-v1 heading. */
+const CONTRACT_DESCRIPTION = [
+    "Compile the Planner ticket into a frozen execution contract.",
+    "",
+    "## Builder execution mode",
+    "feature",
+    "",
+    "## Non-goals",
+    "- Selecting a playbook or reasoning about implementation architecture",
+    "- Adding a generic workflow/schema editor",
+    "",
+    "## Exit predicate",
+    "Importing a Planner-authored Linear ticket yields a versioned frozen execution contract.",
+    "",
+    "## One-PR stopping point",
+    "Stop after the contract compiles, freezes, and renders in both worker prompts.",
+    "",
+    "## Acceptance criteria",
+    "- [ ] Full ticket imports into the exact structured schema",
+    "  Evidence: shared compiler fixtures | run the compiler test | every field asserted",
+    "- [ ] Legacy issues without headings still start",
+    "  Evidence: legacy suite | run the legacy tests | green",
+    "",
+].join("\n");
+const EXPECTED_CONTRACT = {
+    version: "v1",
+    executionMode: "feature",
+    nonGoals: [
+        "Selecting a playbook or reasoning about implementation architecture",
+        "Adding a generic workflow/schema editor",
+    ],
+    exitPredicate: "Importing a Planner-authored Linear ticket yields a versioned frozen execution contract.",
+    onePrStoppingPoint: "Stop after the contract compiles, freezes, and renders in both worker prompts.",
+    acceptanceCriteria: [
+        {
+            text: "Full ticket imports into the exact structured schema",
+            evidence: "shared compiler fixtures | run the compiler test | every field asserted",
+        },
+        {
+            text: "Legacy issues without headings still start",
+            evidence: "legacy suite | run the legacy tests | green",
+        },
+    ],
+};
+const BASE_AGENTS = {
+    repo: "acme/app",
+    baseBranch: "main",
+    developerAgentId: BUILTIN_AGENT_CLAUDE_ID,
+    reviewerAgentId: BUILTIN_AGENT_CURSOR_ID,
+};
+test("web/API/CLI-shaped creates compile the same contract and keep the source untouched", async () => {
+    const app = await buildApp();
+    // Web Linear import: full ticket description, no separate criteria field —
+    // the server derives it with the shared compiler.
+    const webShaped = {
+        title: "NOT-306: frozen execution contracts",
+        description: CONTRACT_DESCRIPTION,
+        source: "linear",
+        externalId: "linear-uuid-web",
+        externalLabel: "NOT-306",
+        externalUrl: "https://linear.app/not-so-fat/issue/NOT-306/x",
+        ...BASE_AGENTS,
+    };
+    // API direct create: same description plus an explicit override stays explicit.
+    const apiShaped = {
+        title: "Contract via API",
+        description: CONTRACT_DESCRIPTION,
+        acceptanceCriteria: "Operator-typed override",
+        ...BASE_AGENTS,
+    };
+    // CLI agent create: source agent, description carried through.
+    const cliShaped = {
+        title: "Contract via CLI",
+        description: CONTRACT_DESCRIPTION,
+        source: "agent",
+        ...BASE_AGENTS,
+    };
+    for (const [name, payload] of [["web", webShaped], ["api", apiShaped], ["cli", cliShaped]]) {
+        const res = await app.inject({ method: "POST", url: "/api/issues", payload });
+        assert.equal(res.statusCode, 200, `${name}: ${res.body}`);
+        const created = res.json();
+        assert.deepStrictEqual(created.executionContract, EXPECTED_CONTRACT, name);
+        assert.equal(created.description, CONTRACT_DESCRIPTION, `${name}: source Markdown stored unchanged`);
+        const detail = (await app.inject({ method: "GET", url: `/api/issues/${created.id}` })).json();
+        assert.deepStrictEqual(detail.issue.executionContract, EXPECTED_CONTRACT, `${name} detail`);
+        assert.equal(detail.issue.description, CONTRACT_DESCRIPTION, `${name} detail source unchanged`);
+    }
+    // The override wins; the derived rendering fills only when nothing was given.
+    const apiCreated = (await app.inject({ method: "POST", url: "/api/issues", payload: { ...apiShaped, title: "again" } })).json();
+    assert.equal(apiCreated.acceptanceCriteria, "Operator-typed override");
+    const webCreated = (await app.inject({ method: "POST", url: "/api/issues", payload: { ...webShaped, title: "again", externalId: "linear-uuid-web-2" } })).json();
+    assert.ok(webCreated.acceptanceCriteria.includes("- [ ] Full ticket imports into the exact structured schema"));
+    assert.ok(webCreated.acceptanceCriteria.includes("Evidence: shared compiler fixtures"));
+    await app.close();
+});
+test("a contract ticket starts — readiness is satisfied by the derived criteria", async () => {
+    const app = await buildApp();
+    const created = (await app.inject({
+        method: "POST",
+        url: "/api/issues",
+        payload: { title: "Startable contract", description: CONTRACT_DESCRIPTION, ...BASE_AGENTS },
+    })).json();
+    const startRes = await app.inject({ method: "POST", url: `/api/issues/${created.id}/start` });
+    assert.equal(startRes.statusCode, 200, startRes.body);
+    // Starting freezes the compiled contract alongside the source description.
+    const frozen = getTaskSnapshot(getIssue(created.id));
+    assert.deepStrictEqual(frozen.executionContract, EXPECTED_CONTRACT);
+    assert.equal(frozen.description, CONTRACT_DESCRIPTION);
+    await app.close();
+});
+test("legacy issues with no contract headings keep current behavior and stay startable", async () => {
+    const app = await buildApp();
+    const created = (await app.inject({
+        method: "POST",
+        url: "/api/issues",
+        payload: { title: "Legacy", description: "Just a plain description.", acceptanceCriteria: "It works", ...BASE_AGENTS },
+    })).json();
+    assert.equal(created.executionContract, null);
+    const startRes = await app.inject({ method: "POST", url: `/api/issues/${created.id}/start` });
+    assert.equal(startRes.statusCode, 200, startRes.body);
+    const frozen = getTaskSnapshot(getIssue(created.id));
+    assert.equal(frozen.executionContract, null);
+    await app.close();
+});
+test("an Acceptance-criteria-only ticket keeps the legacy extraction and stays startable", async () => {
+    const app = await buildApp();
+    const created = (await app.inject({
+        method: "POST",
+        url: "/api/issues",
+        payload: {
+            title: "AC-only legacy",
+            description: "Ship it.\n\n## Acceptance criteria\nIt works and it ships.",
+            ...BASE_AGENTS,
+        },
+    })).json();
+    assert.equal(created.executionContract, null);
+    assert.equal(created.acceptanceCriteria, "It works and it ships.");
+    const startRes = await app.inject({ method: "POST", url: `/api/issues/${created.id}/start` });
+    assert.equal(startRes.statusCode, 200, startRes.body);
+    await app.close();
+});
+const INVALID_DESCRIPTIONS = [
+    {
+        name: "unknown execution mode",
+        description: CONTRACT_DESCRIPTION.replace("feature", "teleport"),
+        match: /unknown execution mode/,
+    },
+    {
+        name: "empty exit predicate",
+        description: CONTRACT_DESCRIPTION.replace("Importing a Planner-authored Linear ticket yields a versioned frozen execution contract.", ""),
+        match: /Exit predicate/,
+    },
+    {
+        name: "duplicate criterion",
+        description: CONTRACT_DESCRIPTION.replace("- [ ] Legacy issues without headings still start", "- [ ] Full ticket imports into the exact structured schema"),
+        match: /duplicate criterion/i,
+    },
+    {
+        name: "empty Evidence line",
+        description: CONTRACT_DESCRIPTION.replace("  Evidence: legacy suite | run the legacy tests | green", "  Evidence:"),
+        match: /Evidence/,
+    },
+    {
+        name: "duplicate heading",
+        description: `${CONTRACT_DESCRIPTION}\n## Non-goals\n- one more\n`,
+        match: /duplicate.*Non-goals/i,
+    },
+    {
+        name: "missing section once a signal is present",
+        description: "## Builder execution mode\nfeature\n\n## Acceptance criteria\n- [ ] Done\n",
+        match: /missing.*Non-goals/i,
+    },
+];
+for (const { name, description, match } of INVALID_DESCRIPTIONS) {
+    test(`POST rejects an invalid contract with an actionable error: ${name}`, async () => {
+        const app = await buildApp();
+        const res = await app.inject({
+            method: "POST",
+            url: "/api/issues",
+            payload: { title: "Bad contract", description, ...BASE_AGENTS },
+        });
+        assert.equal(res.statusCode, 400, `${name}: ${res.body}`);
+        assert.match(res.json().error, match, name);
+        await app.close();
+    });
+}
+test("PATCH validates an edited description and backfills missing criteria", async () => {
+    const app = await buildApp();
+    const created = (await app.inject({
+        method: "POST",
+        url: "/api/issues",
+        payload: { title: "Editable", description: "plain", ...BASE_AGENTS },
+    })).json();
+    // A contract-breaking edit is a 400, not a silent half-parse.
+    const bad = await app.inject({
+        method: "PATCH",
+        url: `/api/issues/${created.id}`,
+        payload: { description: CONTRACT_DESCRIPTION.replace("feature", "teleport") },
+    });
+    assert.equal(bad.statusCode, 400, bad.body);
+    assert.match(bad.json().error, /unknown execution mode/);
+    // Adding the contract fills the missing criteria from the ticket.
+    const good = await app.inject({
+        method: "PATCH",
+        url: `/api/issues/${created.id}`,
+        payload: { description: CONTRACT_DESCRIPTION },
+    });
+    assert.equal(good.statusCode, 200, good.body);
+    const patched = good.json();
+    assert.equal(patched.description, CONTRACT_DESCRIPTION);
+    assert.deepStrictEqual(patched.executionContract, EXPECTED_CONTRACT);
+    assert.ok(patched.acceptanceCriteria.includes("- [ ] Full ticket imports into the exact structured schema"));
+    await app.close();
+});
+test("an active workflow keeps its frozen contract — later edits are refused", async () => {
+    const app = await buildApp();
+    const created = (await app.inject({
+        method: "POST",
+        url: "/api/issues",
+        payload: { title: "Frozen", description: CONTRACT_DESCRIPTION, ...BASE_AGENTS },
+    })).json();
+    assert.equal((await app.inject({ method: "POST", url: `/api/issues/${created.id}/start` })).statusCode, 200);
+    const before = getTaskSnapshot(getIssue(created.id));
+    assert.deepStrictEqual(before.executionContract, EXPECTED_CONTRACT);
+    const refused = await app.inject({
+        method: "PATCH",
+        url: `/api/issues/${created.id}`,
+        payload: { description: CONTRACT_DESCRIPTION.replace("feature", "refactor") },
+    });
+    assert.equal(refused.statusCode, 409);
+    const after = getTaskSnapshot(getIssue(created.id));
+    assert.deepStrictEqual(after, before);
+    await app.close();
+});
+test("NOT-185 + NOT-306: a parked re-freeze updates source and compiled contract atomically", async () => {
+    const app = await buildApp();
+    const created = (await app.inject({
+        method: "POST",
+        url: "/api/issues",
+        payload: {
+            title: "Parked contract",
+            description: CONTRACT_DESCRIPTION,
+            ...BASE_AGENTS,
+            maxReviewRounds: 1,
+        },
+    })).json();
+    assert.equal((await app.inject({ method: "POST", url: `/api/issues/${created.id}/start` })).statusCode, 200);
+    const complete = async (outcome) => {
+        const item = claimWorkItem("route-test", { leaseMs: 60_000 });
+        await applyCompletion(item.id, item.leaseToken, outcome);
+    };
+    const patch = (payload) => app.inject({ method: "PATCH", url: `/api/issues/${created.id}`, payload });
+    await complete({ kind: "clean_handoff", branch: "b", headSha: "abc", baseSha: "base", prNumber: 1, prUrl: "https://gh/pr/1" });
+    await complete({
+        kind: "verdict",
+        result: ReviewerResult.parse({
+            verdict: "changes_requested",
+            baseSha: "b",
+            headSha: "h",
+            acceptanceCriteriaAssessment: "ok",
+            evidenceAssessment: "ok",
+            findings: [],
+            risks: [],
+        }),
+    });
+    // Re-scope the ticket at the park: new exit predicate, one criterion dropped.
+    const rescoped = CONTRACT_DESCRIPTION.replace("Importing a Planner-authored Linear ticket yields a versioned frozen execution contract.", "Importing a Planner-authored Linear ticket yields a versioned frozen execution contract, rescoped.").replace("- [ ] Legacy issues without headings still start\n  Evidence: legacy suite | run the legacy tests | green\n", "");
+    const parked = await patch({ description: rescoped });
+    assert.equal(parked.statusCode, 200, parked.body);
+    const action = listHumanActionsForIssue(created.id).find((a) => a.actionType === "attempts_exhausted");
+    assert.equal(resolveHumanActionAndAdvance(action.id, "operator", "retry").ok, true);
+    // Source and compiled contract re-froze together — never one without the other.
+    const frozen = getTaskSnapshot(getIssue(created.id));
+    assert.equal(frozen.description, rescoped);
+    assert.equal(frozen.executionContract?.exitPredicate, "Importing a Planner-authored Linear ticket yields a versioned frozen execution contract, rescoped.");
+    assert.equal(frozen.executionContract?.acceptanceCriteria.length, 1);
+    assert.deepStrictEqual(getIssue(created.id).executionContract, frozen.executionContract);
+    await app.close();
+});

package/bundle/server/dist/routes/issues.js

@@ -1,6 +1,6 @@
 // packages/server/src/routes/issues.ts
 import fs from "node:fs";
-import { CreateIssueInput, IssueStatus, UpdateIssueInput, } from "@agent-dealer/shared";
+import { CreateIssueInput, ExecutionContractError, IssueStatus, UpdateIssueInput, } from "@agent-dealer/shared";
 import { getDb } from "../db/index.js";
 import { createIssue, getIssue, listIssues, findActiveIssueByExternalId, listIssuesByExternalId, queryIssues, updateIssue, listRecentRepos } from "../repository/issues.js";
 import { listWorkerSessionsForIssue, getActiveWorkerSessionForIssue } from "../repository/worker-sessions.js";
@@ -224,7 +224,18 @@ export async function registerIssueRoutes(app) {
                 });
             }
         }
-        const issue = createIssue(input);
+        // NOT-306: an ambiguous/malformed execution contract in the ticket
+        // description is a 400 with an actionable message, never a silent drop.
+        let issue;
+        try {
+            issue = createIssue(input);
+        }
+        catch (err) {
+            if (err instanceof ExecutionContractError) {
+                return reply.status(400).send({ error: err.message });
+            }
+            throw err;
+        }
         appendWorkflowEvent({ issueId: issue.id, type: "issue.created", actorType: "human", stage: issue.status });
         // NOT-118: create enqueues, it never starts. Server-side so the UI, CLI and agents all
         // behave the same — callers hold no workflow logic. `enqueue: false` creates a draft.
@@ -320,6 +331,12 @@ export async function registerIssueRoutes(app) {
             })();
         }
         catch (err) {
+            // NOT-306: a contract edit that turns ambiguous/malformed is a 400 —
+            // the guard above already answered the 409s (wrong status / active
+            // workflow / parked-field allowlist).
+            if (err instanceof ExecutionContractError) {
+                return reply.status(400).send({ error: err.message });
+            }
             const code = err.code;
             const message = err instanceof Error ? err.message : String(err);
             if (code === 404)

package/bundle/server/dist/runners/muse-code-args.js

@@ -3,6 +3,31 @@
 // no per-attempt XDG dirs, no settings.json — those belong to the coordinator wiring (NOT-181).
 // Reviewer argv, resume and cancellation are out of scope.
 export const MUSE_COMMAND = "muse";
+/**
+ * NOT-316: what the Muse developer sandbox cannot do, derived from the real
+ * launch flags in `buildMuseDeveloperInvocation` below. The developer prompt's
+ * "Environment limits" section is rendered from this constant (not hand-written
+ * prose), and `muse-code-args.test.ts` asserts the pairing — changing
+ * `--sandbox-network` without updating this constant fails a test.
+ *
+ * Live probe results behind these values: under `restricted` there is no DNS
+ * (npm registry and GitHub API unreachable) and loopback `listen()` fails with
+ * EPERM; under `proxy-only` network works through a local proxy but `listen()`
+ * still fails; under `enabled` both work. No headless browser or
+ * credentials/Keychain are provisioned into the developer session.
+ */
+export const MUSE_SANDBOX_CAPABILITIES = {
+    /** Must equal the `--sandbox-network` value passed in the developer argv. */
+    sandboxNetwork: "restricted",
+    /** Effective network access under that sandbox mode. */
+    network: "none",
+    /** Whether loopback `listen()` works. */
+    loopbackListen: false,
+    /** Whether a browser is available for visual QA / screenshots. */
+    browser: false,
+    /** Whether credentials / Keychain are provisioned. */
+    credentialsKeychain: false,
+};
 /** The launcher re-execs a newer binary hourly unless this is set, so the pinned version can drift. */
 export const MUSE_NO_AUTO_UPDATE_ENV = { MUSE_NO_AUTO_UPDATE: "1" };
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;

package/bundle/server/dist/runners/muse-code-args.test.js

@@ -0,0 +1,30 @@
+// packages/server/src/runners/muse-code-args.test.ts
+//
+// NOT-316: `MUSE_SANDBOX_CAPABILITIES` is mechanically tied to the real launch
+// flags — changing `--sandbox-network` without updating the constant fails a test.
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { buildMuseDeveloperInvocation, MUSE_SANDBOX_CAPABILITIES, } from "./muse-code-args.js";
+const baseOpts = {
+    model: "muse-spark-1.3-contributor",
+    maxModelSteps: 40,
+    sessionId: "0b6c3f0e-4c2a-4f0e-9d3b-2f6f1a9a7c11",
+    prompt: "Implement NOT-1",
+};
+function sandboxNetworkFlag() {
+    const args = buildMuseDeveloperInvocation(baseOpts).args;
+    const i = args.indexOf("--sandbox-network");
+    assert.notEqual(i, -1, "--sandbox-network must be present in the developer argv");
+    const value = args[i + 1];
+    assert.ok(value, "--sandbox-network must have a value");
+    return value;
+}
+test("NOT-316: MUSE_SANDBOX_CAPABILITIES.sandboxNetwork matches the --sandbox-network flag actually passed", () => {
+    assert.equal(sandboxNetworkFlag(), MUSE_SANDBOX_CAPABILITIES.sandboxNetwork);
+});
+test("NOT-316: sandbox capabilities state the restricted-sandbox limits (no network/listen/browser/credentials)", () => {
+    assert.equal(MUSE_SANDBOX_CAPABILITIES.network, "none");
+    assert.equal(MUSE_SANDBOX_CAPABILITIES.loopbackListen, false);
+    assert.equal(MUSE_SANDBOX_CAPABILITIES.browser, false);
+    assert.equal(MUSE_SANDBOX_CAPABILITIES.credentialsKeychain, false);
+});