deepdebug-local-agent 1.9.0 → 1.10.0

package/test/la-protocol-v2/jobs-manager.test.js

@@ -0,0 +1,370 @@
+// F3-10 (2), the supervisor in isolation (fake session, scripted runners, fake clock where it matters): admission (concurrency, queue, memory, RSS),
+// idempotent job ids, budget clamp, cancel (running, queued, unknown, a runner that ignores it), deadline, event coalescing and backpressure,
+// terminal frames that are never lost, result field fallback. The end-to-end run through the real session and the smoke runner is jobs-e2e.test.js.
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { createJobManager, validateRunner, jobErrorCodeOf } from "../../src/la-protocol-v2/jobs/manager.js";
+import { resolveJobsConfig } from "../../src/la-protocol-v2/jobs/config.js";
+import { eventPayload, resultPayload } from "../../src/la-protocol-v2/jobs/events.js";
+import { ProtocolError } from "../../src/la-protocol-v2/errors.js";
+import { LlmClientError } from "../../src/la-protocol-v2/llm/client.js";
+
+const noop = () => {};
+const ENV = { LOCAL_AGENT_DLP_MODE: "enforce" };
+const uuid = () => crypto.randomUUID();
+const tick = (ms = 5) => new Promise((r) => setTimeout(r, ms));
+const until = async (cond, ms = 3000) => { const t0 = Date.now(); while (!cond()) { if (Date.now() - t0 > ms) throw new Error("until: timed out"); await tick(5); } };
+const MIB = 1024 * 1024;
+
+function fakeSession({ failWith = [] } = {}) {
+    const frames = [];
+    const failures = [...failWith];
+    return { frames, enqueue: async (type, payload, opts) => { if (failures.length) { const code = failures.shift(); if (code) throw new ProtocolError(code); } frames.push({ type, payload, workspaceId: opts?.workspaceId }); return { acked: Promise.resolve() }; },
+        of: (jobId, type) => frames.filter((f) => f.payload.jobId === jobId && (!type || f.type === type)) };
+}
+
+const params = (over = {}) => ({ jobId: uuid(), kind: "quality", repoRef: { provider: "github", org: "acme", repo: "app", branch: "main" },
+    policy: { operationMode: "assist", automationLevel: 2, ceiling: "assist" }, budget: { tokens: 50_000, seconds: 60 }, llm: { alias: "vh-claude-sonnet", keyRef: "ab".repeat(32) }, inputs: [], ...over });
+const ctxOf = (p, workspaceId = "ws-1") => ({ type: "job.assign", params: p, workspaceId });
+
+/** A runner whose jobs finish when the test says so. */
+function gatedRunner(over = {}) {
+    const calls = { started: [], cancelled: [], signals: new Map() };
+    const gates = new Map();
+    return {
+        calls, gates, name: "gated", needsLlm: false,
+        start(job, ctx) {
+            calls.started.push(job.jobId);
+            calls.signals.set(job.jobId, ctx.signal);
+            return new Promise((resolve, reject) => {
+                gates.set(job.jobId, { resolve, reject });
+                ctx.signal.addEventListener("abort", () => { if (!over.ignoreAbort) reject(new Error("aborted")); }, { once: true });
+            });
+        },
+        cancel(jobId) { calls.cancelled.push(jobId); },
+        ...over,
+    };
+}
+
+function mgr({ runner = gatedRunner(), env = {}, session = fakeSession(), resolveWorkspace = (id) => (id === "ws-1" || id === "ws-2" ? { root: `/w/${id}` } : null), memoryUsage, onResult, llm = null, readFile = null, now } = {}) {
+    const config = resolveJobsConfig({ LOCAL_AGENT_JOBS: "true", LOCAL_AGENT_JOBS_EVENT_MIN_MS: "50", LOCAL_AGENT_JOBS_CANCEL_GRACE_MS: "100", LOCAL_AGENT_JOBS_TERMINAL_RETRY_MS: "10", ...env }, noop);
+    const m = createJobManager({ session, tenantId: "3f2b8c1e-5a4d-4e7b-9c21-0a1b2c3d4e5f", resolveWorkspace, config, env: ENV, runner, llm, readFile, onResult, log: { warn: noop }, ...(memoryUsage ? { memoryUsage } : {}), ...(now ? { now } : {}) });
+    return { m, session, runner, config };
+}
+
+// ------------------------------------------------------------------------------------------------------ config
+
+test("config: off by default (unset, empty, unknown -> off, unknown warns); numbers are clamped; an unknown runner is ignored with a warning", () => {
+    for (const v of [undefined, "", "false", "no", "nope"]) {
+        const w = [];
+        assert.deepEqual(resolveJobsConfig({ LOCAL_AGENT_JOBS: v }, (m) => w.push(m)), { enabled: false });
+        assert.equal(w.length, v === "nope" ? 1 : 0);
+    }
+    const w = [];
+    const c = resolveJobsConfig({ LOCAL_AGENT_JOBS: "true", LOCAL_AGENT_JOBS_RUNNER: "evil", LOCAL_AGENT_JOBS_MAX_CONCURRENT: "500", LOCAL_AGENT_JOBS_MAX_TOKENS: "-3",
+        LOCAL_AGENT_JOBS_MAX_SECONDS: "abc", LOCAL_AGENT_JOBS_MAX_RSS_BYTES: "10", LOCAL_AGENT_JOBS_MAX_QUEUED: "9999" }, (m) => w.push(m));
+    assert.equal(c.runner, null); assert.equal(w.length, 1);
+    assert.equal(c.maxConcurrent, 1); assert.equal(c.maxTokens, 2_000_000); assert.equal(c.maxSeconds, 3600); assert.equal(c.maxRssBytes, 0); assert.equal(c.maxQueued, 4);
+    assert.equal(resolveJobsConfig({ LOCAL_AGENT_JOBS: "on", LOCAL_AGENT_JOBS_RUNNER: "smoke", LOCAL_AGENT_JOBS_MAX_RSS_BYTES: String(512 * MIB) }, noop).maxRssBytes, 512 * MIB);
+});
+
+test("runner interface: needs name, start() and cancel(); kinds only fix|implement|quality; setRunner refuses anything else", () => {
+    assert.equal(validateRunner(gatedRunner()), true);
+    for (const bad of [null, {}, { name: "x", start() {} }, { name: "X Y", start() {}, cancel() {} }, { name: "x", start() {}, cancel() {}, kinds: ["deploy"] }]) assert.equal(validateRunner(bad), false);
+    const { m } = mgr();
+    assert.throws(() => m.setRunner({ name: "x" }), /not a runner/);
+});
+
+// ------------------------------------------------------------------------------------------------------ admission
+
+test("admission: no runner / DLP not enforce / a kind the runner does not do -> rejected protocol_unsupported; unknown workspace -> unauthorized; nothing starts", () => {
+    const noRunner = mgr({ runner: null });
+    assert.deepEqual(noRunner.m.handleAssign(ctxOf(params())), { reject: "protocol_unsupported" });
+    const r = gatedRunner({ kinds: ["quality"] });
+    const a = mgr({ runner: r });
+    assert.deepEqual(a.m.handleAssign(ctxOf(params({ kind: "fix" }))), { reject: "protocol_unsupported" });
+    assert.deepEqual(a.m.handleAssign(ctxOf(params(), "ws-nope")), { reject: "unauthorized" });
+    assert.deepEqual(a.m.handleAssign(ctxOf(params(), "")), { reject: "unauthorized" });
+    const cfg = resolveJobsConfig({ LOCAL_AGENT_JOBS: "true" }, noop);
+    const env = { LOCAL_AGENT_DLP_MODE: "enforce" };
+    const live = createJobManager({ session: fakeSession(), tenantId: "t", resolveWorkspace: () => ({ root: "/w" }), config: cfg, env, runner: gatedRunner(), log: { warn: noop } });
+    assert.deepEqual(live.handleAssign(ctxOf(params())), { accept: true });
+    env.LOCAL_AGENT_DLP_MODE = "warn";   // read per request
+    assert.deepEqual(live.handleAssign(ctxOf(params())), { reject: "protocol_unsupported" });
+    assert.equal(r.calls.started.length, 0);
+    live.cancelAll();
+});
+
+test("admission: concurrency 1 + queue 1: the 3rd job is rate_limited, the 2nd is queued (event `queued`) and runs when the 1st ends", async () => {
+    const { m, session, runner } = mgr({ env: { LOCAL_AGENT_JOBS_MAX_CONCURRENT: "1", LOCAL_AGENT_JOBS_MAX_QUEUED: "1" } });
+    const [p1, p2, p3] = [params(), params(), params()];
+    assert.deepEqual(m.handleAssign(ctxOf(p1)), { accept: true });
+    assert.deepEqual(m.handleAssign(ctxOf(p2)), { accept: true });
+    assert.deepEqual(m.handleAssign(ctxOf(p3)), { reject: "rate_limited" });
+    await until(() => runner.calls.started.length === 1);
+    assert.deepEqual(runner.calls.started, [p1.jobId], "only one runs");
+    assert.equal(session.of(p2.jobId, "job.event")[0].payload.state, "queued");
+    assert.equal(m.running, 1);
+    runner.gates.get(p1.jobId).resolve({ outcome: "no_change" });
+    await until(() => runner.calls.started.length === 2);
+    assert.deepEqual(runner.calls.started, [p1.jobId, p2.jobId]);
+    runner.gates.get(p2.jobId).resolve({ outcome: "no_change" });
+    await until(() => session.of(p2.jobId, "job.result").length === 1);
+    assert.equal(m.activeCount, 0); assert.equal(m.reservedBytes, 0, "memory reservation released");
+});
+
+test("admission: memory reservation (inline bytes + per-job) above the limit and RSS above the brake -> rate_limited; released when the job ends", async () => {
+    const a = mgr({ env: { LOCAL_AGENT_JOBS_MAX_CONCURRENT: "8", LOCAL_AGENT_JOBS_MEM_PER_JOB_BYTES: String(100 * MIB), LOCAL_AGENT_JOBS_MAX_MEMORY_BYTES: String(256 * MIB) } });
+    const [p1, p2, p3] = [params(), params(), params()];
+    assert.deepEqual(a.m.handleAssign(ctxOf(p1)), { accept: true });
+    assert.deepEqual(a.m.handleAssign(ctxOf(p2)), { accept: true });
+    assert.deepEqual(a.m.handleAssign(ctxOf(p3)), { reject: "rate_limited" }, "3 x 100 MiB > 256 MiB");
+    assert.ok(a.m.reservedBytes >= 200 * MIB);
+    await until(() => a.runner.calls.started.length === 2);
+    a.runner.gates.get(p1.jobId).resolve({ outcome: "no_change" });
+    await until(() => a.m.activeCount === 1);
+    assert.deepEqual(a.m.handleAssign(ctxOf(p3)), { accept: true }, "room again");
+    a.m.cancelAll();
+
+    let rss = 100 * MIB;
+    const b = mgr({ env: { LOCAL_AGENT_JOBS_MAX_RSS_BYTES: String(500 * MIB) }, memoryUsage: () => rss });
+    assert.deepEqual(b.m.handleAssign(ctxOf(params())), { accept: true });
+    rss = 800 * MIB;
+    assert.deepEqual(b.m.handleAssign(ctxOf(params())), { reject: "rate_limited" });
+    b.m.cancelAll();
+});
+
+test("idempotent: the same jobId again (running, queued or recently finished) is acked accepted and NOT started twice", async () => {
+    const { m, runner, session } = mgr({ env: { LOCAL_AGENT_JOBS_MAX_QUEUED: "2" } });
+    const p = params();
+    assert.deepEqual(m.handleAssign(ctxOf(p)), { accept: true });
+    assert.deepEqual(m.handleAssign(ctxOf(p)), { accept: true });
+    await until(() => runner.calls.started.length === 1);
+    assert.deepEqual(m.handleAssign(ctxOf(p)), { accept: true });
+    runner.gates.get(p.jobId).resolve({ outcome: "no_change" });
+    await until(() => session.of(p.jobId, "job.result").length === 1);
+    assert.deepEqual(m.handleAssign(ctxOf(p)), { accept: true }, "finished: remembered");
+    await tick(30);
+    assert.equal(runner.calls.started.length, 1);
+    assert.equal(m.stats.duplicate, 3);
+});
+
+test("budget: the requested budget is clamped to the local ceilings (and the runner sees the clamped one)", async () => {
+    let seen;
+    const runner = gatedRunner({ start(job) { seen = job.budget; return new Promise(() => {}); } });
+    const { m } = mgr({ runner, env: { LOCAL_AGENT_JOBS_MAX_TOKENS: "1000", LOCAL_AGENT_JOBS_MAX_SECONDS: "30" } });
+    m.handleAssign(ctxOf(params({ budget: { tokens: 9_999_999, seconds: 86_400 } })));
+    await until(() => seen);
+    assert.deepEqual(seen, { tokens: 1000, seconds: 30 });
+    assert.throws(() => { seen.tokens = 1; }, TypeError, "frozen");
+    m.cancelAll();
+});
+
+// ------------------------------------------------------------------------------------------------------ outcomes and cancel
+
+test("outcomes: success -> job.result BEFORE the terminal job.event succeeded (+totals, errorCode none) (the control plane drops a result that follows the terminal event); failed/thrown -> failed with a code; the slot is freed", async () => {
+    const results = [];
+    const { m, session, runner } = mgr({ onResult: (r) => results.push(r) });
+    const ok = params(), bad = params(), boom = params();
+    for (const p of [ok, bad, boom]) m.handleAssign(ctxOf(p));
+    await until(() => runner.calls.started.length === 1);
+    runner.gates.get(ok.jobId).resolve({ outcome: "pr_opened", prUrl: "https://git.example/acme/app/pull/7", branch: "vh/fix-1", commitSha: "abcdef1", filesChangedCount: 2, diffSha256: "a".repeat(64), tests: { pass: 5, fail: 0, skip: 1 }, answer: "LOCAL ONLY" });
+    await until(() => session.of(ok.jobId, "job.result").length === 1 && session.of(ok.jobId, "job.event").length === 2);
+    const evs = session.frames.filter((f) => f.payload.jobId === ok.jobId);
+    assert.deepEqual(evs.map((f) => f.type), ["job.event", "job.result", "job.event"], "running, result, terminal event (result first)");
+    assert.equal(evs[2].payload.state, "succeeded"); assert.equal(evs[2].payload.errorCode, "none"); assert.equal(evs[2].payload.phase, "done");
+    assert.deepEqual(evs[1].payload, { jobId: ok.jobId, outcome: "pr_opened", prUrl: "https://git.example/acme/app/pull/7", branch: "vh/fix-1", commitSha: "abcdef1", filesChangedCount: 2, diffSha256: "a".repeat(64), tests: { pass: 5, fail: 0, skip: 1 } });
+    assert.ok(!JSON.stringify(session.frames).includes("LOCAL ONLY"), "the answer never goes on the wire");
+    assert.equal(results[0].answer, "LOCAL ONLY", "it goes to the local hook only");
+
+    await until(() => runner.calls.started.length === 2);
+    runner.gates.get(bad.jobId).resolve({ outcome: "failed", errorCode: "tests_failed" });
+    await until(() => session.of(bad.jobId, "job.result").length === 1);
+    assert.equal(session.of(bad.jobId, "job.event").at(-1).payload.errorCode, "tests_failed");
+    assert.equal(session.of(bad.jobId, "job.result")[0].payload.outcome, "failed");
+
+    await until(() => runner.calls.started.length === 3);
+    runner.gates.get(boom.jobId).reject(Object.assign(new Error("SECRET TEXT of an error"), { jobErrorCode: "build_failed" }));
+    await until(() => session.of(boom.jobId, "job.result").length === 1);
+    assert.equal(session.of(boom.jobId, "job.event").at(-1).payload.errorCode, "build_failed");
+    assert.ok(!JSON.stringify([session.frames, m.audit.tail(100)]).includes("SECRET TEXT"), "no error text anywhere");
+});
+
+test("error codes: LLM client codes map to job codes; anything else is `unknown` (the message is never read)", () => {
+    for (const [c, j] of [["budget_exceeded", "budget_exceeded"], ["timeout", "timeout"], ["cancelled", "cancelled"], ["dlp_blocked", "policy_denied"], ["dlp_denied", "policy_denied"], ["model_not_allowed", "policy_denied"], ["upstream_error", "llm_error"], ["no_key", "llm_error"], ["key_rejected", "llm_error"]]) {
+        assert.equal(jobErrorCodeOf(new LlmClientError(c)), j, c);
+    }
+    assert.equal(jobErrorCodeOf(new Error("x")), "unknown");
+    assert.equal(jobErrorCodeOf(Object.assign(new Error("x"), { jobErrorCode: "none" })), "unknown");
+    assert.equal(jobErrorCodeOf(Object.assign(new Error("x"), { jobErrorCode: "infra" })), "infra");
+});
+
+test("cancel: running job -> signal aborted, runner.cancel called, job.event cancelled then job.result cancelled; unknown / finished id = accepted no-op", async () => {
+    const { m, session, runner } = mgr();
+    const p = params();
+    m.handleAssign(ctxOf(p));
+    await until(() => runner.calls.started.length === 1);
+    assert.deepEqual(m.handleCancel({ params: { jobId: p.jobId, reason: "user" } }), { accept: true });
+    await until(() => session.of(p.jobId, "job.result").length === 1);
+    assert.equal(runner.calls.signals.get(p.jobId).aborted, true);
+    assert.deepEqual(runner.calls.cancelled, [p.jobId]);
+    assert.equal(session.of(p.jobId, "job.event").at(-1).payload.state, "cancelled");
+    assert.equal(session.of(p.jobId, "job.event").at(-1).payload.errorCode, "cancelled");
+    assert.equal(session.of(p.jobId, "job.result")[0].payload.outcome, "cancelled");
+    const n = session.frames.length;
+    assert.deepEqual(m.handleCancel({ params: { jobId: p.jobId, reason: "user" } }), { accept: true });
+    assert.deepEqual(m.handleCancel({ params: { jobId: uuid(), reason: "user" } }), { accept: true });
+    await tick(30);
+    assert.equal(session.frames.length, n, "no frame for an unknown or finished job (no oracle)");
+});
+
+test("cancel: a QUEUED job is cancelled at once (never started); a runner that ignores the abort is abandoned after the grace period", async () => {
+    const q = mgr({ env: { LOCAL_AGENT_JOBS_MAX_QUEUED: "2" } });
+    const [a, b] = [params(), params()];
+    q.m.handleAssign(ctxOf(a)); q.m.handleAssign(ctxOf(b));
+    await until(() => q.runner.calls.started.length === 1);
+    q.m.handleCancel({ params: { jobId: b.jobId, reason: "policy" } });
+    await until(() => q.session.of(b.jobId, "job.result").length === 1);
+    assert.equal(q.session.of(b.jobId, "job.result")[0].payload.outcome, "cancelled");
+    q.runner.gates.get(a.jobId).resolve({ outcome: "no_change" });
+    await tick(30);
+    assert.deepEqual(q.runner.calls.started, [a.jobId], "the cancelled one never ran");
+    q.m.cancelAll();
+
+    const stubborn = mgr({ runner: gatedRunner({ ignoreAbort: true }) });
+    const p = params();
+    stubborn.m.handleAssign(ctxOf(p));
+    await until(() => stubborn.runner.calls.started.length === 1);
+    stubborn.m.handleCancel({ params: { jobId: p.jobId, reason: "killswitch" } });
+    await until(() => stubborn.session.of(p.jobId, "job.result").length === 1, 2000);
+    assert.equal(stubborn.m.stats.abandoned, 1);
+    assert.equal(stubborn.m.running, 0, "the slot is free although the runner never returned");
+    stubborn.runner.gates.get(p.jobId).resolve({ outcome: "pr_opened" });   // a late result of an abandoned runner changes nothing
+    await tick(30);
+    assert.equal(stubborn.session.of(p.jobId, "job.result").length, 1);
+});
+
+test("deadline: the job's seconds budget aborts it -> failed timeout (job.event + job.result failed)", async () => {
+    const { m, session, runner } = mgr();
+    const p = params({ budget: { tokens: 1000, seconds: 1 } });
+    m.handleAssign(ctxOf(p));
+    await until(() => session.of(p.jobId, "job.result").length === 1, 4000);
+    assert.equal(session.of(p.jobId, "job.event").at(-1).payload.errorCode, "timeout");
+    assert.equal(session.of(p.jobId, "job.result")[0].payload.outcome, "failed");
+    assert.deepEqual(runner.calls.cancelled, [p.jobId]);
+});
+
+test("no runner needs the LLM but there is none / the key named by the job is not the held one -> failed llm_error (after the ack, a failure of the job, not of the channel)", async () => {
+    const needs = gatedRunner({ needsLlm: true });
+    const a = mgr({ runner: needs });
+    const p = params();
+    assert.deepEqual(a.m.handleAssign(ctxOf(p)), { accept: true });
+    await until(() => a.session.of(p.jobId, "job.result").length === 1);
+    assert.equal(a.session.of(p.jobId, "job.event").at(-1).payload.errorCode, "llm_error");
+    assert.equal(needs.calls.started.length, 0);
+    const holder = { held: true, matches: () => false };
+    const b = mgr({ runner: gatedRunner({ needsLlm: true }), llm: { client: {}, holder } });
+    const q = params();
+    b.m.handleAssign(ctxOf(q));
+    await until(() => b.session.of(q.jobId, "job.result").length === 1);
+    assert.equal(b.session.of(q.jobId, "job.event").at(-1).payload.errorCode, "llm_error");
+});
+
+// ------------------------------------------------------------------------------------------------------ events: coalescing and backpressure
+
+test("progress is coalesced: a runner that reports 1000 times a flood-free number of frames goes out, the LAST state wins", async () => {
+    const runner = { name: "chatty", needsLlm: false, cancel: noop, async start(job, ctx) { for (let i = 1; i <= 1000; i++) ctx.progress({ phase: "edit", iteration: i % 1000, filesChanged: i }); await tick(120); return { outcome: "no_change" }; } };
+    const { m, session } = mgr({ runner });
+    const p = params();
+    m.handleAssign(ctxOf(p));
+    await until(() => session.of(p.jobId, "job.result").length === 1);
+    const progress = session.of(p.jobId, "job.event").filter((f) => f.payload.state === "running");
+    assert.ok(progress.length <= 6, `coalesced, got ${progress.length}`);
+    assert.equal(progress.at(-1).payload.filesChanged, 1000, "the last state is the one that is sent");
+    assert.equal(session.of(p.jobId, "job.event").at(-1).payload.state, "succeeded");
+    assert.ok(m.events.stats.progressSent >= 1);
+});
+
+test("backpressure: a full send queue drops PROGRESS frames (counted) but the terminal event and result are retried until they get through", async () => {
+    // the first calls fail with rate_limited: running (dropped), then the result (retried), then the terminal event (retried)
+    const session = fakeSession({ failWith: ["rate_limited", "rate_limited", "rate_limited", null, "not_ready", "rate_limited"] });
+    const { m, runner } = mgr({ session, env: { LOCAL_AGENT_JOBS_TERMINAL_RETRIES: "20" } });
+    const p = params();
+    m.handleAssign(ctxOf(p));
+    await until(() => runner.calls.started.length === 1);
+    await tick(20);
+    runner.gates.get(p.jobId).resolve({ outcome: "no_change" });
+    await until(() => session.of(p.jobId, "job.result").length === 1 && m.events.stats.terminalSent === 1, 3000);
+    assert.equal(m.events.stats.progressDropped >= 1, true);
+    assert.equal(session.of(p.jobId, "job.event").at(-1).payload.state, "succeeded");
+    assert.equal(m.events.stats.terminalSent, 1);
+});
+
+test("backpressure: after terminalRetries the terminal frame is given up (audited with a code), the supervisor stays healthy", async () => {
+    const session = fakeSession({ failWith: Array(50).fill("rate_limited") });
+    const { m, runner } = mgr({ session, env: { LOCAL_AGENT_JOBS_TERMINAL_RETRIES: "3" } });
+    const p = params();
+    m.handleAssign(ctxOf(p));
+    await until(() => runner.calls.started.length === 1);
+    runner.gates.get(p.jobId).resolve({ outcome: "no_change" });
+    await until(() => m.events.stats.terminalGivenUp >= 1, 3000);
+    assert.ok(m.audit.tail(100).some((a) => a.event === "job_event_given_up" && a.code === "rate_limited"));
+    assert.equal(m.running, 0);
+    assert.equal(m.handleAssign(ctxOf(params())).accept, true);
+    m.cancelAll();
+});
+
+test("result fallback: a runner field the schema refuses (a malformed PR url) does not lose the result: the outcome alone is sent", async () => {
+    const session = fakeSession();
+    const real = session.enqueue;
+    let refused = 0;
+    session.enqueue = async (type, payload, opts) => {   // what the real session does when the closed schema refuses a field
+        if (type === "job.result" && payload.prUrl) { refused++; throw new ProtocolError("schema_violation"); }
+        return real(type, payload, opts);
+    };
+    const { m, runner } = mgr({ session });
+    const p = params();
+    m.handleAssign(ctxOf(p));
+    await until(() => runner.calls.started.length === 1);
+    runner.gates.get(p.jobId).resolve({ outcome: "pr_opened", prUrl: "http://not-https/x" });
+    await until(() => session.of(p.jobId, "job.result").length === 1);
+    assert.equal(refused, 1);
+    assert.deepEqual(session.of(p.jobId, "job.result")[0].payload, { jobId: p.jobId, outcome: "pr_opened" });
+    // the pure builders: unknown or invalid fields are dropped, never repaired
+    assert.deepEqual(resultPayload(p.jobId, "pr_opened", { prUrl: "https://x/y", extra: "ignored", tests: { pass: -1, fail: 0, skip: 0 } }), { jobId: p.jobId, outcome: "pr_opened", prUrl: "https://x/y" });
+    assert.deepEqual(resultPayload(p.jobId, "weird"), { jobId: p.jobId, outcome: "failed" });
+    assert.deepEqual(eventPayload({ jobId: p.jobId, state: "nonsense", phase: "x", iteration: 5000, filesRead: -1, tokensIn: 3, costUsd: 0.1234567891, errorCode: "boom" }), { jobId: p.jobId, state: "running", tokensIn: 3, costUsd: 0.123457 });
+});
+
+test("events carry only the whitelist: no field outside the contract can be put on a job.event / job.result by a runner", () => {
+    const e = eventPayload({ jobId: "j", state: "running", phase: "edit", iteration: 1, filesRead: 2, filesChanged: 3, tokensIn: 4, tokensOut: 5, costUsd: 0.5, durationMs: 6, errorCode: "none", prompt: "SECRET", path: "/etc/passwd", model: "m" });
+    assert.deepEqual(Object.keys(e).sort(), ["costUsd", "durationMs", "errorCode", "filesChanged", "filesRead", "iteration", "jobId", "phase", "state", "tokensIn", "tokensOut"]);
+    const r = resultPayload("j", "no_change", { answer: "SECRET", diff: "SECRET", stack: "SECRET" });
+    assert.deepEqual(r, { jobId: "j", outcome: "no_change" });
+});
+
+test("cancelAll (link close): every job aborted, runner.cancel called, memory released, nothing more is sent", async () => {
+    const { m, session, runner } = mgr({ env: { LOCAL_AGENT_JOBS_MAX_QUEUED: "2" } });
+    const ps = [params(), params(), params()];
+    for (const p of ps) m.handleAssign(ctxOf(p));
+    await until(() => runner.calls.started.length === 1);
+    const n = session.frames.length;
+    m.cancelAll();
+    assert.equal(m.activeCount, 0); assert.equal(m.reservedBytes, 0); assert.equal(m.running, 0);
+    assert.deepEqual(runner.calls.cancelled.sort(), ps.map((p) => p.jobId).sort());
+    assert.equal(runner.calls.signals.get(ps[0].jobId).aborted, true);
+    await tick(80);
+    assert.equal(session.frames.length, n);
+    assert.deepEqual(m.handleAssign(ctxOf(params())), { reject: "protocol_unsupported" }, "closed");
+});
+
+test("isolation: a job's context can only read through the job's own workspace (readFile gets the envelope's workspace, never one chosen by the runner)", async () => {
+    const asked = [];
+    const readFile = async (o) => { asked.push(o.workspaceId); return { ok: false, status: "not_found" }; };
+    const runner = { name: "r", needsLlm: false, cancel: noop, async start(job, ctx) { await ctx.readFile("x".repeat(43), { workspaceId: "ws-2" }); return { outcome: "no_change" }; } };
+    const { m, session } = mgr({ runner, readFile });
+    const p = params();
+    m.handleAssign(ctxOf(p, "ws-1"));
+    await until(() => session.of(p.jobId, "job.result").length === 1);
+    assert.deepEqual(asked, ["ws-1"]);
+});