@synap-core/cli 1.12.2 → 1.13.1-next.20261102.ec3d166

package/dist/commands/worker.test.js

@@ -1,6 +1,9 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 import { describe, expect, it } from "vitest";
-import { buildWorkerPrompt, findMcpServerName, AgentBoundForDispatchError, AgentPausedError, parseHandedToYou, parseInterval, pickNew, workerEnv, workerVerdict, } from "./worker.js";
-import { lastJsonPayload } from "../lib/mcp-call.js";
+import { buildWorkerPrompt, RUN_MCP_SERVER, runMcpConfig, writeRunMcpConfig, AgentBoundForDispatchError, AgentPausedError, parseHandedToYou, parseInterval, pickNew, LAUNCH_RETRY_BASE_MS, MAX_LAUNCH_RETRIES, workerEnv, workerVerdict, parseVerdict, verdictClaim, verdictForExit, quietIsOwnRun, runProcessIdentity, runEndHeaders, foldRunEvent as foldOne, RUN_ENV_BLOCKLIST, } from "./worker.js";
+import { createMcpClient, lastJsonPayload } from "../lib/mcp-call.js";
 const orient = (handed) => JSON.stringify({ startHere: { pendingReview: { count: 0 }, handedToYou: handed } });
 describe("parseHandedToYou", () => {
     it("reads the handed sessions from orient", () => {
@@ -25,6 +28,20 @@ describe("parseHandedToYou", () => {
     it("non-JSON orient text throws", () => {
         expect(() => parseHandedToYou("Error: pod down")).toThrow(/did not return JSON/);
     });
+    it("keeps a resume mark and when the session went quiet; anything but `resume: true` is no mark", () => {
+        const items = parseHandedToYou(orient({
+            items: [
+                { id: "a", goal: "g", resume: true, quietSince: "2026-10-29T10:00:00.000Z" },
+                { id: "b", goal: "g", resume: "yes", quietSince: "2026-10-29T10:00:00.000Z" },
+                { id: "c", goal: "g", resume: true },
+            ],
+        }));
+        expect(items).toEqual([
+            { id: "a", goal: "g", resume: true, quietSince: "2026-10-29T10:00:00.000Z" },
+            { id: "b", goal: "g" },
+            { id: "c", goal: "g", resume: true },
+        ]);
+    });
 });
 describe("pickNew", () => {
     const items = [{ id: "a", goal: null }, { id: "b", goal: null }, { id: "c", goal: null }];
@@ -35,18 +52,81 @@ describe("pickNew", () => {
     it("launches nothing when no slot is free", () => {
         expect(pickNew(items, { runs: {} }, 0)).toEqual([]);
     });
+    it("never a session handed back to resume, even with no record of it (an empty state file relaunches nothing)", () => {
+        const handedBack = [{ id: "a", goal: null, resume: true }, { id: "b", goal: null }];
+        expect(pickNew(handedBack, { runs: {} }, 5).map((i) => i.id)).toEqual(["b"]);
+    });
+    // A run that failed BEFORE Claude started (no Claude session: an expired
+    // login, exhausted credits) had no way back: the session stayed dead even
+    // after the cause was fixed (2026-10-20). It is retried with backoff now.
+    describe("a run that failed before Claude started is retried with backoff", () => {
+        const T0 = Date.parse("2026-10-20T12:00:00Z");
+        const failedAt = (retries, extra = {}) => ({
+            runs: {
+                a: {
+                    sessionId: "a",
+                    status: "failed",
+                    startedAt: "t",
+                    finishedAt: new Date(T0).toISOString(),
+                    launchRetries: retries,
+                    ...extra,
+                },
+            },
+        });
+        const one = [{ id: "a", goal: null }];
+        it("not before its backoff", () => {
+            expect(pickNew(one, failedAt(0), 1, T0 + LAUNCH_RETRY_BASE_MS - 1)).toEqual([]);
+        });
+        it("once the backoff has passed", () => {
+            expect(pickNew(one, failedAt(0), 1, T0 + LAUNCH_RETRY_BASE_MS).map((i) => i.id)).toEqual(["a"]);
+        });
+        it("the backoff doubles with each retry", () => {
+            expect(pickNew(one, failedAt(2), 1, T0 + 4 * LAUNCH_RETRY_BASE_MS - 1)).toEqual([]);
+            expect(pickNew(one, failedAt(2), 1, T0 + 4 * LAUNCH_RETRY_BASE_MS).map((i) => i.id)).toEqual(["a"]);
+        });
+        it("never after the last retry", () => {
+            expect(pickNew(one, failedAt(MAX_LAUNCH_RETRIES), 1, T0 + 1e12)).toEqual([]);
+        });
+        it("never when Claude did start (a room follow-up resumes that one)", () => {
+            expect(pickNew(one, failedAt(0, { claudeSessionId: "c1" }), 1, T0 + 1e12)).toEqual([]);
+        });
+        it("never a run that finished", () => {
+            const state = { runs: { a: { sessionId: "a", status: "done", startedAt: "t", finishedAt: new Date(T0).toISOString() } } };
+            expect(pickNew(one, state, 1, T0 + 1e12)).toEqual([]);
+        });
+    });
 });
-describe("findMcpServerName", () => {
-    it("finds the user-scope server pointing at the pod", () => {
-        const cj = { mcpServers: { other: { url: "https://x/mcp" }, "synap-pod": { url: "https://pod.example/mcp/" } } };
-        expect(findMcpServerName(cj, "https://pod.example")).toBe("synap-pod");
+describe("the run's MCP server is pinned to the worker agent's own key", () => {
+    // A `synap login --reconnect` on the box rewrote ~/.claude.json with ANOTHER
+    // agent's key; runs that inherited it posted as that agent (2026-10-20).
+    it("points one http server at the pod with the worker's key", () => {
+        expect(runMcpConfig("https://pod.example/", "synap_hub_k")).toEqual({
+            mcpServers: {
+                [RUN_MCP_SERVER]: {
+                    type: "http",
+                    url: "https://pod.example/mcp",
+                    headers: { Authorization: "Bearer synap_hub_k", "X-Synap-Model-Provider": "anthropic" },
+                },
+            },
+        });
     });
-    it("falls back to a project-scope server", () => {
-        const cj = { projects: { "/w": { mcpServers: { s: { url: "https://pod.example/mcp" } } } } };
-        expect(findMcpServerName(cj, "https://pod.example/")).toBe("s");
+    it("names the run's Claude session as the conversation, so the pod sees one run", () => {
+        const sid = "8c34a72b-b1c1-4c37-9c1f-02920b69ccb2";
+        const cfg = runMcpConfig("https://pod.example", "k", sid);
+        expect(cfg.mcpServers[RUN_MCP_SERVER].headers).toEqual({
+            Authorization: "Bearer k",
+            "X-Synap-Conversation": `claude-code:${sid}`,
+            "X-Synap-Model-Provider": "anthropic",
+        });
     });
-    it("returns null when none matches", () => {
-        expect(findMcpServerName({ mcpServers: { s: { url: "https://other/mcp" } } }, "https://pod.example")).toBeNull();
+    it("writes it owner-only, replacing a wider file", () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "worker-mcp-"));
+        const file = path.join(dir, "mcp.json");
+        fs.writeFileSync(file, "{}", { mode: 0o644 });
+        const written = writeRunMcpConfig(dir, runMcpConfig("https://pod.example", "k"));
+        expect(written).toBe(file);
+        expect(fs.statSync(file).mode & 0o777).toBe(0o600);
+        expect(JSON.parse(fs.readFileSync(file, "utf8")).mcpServers[RUN_MCP_SERVER].url).toBe("https://pod.example/mcp");
     });
 });
 describe("workerEnv", () => {
@@ -67,6 +147,12 @@ describe("prompt + verdict", () => {
         expect(p).toContain("devbox/c5a34b78-");
         expect(p).toContain("WORKER-RESULT:");
     });
+    it("lets the goal name the directory and allows only a preview deploy the goal asks for", () => {
+        const p = buildWorkerPrompt({ sessionId: "c5a34b78-0000", goal: "g", agentName: "cc-devbox", cwd: "/w", mcpServer: "synap-pod" });
+        expect(p).toContain("Work in /w, or in the directory the session goal names");
+        expect(p).toContain("Never deploy to production");
+        expect(p).toContain("preview deploy only when the session goal asks for one");
+    });
     it("reads the last WORKER-RESULT line", () => {
         expect(workerVerdict("work\nWORKER-RESULT: done — posted report")).toBe("done — posted report");
         expect(workerVerdict("no verdict here")).toBeUndefined();
@@ -113,4 +199,495 @@ describe("followUpsSince", () => {
         expect(MAX_RESUMES).toBeGreaterThan(0);
     });
 });
+// ─── night shift: limits, design runs, the protocol ──────────────────────────
+import { BG_SETTLE_MS, bgPhase, DESIGN_OUTCOME_KIND, endedOnLimit, foldRunEvent, isDesignSession, limitUntil, parseAgentsList, parseBgId, readTranscriptEnd, } from "./worker.js";
+const fold = (lines) => {
+    const rejected = {};
+    return lines.reduce((end, ev) => foldRunEvent(end, ev, rejected), {});
+};
+// Reduced from a real `claude -p … --output-format stream-json --verbose` run on
+// Claude Code 2.1.309 (2026-10-23): field names verbatim.
+const OK_STREAM = [
+    { type: "system", subtype: "init", session_id: "0d6b64a2-9d15-444e-be4e-a8f449b51b7f", claude_code_version: "2.1.309" },
+    { type: "assistant", parent_tool_use_id: null, session_id: "0d6b64a2", message: { role: "assistant", content: [{ type: "text", text: "WORKER-RESULT: done — ok" }] } },
+    { type: "rate_limit_event", rate_limit_info: { status: "allowed", resetsAt: 1792725000, rateLimitType: "five_hour" }, session_id: "0d6b64a2" },
+    { type: "result", subtype: "success", is_error: false, api_error_status: null, result: "WORKER-RESULT: done — ok", session_id: "0d6b64a2" },
+];
+// A usage limit, in the stream's spelling. The assistant fields are the real
+// transcript entry's (507 of them in this Mac's ~/.claude/projects: error
+// "rate_limit", apiError "usage_limit_reached", apiErrorStatus 429,
+// apiErrorParams.rate_limit_info.resetsAt) renamed the way the 2.1.309 binary
+// maps them onto SDKAssistantMessage (api_error_status, api_error_params).
+const LIMIT_STREAM = [
+    { type: "system", subtype: "init", session_id: "s-limit" },
+    { type: "assistant", parent_tool_use_id: null, message: { content: [{ type: "text", text: "Working on it." }] } },
+    { type: "rate_limit_event", rate_limit_info: { status: "rejected", resetsAt: 1792474200, rateLimitType: "five_hour" } },
+    {
+        type: "assistant",
+        parent_tool_use_id: null,
+        error: "rate_limit",
+        api_error: "usage_limit_reached",
+        api_error_status: 429,
+        api_error_params: { rate_limit_info: { status: "rejected", resetsAt: 1792474200, rateLimitType: "five_hour" } },
+        message: { model: "<synthetic>", content: [{ type: "text", text: "You've hit your session limit · resets 7:30am (Europe/Paris)" }] },
+    },
+    { type: "result", subtype: "success", is_error: true, api_error_status: 429, result: "You've hit your session limit · resets 7:30am (Europe/Paris)" },
+];
+describe("a run that ends on a usage limit", () => {
+    it("is told apart from a run that finished", () => {
+        const ok = fold(OK_STREAM);
+        expect(ok.claudeSessionId).toBe("0d6b64a2-9d15-444e-be4e-a8f449b51b7f");
+        expect(endedOnLimit(ok)).toBeUndefined();
+        expect(endedOnLimit(fold(LIMIT_STREAM))).toEqual({ error: "rate_limit", resetsAt: 1792474200_000 });
+    });
+    it("the assistant's limit error alone counts (no result line: the process died after it), with its own reset", () => {
+        const own = { ...LIMIT_STREAM[3], api_error_params: { rate_limit_info: { status: "rejected", resetsAt: 1792480000 } } };
+        expect(endedOnLimit(fold([LIMIT_STREAM[0], own]))).toEqual({ error: "rate_limit", resetsAt: 1792480000_000 });
+        expect(endedOnLimit(fold([LIMIT_STREAM[0], { ...own, error: "billing_error" }]))?.error).toBe("billing_error");
+    });
+    it("a 429 result alone counts, with the reset from the rejected rate_limit_event", () => {
+        const end = fold([LIMIT_STREAM[0], LIMIT_STREAM[2], { type: "result", is_error: true, api_error_status: 429, result: "x" }]);
+        expect(endedOnLimit(end)).toEqual({ error: "rate_limit", resetsAt: 1792474200_000 });
+    });
+    it("a limit a later healthy turn got past is not how the run ended", () => {
+        expect(endedOnLimit(fold([LIMIT_STREAM[3], OK_STREAM[1]]))).toBeUndefined();
+    });
+    it("a subagent's limit does not decide the run", () => {
+        expect(endedOnLimit(fold([{ ...LIMIT_STREAM[3], parent_tool_use_id: "toolu_1" }]))).toBeUndefined();
+    });
+    it("a printed WORKER-RESULT verdict means the protocol finished", () => {
+        const end = fold([...LIMIT_STREAM.slice(0, 4), { type: "result", is_error: true, api_error_status: 429, result: "WORKER-RESULT: done — x" }]);
+        expect(endedOnLimit(end)).toBeUndefined();
+    });
+    it("the account is out until the reset, or a quarter hour (an hour for billing) when none was given", () => {
+        const now = 1_000_000;
+        expect(limitUntil({ error: "rate_limit", resetsAt: now + 5 }, now)).toBe(now + 5);
+        expect(limitUntil({ error: "rate_limit" }, now)).toBe(now + 15 * 60_000);
+        expect(limitUntil({ error: "billing_error" }, now)).toBe(now + 60 * 60_000);
+    });
+});
+describe("design runs: the structured signal", () => {
+    const session = (outcomes) => JSON.stringify({ session: { id: "s" }, outcomes });
+    it("an outcome of kind 'design' makes it a design run", () => {
+        expect(DESIGN_OUTCOME_KIND).toBe("design");
+        expect(isDesignSession(session({ status: "ok", outcomes: [{ key: "pr", kind: "code" }, { key: "design", kind: "design" }] }))).toBe(true);
+        expect(isDesignSession(session({ status: "ok", outcomes: [{ key: "design-notes", kind: "document" }] }))).toBe(false);
+    });
+    it("the goal text is never read for it", () => {
+        const s = JSON.stringify({ session: { goal: "design the landing page" }, outcomes: { status: "ok", outcomes: [] } });
+        expect(isDesignSession(s)).toBe(false);
+    });
+    it("outcomes that could not be read THROW — never 'not a design run'", () => {
+        expect(() => isDesignSession(session({ status: "unavailable", reason: "read_failed" }))).toThrow(/unavailable/);
+        expect(() => isDesignSession(JSON.stringify({ session: {} }))).toThrow(/missing/);
+        expect(() => isDesignSession(JSON.stringify({ error: "Focus session x not found" }))).toThrow(/not found/);
+    });
+});
+describe("background (design) runs: how they are watched", () => {
+    it("reads the short id `claude --bg` prints (verbatim 2.1.309 output)", () => {
+        const out = "Starting background service…\nbackgrounded · fd009109\n  claude agents             list sessions\n  claude attach fd009109    open in this terminal\n";
+        expect(parseBgId(out)).toBe("fd009109");
+        expect(parseBgId("Error: not logged in")).toBeUndefined();
+    });
+    it("maps `claude agents --json --all` states (verbatim 2.1.309 entry first)", () => {
+        const list = parseAgentsList(JSON.stringify([
+            { pid: 20822, id: "fd009109", cwd: "/w", kind: "background", startedAt: 1792723262938, sessionId: "fd009109-0488-47e7-a314-064ba85d1c5e", name: "bg test", status: "idle", state: "done" },
+            { id: "aa", state: "blocked" },
+            { id: "bb", state: "working", status: "busy" },
+            { id: "cc", state: "failed" },
+        ]));
+        expect(list.map((e) => bgPhase(e))).toEqual(["finished", "blocked", "running", "finished"]);
+        expect(bgPhase(undefined)).toBe("gone");
+        expect(() => parseAgentsList("{}")).toThrow();
+    });
+    it("the transcript gives the final text and a limit, counting only entries since the launch", () => {
+        const t0 = Date.parse("2026-10-23T02:41:00Z");
+        const lines = [
+            { type: "assistant", timestamp: "2026-10-23T02:40:00Z", message: { content: [{ type: "text", text: "WORKER-RESULT: done — old turn" }] } },
+            { type: "user", timestamp: "2026-10-23T02:41:01Z", message: { content: "go" } },
+            { type: "assistant", timestamp: "2026-10-23T02:41:05Z", message: { content: [{ type: "thinking" }] } },
+            { type: "assistant", timestamp: "2026-10-23T02:41:06Z", message: { content: [{ type: "text", text: "WORKER-RESULT: done — new turn" }] } },
+        ].map((l) => JSON.stringify(l));
+        const end = readTranscriptEnd(lines.join("\n"), t0);
+        expect(end.seen).toBe(2);
+        expect(end.text).toBe("WORKER-RESULT: done — new turn");
+        expect(readTranscriptEnd(lines.slice(0, 1).join("\n"), t0).seen).toBe(0);
+        // The real transcript spelling of a usage limit.
+        const limit = JSON.stringify({
+            type: "assistant",
+            timestamp: "2026-10-23T02:42:00Z",
+            isSidechain: false,
+            isApiErrorMessage: true,
+            error: "rate_limit",
+            apiError: "usage_limit_reached",
+            apiErrorStatus: 429,
+            apiErrorParams: { rate_limit_info: { status: "rejected", resetsAt: 1792474200, rateLimitType: "five_hour" } },
+            message: { content: [{ type: "text", text: "You've hit your session limit · resets 7:30am (Europe/Paris)" }] },
+        });
+        expect(endedOnLimit(readTranscriptEnd([lines[1], limit].join("\n"), t0))).toEqual({ error: "rate_limit", resetsAt: 1792474200_000 });
+        expect(BG_SETTLE_MS).toBeGreaterThan(0);
+    });
+});
+describe("the night protocol in the prompt", () => {
+    const p = (design = false) => buildWorkerPrompt({ sessionId: "c5a34b78-0000", goal: "g", agentName: "cc-devbox", cwd: "/w", mcpServer: "synap-pod", design });
+    it("every run: worktree branch, a DRAFT PR at most, never merge / push main", () => {
+        expect(p()).toContain("git worktree on a branch named devbox/c5a34b78-<slug>");
+        expect(p()).toContain("open a DRAFT pull request (gh pr create --draft); never merge one");
+        expect(p()).toContain("never push to main");
+    });
+    it("every run records every deliverable with its ref, and says what to look at first", () => {
+        expect(p()).toContain("Record EVERY deliverable as a session output");
+        expect(p()).toContain("outcomes:[{key, label, kind, ref:{url}}]");
+        expect(p()).toContain("the draft PR (ref = its URL), the branch, the gate summary path");
+        expect(p()).toContain('starting "Look at first:"');
+    });
+    it("a run never completes its own PR, branch or commit: a PR is delivered when it merges", () => {
+        expect(p()).toContain("Never completeOutput a pull request, a branch or a commit");
+        expect(p()).toContain("the merge sweeper marks it met then");
+        expect(p()).not.toMatch(/completeOutput <key> for each —/);
+        expect(p(true)).toContain("Never completeOutput a pull request, a branch or a commit");
+    });
+    it("a design run is told to quickstart the Artifact tool, publish, and store the URL on the session and the subject", () => {
+        const d = p(true);
+        expect(d).toContain('Artifact tool with action "quickstart" and intent "design" FIRST');
+        expect(d).toContain("the outcome of kind \"design\", ref = the artifact's claude.ai URL");
+        expect(d).toContain("subject entity");
+        expect(p()).not.toContain("quickstart");
+    });
+});
+describe("a code run's own tree folder in the prompt", () => {
+    const p = (treeDir) => buildWorkerPrompt({ sessionId: "c5a34b78-0000", goal: "g", agentName: "cc", cwd: "/w", mcpServer: "m", treeDir });
+    it("names the folder, a --no-track worktree there (concurrent adds race on the repo config), and forbids the shared clone", () => {
+        expect(p("/t/c5a34b78")).toContain("git -C /w/<repo> worktree add --no-track /t/c5a34b78/<repo> -b devbox/c5a34b78-<slug> origin/main");
+        expect(p("/t/c5a34b78")).toContain("never in /w/<repo> itself");
+    });
+    it("without a folder the prompt is what it was", () => {
+        expect(p()).not.toContain("worktree add");
+    });
+});
+describe("workerEnv with a GitHub token", () => {
+    const g = { token: "ghs_app", sock: "/s", binDir: "/bin-synap", gitHelper: "/bin-synap/h", ghConfigDir: "/c" };
+    it("puts the App token in GH_TOKEN and the helpers first on PATH, over an inherited GH_TOKEN", () => {
+        const env = workerEnv({ GH_TOKEN: "founder", PATH: "/usr/bin" }, undefined, undefined, g);
+        expect(env.GH_TOKEN).toBe("ghs_app");
+        expect(env.GITHUB_TOKEN).toBe("ghs_app");
+        expect(env.PATH).toBe("/bin-synap:/usr/bin");
+    });
+    it("without the App, an inherited GH_TOKEN is NOT passed on", () => {
+        expect(workerEnv({ GH_TOKEN: "founder" }).GH_TOKEN).toBeUndefined();
+    });
+});
+describe("workerEnv is an allowlist: a secret in the worker's env never reaches a run", () => {
+    const worker = {
+        PATH: "/usr/bin",
+        HOME: "/h",
+        LANG: "C",
+        TERM: "xterm",
+        LC_ALL: "C",
+        CLAUDE_CODE_OAUTH_TOKEN: "oauth",
+        CLAUDE_CONFIG_DIR: "/cc",
+        SYNAP_AGENT: "a",
+        SYNAP_POD_URL: "https://pod",
+        VERCEL_TOKEN: "v",
+        VERCEL_ORG_ID: "o",
+        CLOUDFLARE_API_TOKEN: "c",
+        GH_TOKEN: "founder",
+        GITHUB_TOKEN: "founder",
+        NPM_TOKEN: "n",
+        AWS_SECRET_ACCESS_KEY: "a",
+        SSH_AUTH_SOCK: "/ssh",
+        ANTHROPIC_API_KEY: "sk",
+        ANTHROPIC_AUTH_TOKEN: "t",
+        ANTHROPIC_BASE_URL: "u",
+    };
+    it("VERCEL_*, CLOUDFLARE_*, GH_TOKEN, ANTHROPIC_* and any other secret are not visible to the run", () => {
+        const env = workerEnv(worker);
+        for (const k of ["VERCEL_TOKEN", "VERCEL_ORG_ID", "CLOUDFLARE_API_TOKEN", "GH_TOKEN", "GITHUB_TOKEN", "NPM_TOKEN", "AWS_SECRET_ACCESS_KEY", "SSH_AUTH_SOCK", "ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_BASE_URL"]) {
+            expect(env[k], k).toBeUndefined();
+        }
+    });
+    it("keeps what the run needs: PATH, HOME, locale, the Claude login and the pod vars", () => {
+        expect(workerEnv(worker)).toEqual({
+            PATH: "/usr/bin",
+            HOME: "/h",
+            LANG: "C",
+            TERM: "xterm",
+            LC_ALL: "C",
+            CLAUDE_CODE_OAUTH_TOKEN: "oauth",
+            CLAUDE_CONFIG_DIR: "/cc",
+            SYNAP_AGENT: "a",
+            SYNAP_POD_URL: "https://pod",
+        });
+    });
+});
+describe("workerEnv with an account", () => {
+    it("the chosen token REPLACES an inherited one", () => {
+        const env = workerEnv({ CLAUDE_CODE_OAUTH_TOKEN: "inherited", CLAUDE_CODE_OAUTH_TOKEN_FILE_DESCRIPTOR: "4" }, undefined, "chosen");
+        expect(env.CLAUDE_CODE_OAUTH_TOKEN).toBe("chosen");
+        expect(env.CLAUDE_CODE_OAUTH_TOKEN_FILE_DESCRIPTOR).toBeUndefined();
+        expect(workerEnv({ CLAUDE_CODE_OAUTH_TOKEN: "inherited" }).CLAUDE_CODE_OAUTH_TOKEN).toBe("inherited");
+    });
+});
+// ─── protocols: code vs work folder ──────────────────────────────────────────
+import { ASK_WAIT_MINUTES, buildWorkFolderPrompt, CODE_OUTPUT_KINDS, REPO_PARAM_KEYS, sessionProtocol, workFolderFor, } from "./worker.js";
+describe("sessionProtocol: which protocol a handed session gets", () => {
+    const read = (session) => JSON.stringify({ session: { id: "s", goal: "g", ...session }, outcomes: { status: "ok", outcomes: [] } });
+    // The shape of a Produce Content run (content-os.yaml): params post/platform/format, a
+    // document at Script, a content-composition at Draft.
+    const produceContent = {
+        playbookId: "pb-produce-content",
+        subjectEntityId: "post-1",
+        metadata: { prompt: "Produce content for instagram…", params: { post: "post-1", platform: "instagram", format: "video" } },
+        expectedOutputs: [],
+        stages: [
+            { key: "brief", name: "Brief" },
+            { key: "script", expectedOutputs: [{ kind: "document", label: "Script" }] },
+            { key: "draft", expectedOutputs: [{ kind: "content-composition", label: "Composition" }] },
+        ],
+    };
+    it("a playbook run over pod data gets the work folder, from its first stage", () => {
+        expect(sessionProtocol(read(produceContent))).toBe("work-folder");
+        expect(sessionProtocol(read({ playbookId: "pb", metadata: {}, stages: [] }))).toBe("work-folder");
+    });
+    it("an ad-hoc hand-off (no playbook) keeps the code protocol, whatever it declares", () => {
+        expect(sessionProtocol(read({ playbookId: null }))).toBe("code");
+        expect(sessionProtocol(read({}))).toBe("code");
+        expect(sessionProtocol(read({ playbookId: null, expectedOutputs: [{ kind: "document", label: "Report" }] }))).toBe("code");
+    });
+    it("a playbook run whose params name a repo or a branch is code (the keys the dispatch path mounts)", () => {
+        expect([...REPO_PARAM_KEYS]).toEqual(["repo", "repos", "branch"]);
+        for (const params of [{ repo: "Synap-core/backend" }, { repos: ["Synap-core/synap-cli"] }, { branch: "fix/x" }]) {
+            expect(sessionProtocol(read({ ...produceContent, metadata: { params } })), JSON.stringify(params)).toBe("code");
+        }
+        // Blank values name nothing.
+        expect(sessionProtocol(read({ ...produceContent, metadata: { params: { repo: " ", repos: [] } } }))).toBe("work-folder");
+    });
+    it("a playbook run declaring a code deliverable — on the session or on ANY stage — is code", () => {
+        for (const kind of CODE_OUTPUT_KINDS) {
+            expect(sessionProtocol(read({ ...produceContent, expectedOutputs: [{ kind, label: "x" }] })), kind).toBe("code");
+            const stages = [...produceContent.stages, { key: "ship", expectedOutputs: [{ kind, label: "x" }] }];
+            expect(sessionProtocol(read({ ...produceContent, stages })), `stage ${kind}`).toBe("code");
+        }
+    });
+    it("the goal and the instruction are never read for it", () => {
+        const codey = { ...produceContent, goal: "open a pull request on the repo", metadata: { prompt: "git worktree, branch, PR" } };
+        expect(sessionProtocol(read(codey))).toBe("work-folder");
+    });
+    it("an unreadable session THROWS — never 'a code session'", () => {
+        expect(() => sessionProtocol("Error: pod down")).toThrow(/did not return JSON/);
+        expect(() => sessionProtocol(JSON.stringify({ error: "Focus session x not found" }))).toThrow(/not found/);
+        expect(() => sessionProtocol(JSON.stringify({ session: null, message: "You have no open focus session." }))).toThrow(/no session/);
+    });
+});
+describe("the work-folder protocol in the prompt", () => {
+    const sid = "8c34a72b-b1c1-4c37-9c1f-02920b69ccb2";
+    const p = buildWorkFolderPrompt({ sessionId: sid, goal: "Produce Content for a post", agentName: "mac", workDir: `/Users/x/synap-work/${sid}`, mcpServer: "synap-worker" });
+    it("works in the session's folder, with no git", () => {
+        expect(workFolderFor("/Users/x/synap-work", sid)).toBe(`/Users/x/synap-work/${sid}`);
+        expect(p).toContain(`Work folder: /Users/x/synap-work/${sid}`);
+        expect(p).toContain("No git, no branch, no repository, no pull request");
+        expect(p).not.toMatch(/worktree|devbox\/|gh pr/);
+    });
+    it("reads the playbook's instruction, stage and subject", () => {
+        expect(p).toContain("session.metadata.prompt");
+        expect(p).toContain("session.currentStage");
+        expect(p).toContain("synap_get_entity");
+    });
+    it("names where a run's params are (the pod stores them on metadata.params)", () => {
+        expect(p).toContain("The run's params are in session.metadata.params, by param name");
+        expect(p).toContain("session.metadata.params.takes");
+    });
+    it("keeps a take's transcript in ONE shape: the content-asset Content Studio writes, found before it is made", () => {
+        expect(p).toContain("A transcript of a recording is never a new document");
+        expect(p).toContain("ONE content-asset (Kind script, File ID = the take's file id)");
+        expect(p).toContain('the readable text under a "## Transcript" heading');
+        expect(p).toContain('then a "## Words" heading followed by exactly one ```json block of word timings [{"text","start","end"}]');
+        expect(p).toContain("Find it before transcribing");
+        expect(p).toContain("reuse it and only fill the word timings");
+        expect(p).toContain("synap_link_entities type references");
+    });
+    it("asks through a human-owned slot and waits for the answer — never a room QUESTION:", () => {
+        expect(p).toContain('owner:"human"');
+        expect(p).toContain("ask:{mode:");
+        expect(p).toContain("synap_wait_for_answer");
+        expect(p).toContain(`up to ${ASK_WAIT_MINUTES} minutes`);
+        expect(p).toContain('never a room "QUESTION:" line');
+        expect(p).not.toMatch(/post in the room starting with "QUESTION:"/);
+    });
+    it("files every deliverable to the pod and records it on the declared slot", () => {
+        expect(p).toContain("synap upload <path> --json");
+        expect(p).toContain("synap_create_document");
+        expect(p).toContain("reuse the key of the slot already declared");
+        expect(p).toContain("completeOutput <key>");
+    });
+    it("never publishes outward nor works around a human gate, and reports the same way as a code run", () => {
+        expect(p).toContain("Publish nothing outward");
+        expect(p).toContain("never approve, skip or work around it");
+        expect(p).toContain('starting "Look at first:"');
+        expect(p).toContain("WORKER-RESULT: done | blocked | failed");
+    });
+});
+describe("a run's process and end, as the pod reads them", () => {
+    const POD_PROCESS_RE = /^([A-Za-z0-9._-]{1,255}):(\d{1,10}):(\d{10,14})$/;
+    it("the process identity is <host>:<pid>:<launch ms>, in the pod's own shape, whatever the hostname", () => {
+        expect(runProcessIdentity(1_792_000_000_123, "devbox", 4242)).toBe("devbox:4242:1792000000123");
+        expect(runProcessIdentity(1_792_000_000_123, "MacBook Pro de Antoine.local", 7)).toMatch(POD_PROCESS_RE);
+        expect(runProcessIdentity(1_792_000_000_123, "", 7)).toBe("computer:7:1792000000123");
+    });
+    it("the run's config says busy for that process; nothing is claimed without a conversation", () => {
+        const sid = "8c34a72b-b1c1-4c37-9c1f-02920b69ccb2";
+        const cfg = runMcpConfig("https://pod.example", "k", sid, "devbox:1:1792000000000");
+        expect(cfg.mcpServers[RUN_MCP_SERVER].headers).toMatchObject({
+            "X-Synap-Process": "devbox:1:1792000000000",
+            "X-Synap-Runner-State": "busy",
+        });
+        expect(runEndHeaders({ claudeSessionId: sid, process: "devbox:1:1792000000000" })).toEqual({
+            "X-Synap-Conversation": `claude-code:${sid}`,
+            "X-Synap-Process": "devbox:1:1792000000000",
+            "X-Synap-Runner-State": "ended",
+            "X-Synap-Model-Provider": "anthropic",
+        });
+        expect(runEndHeaders({ process: "devbox:1:1792000000000" })).toBeUndefined();
+        expect(runEndHeaders({ claudeSessionId: sid })).toBeUndefined();
+    });
+});
+describe("the verdict, read for the session", () => {
+    it("parses done | blocked | failed and the sentence; anything else is no verdict", () => {
+        expect(parseVerdict("done — PR #4 is open")).toEqual({ status: "done", sentence: "PR #4 is open" });
+        expect(parseVerdict("Blocked - needs the key")).toEqual({ status: "blocked", sentence: "needs the key" });
+        expect(parseVerdict("failed")).toEqual({ status: "failed", sentence: "" });
+        // The prompt's template echoed back names no status: no verdict.
+        expect(parseVerdict("done | blocked | failed — <one sentence>")).toBeUndefined();
+        expect(parseVerdict("done|blocked|failed")).toBeUndefined();
+        expect(parseVerdict("maybe — later")).toBeUndefined();
+        expect(parseVerdict(undefined)).toBeUndefined();
+    });
+    const read = (outcomes, status = "ok") => JSON.stringify({ outcomes: { status, outcomes } });
+    it("claims only the ONE open deliverable the agent owns; none and several are told apart", () => {
+        expect(verdictClaim(read([{ key: "v", kind: "file", owner: "agent", met: false }]))).toEqual({ kind: "one", key: "v" });
+        expect(verdictClaim(read([{ key: "v", kind: "file", owner: "agent", met: false }, { key: "w", kind: "file", met: false }]))).toEqual({
+            kind: "several",
+            keys: ["v", "w"],
+        });
+        expect(verdictClaim(read([{ key: "q", kind: "decision", owner: "human", met: false }]))).toEqual({ kind: "none" });
+        expect(verdictClaim(read([{ key: "f", kind: "fact", owner: "agent", met: false }]))).toEqual({ kind: "none" });
+        expect(verdictClaim(read([]))).toEqual({ kind: "none" });
+    });
+    it("never claims a pull request, a branch or a commit: a PR is delivered only when it merges", () => {
+        const pr = { key: "pr-backend-12", kind: "pull_request", owner: "agent", met: false, ref: { url: "https://github.com/o/r/pull/12" } };
+        expect(verdictClaim(read([pr]))).toEqual({ kind: "none" });
+        expect(verdictClaim(read([{ key: "branch-x", kind: "branch", met: false }, { key: "commit-r-abc", kind: "commit", met: false }]))).toEqual({
+            kind: "none",
+        });
+        // The one claimable deliverable beside an open PR is still the one.
+        expect(verdictClaim(read([pr, { key: "gate", kind: "file", owner: "agent", met: false }]))).toEqual({ kind: "one", key: "gate" });
+    });
+    it("an outcomes list that could not be read is unreadable, never \"nothing open\"", () => {
+        expect(verdictClaim(read([{ key: "v", kind: "file", owner: "agent", met: false }], "unavailable")).kind).toBe("unreadable");
+        expect(verdictClaim("not json").kind).toBe("unreadable");
+        expect(verdictClaim(JSON.stringify({ session: {} })).kind).toBe("unreadable");
+        expect(verdictClaim(JSON.stringify({ outcomes: { status: "ok" } })).kind).toBe("unreadable");
+    });
+    it("done is heard only from a clean exit; blocked and failed stand", () => {
+        const done = { status: "done", sentence: "PR #4 is open" };
+        expect(verdictForExit(done, true, 0)).toEqual(done);
+        expect(verdictForExit(done, false, 1)).toEqual({ status: "failed", sentence: "the run exited 1; it said done — PR #4 is open" });
+        expect(verdictForExit({ status: "done", sentence: "" }, false, undefined)).toEqual({ status: "failed", sentence: "the run did not end cleanly" });
+        expect(verdictForExit({ status: "blocked", sentence: "b" }, false, 1)).toEqual({ status: "blocked", sentence: "b" });
+    });
+    it("a quiet period that began after the run launched is the run's own activity", () => {
+        const rec = { launchedAt: "2026-10-31T10:00:00.000Z" };
+        expect(quietIsOwnRun({ quietSince: "2026-10-31T10:05:00.000Z" }, rec)).toBe(true);
+        expect(quietIsOwnRun({ quietSince: "2026-10-31T10:00:00.000Z" }, rec)).toBe(true);
+        expect(quietIsOwnRun({ quietSince: "2026-10-31T09:59:59.000Z" }, rec)).toBe(false);
+        expect(quietIsOwnRun({}, rec)).toBe(false);
+        expect(quietIsOwnRun({ quietSince: "not a date" }, rec)).toBe(false);
+        expect(quietIsOwnRun({ quietSince: "2026-10-31T10:05:00.000Z" }, {})).toBe(false);
+    });
+});
+describe("an MCP call's own headers", () => {
+    it("ride on that call only, never on the handshake or the next call", async () => {
+        const sent = [];
+        const fetchImpl = (async (_u, init) => {
+            const body = JSON.parse(String(init.body));
+            sent.push({ method: body.method, headers: init.headers });
+            return new Response(JSON.stringify({ jsonrpc: "2.0", id: body.id, result: { content: [{ type: "text", text: "{}" }] } }), {
+                status: 200,
+                headers: { "content-type": "application/json" },
+            });
+        });
+        const mcp = createMcpClient({ url: "https://pod/mcp", apiKey: "k", fetchImpl });
+        await mcp.call("synap_orient", {}, { headers: { "X-Synap-Runner": "synap-worker/1", Authorization: "Bearer other" } });
+        await mcp.call("synap_get_session", { sessionId: "s" });
+        const calls = sent.filter((s) => s.method === "tools/call");
+        expect(calls[0].headers["X-Synap-Runner"]).toBe("synap-worker/1");
+        // An extra header never replaces the key.
+        expect(calls[0].headers.Authorization).toBe("Bearer k");
+        expect(calls[1].headers["X-Synap-Runner"]).toBeUndefined();
+        for (const s of sent.filter((s) => s.method !== "tools/call"))
+            expect(s.headers["X-Synap-Runner"]).toBeUndefined();
+    });
+});
+describe("what a run runs on, as the pod reads it (X-Synap-Model / X-Synap-Model-Provider)", () => {
+    const sid = "8c34a72b-b1c1-4c37-9c1f-02920b69ccb2";
+    const headersOf = (cfg) => cfg.mcpServers[RUN_MCP_SERVER].headers;
+    it("the run's config names the subscription's provider always, and the model once known", () => {
+        expect(headersOf(runMcpConfig("https://pod.example", "k", sid, "devbox:1:1792000000000"))).not.toHaveProperty("X-Synap-Model");
+        expect(headersOf(runMcpConfig("https://pod.example", "k", sid, "devbox:1:1792000000000", "claude-opus-5-5"))).toMatchObject({
+            "X-Synap-Model": "claude-opus-5-5",
+            "X-Synap-Model-Provider": "anthropic",
+        });
+    });
+    it("the model is read from the stream's init; a non-id (a synthetic marker, a URL) is never reported", () => {
+        const init = (model) => foldOne({}, { type: "system", subtype: "init", session_id: sid, model });
+        expect(init("claude-opus-5-5").model).toBe("claude-opus-5-5");
+        expect(init("claude-opus-4-6[1m]").model).toBe("claude-opus-4-6[1m]");
+        expect(init("<synthetic>").model).toBeUndefined();
+        expect(init("https://gw.example/v1").model).toBeUndefined();
+        expect(init(42).model).toBeUndefined();
+    });
+    it("the end-of-run calls carry the model the run said, beside the subscription's provider", () => {
+        expect(runEndHeaders({ claudeSessionId: sid, process: "devbox:1:1792000000000", model: "claude-opus-5-5" })).toMatchObject({
+            "X-Synap-Model": "claude-opus-5-5",
+            "X-Synap-Model-Provider": "anthropic",
+        });
+    });
+});
+describe("workerEnv never passes a provider switch: a run reports anthropic only because it runs on it", () => {
+    const worker = {
+        PATH: "/usr/bin",
+        CLAUDE_CONFIG_DIR: "/cc",
+        CLAUDE_CODE_OAUTH_TOKEN: "oauth",
+        CLAUDE_CODE_SUBAGENT_MODEL: "claude-haiku-5-5",
+        CLAUDE_CODE_USE_POWERSHELL_TOOL: "1",
+        CLAUDE_CODE_USE_BEDROCK: "1",
+        CLAUDE_CODE_USE_VERTEX: "1",
+        CLAUDE_CODE_USE_FOUNDRY: "1",
+        CLAUDE_CODE_USE_MANTLE: "1",
+        CLAUDE_CODE_USE_ANTHROPIC_AWS: "1",
+        CLAUDE_CODE_SKIP_BEDROCK_AUTH: "1",
+        CLAUDE_CODE_SKIP_VERTEX_AUTH: "1",
+        CLAUDE_CODE_SKIP_FOUNDRY_AUTH: "1",
+        CLAUDE_CODE_SKIP_MANTLE_AUTH: "1",
+        CLAUDE_CODE_SKIP_ANTHROPIC_AWS_AUTH: "1",
+        CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST: "1",
+    };
+    it("blocks every provider switch, a future CLAUDE_CODE_USE_<provider> too", () => {
+        const env = workerEnv({ ...worker, CLAUDE_CODE_USE_SOMECLOUD: "1" });
+        for (const k of Object.keys(worker).filter((k) => /USE_(?!POWERSHELL)|SKIP_.*_AUTH|MANAGED_BY_HOST/.test(k))) {
+            expect(env[k], k).toBeUndefined();
+        }
+        expect(env.CLAUDE_CODE_USE_SOMECLOUD).toBeUndefined();
+    });
+    it("keeps the Claude vars a run needs, the one non-provider USE_ flag included", () => {
+        expect(workerEnv(worker)).toEqual({
+            PATH: "/usr/bin",
+            CLAUDE_CONFIG_DIR: "/cc",
+            CLAUDE_CODE_OAUTH_TOKEN: "oauth",
+            CLAUDE_CODE_SUBAGENT_MODEL: "claude-haiku-5-5",
+            CLAUDE_CODE_USE_POWERSHELL_TOOL: "1",
+        });
+        expect(RUN_ENV_BLOCKLIST.some((re) => re.test("CLAUDE_CONFIG_DIR"))).toBe(false);
+    });
+});
 //# sourceMappingURL=worker.test.js.map