agent-dealer 1.3.0 → 1.3.2

package/bundle/server/dist/repository/admission-settings.test.js

@@ -1,6 +1,7 @@
 // packages/server/src/repository/admission-settings.test.ts
 //
 // NOT-215: validation, persistence, and ceiling clamping of `maxActiveIssues`.
+// NOT-378: the configurable range widens to 1–5 with a five-process default ceiling.
 import { test, before, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import fs from "node:fs";
@@ -8,7 +9,9 @@ import os from "node:os";
 import path from "node:path";
 process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-admission-settings-"));
 const { migrate, getDb } = await import("../db/index.js");
-const { ADMISSION_MAX_ACTIVE_ISSUES_KEY, getMaxActiveIssues, setMaxActiveIssues, getEffectiveMaxActiveIssues, admissionLimitOptions, workerSpawnCeiling, } = await import("./admission-settings.js");
+const { ADMISSION_MAX_ACTIVE_ISSUES_KEY, DEFAULT_MAX_ACTIVE_ISSUES, MAX_ACTIVE_ISSUES_HARD_MAX, getMaxActiveIssues, setMaxActiveIssues, getEffectiveMaxActiveIssues, admissionLimitOptions, workerSpawnCeiling, } = await import("./admission-settings.js");
+const { coordinatorConfig } = await import("../coordinator/worker-loop.js");
+const { maxConcurrentSpawns } = await import("../runners/process-registry.js");
 before(() => migrate());
 const savedEnv = {
     MAX_COORDINATOR_CONCURRENCY: process.env.MAX_COORDINATOR_CONCURRENCY,
@@ -28,18 +31,35 @@ afterEach(() => {
             process.env[key] = value;
     }
 });
-test("default is 1 for fresh installations (no stored row)", () => {
+test("NOT-378: the default stays 1 while the hard maximum widens to 5", () => {
+    assert.equal(DEFAULT_MAX_ACTIVE_ISSUES, 1);
+    assert.equal(MAX_ACTIVE_ISSUES_HARD_MAX, 5);
     assert.equal(getMaxActiveIssues(), 1);
     assert.equal(getEffectiveMaxActiveIssues(), 1);
 });
 test("persisted value survives re-read (page reload / server restart read the same DB row)", () => {
-    assert.equal(setMaxActiveIssues(2), 2);
-    assert.equal(getMaxActiveIssues(), 2);
-    assert.equal(getEffectiveMaxActiveIssues(), 2);
+    assert.equal(setMaxActiveIssues(5), 5);
+    assert.equal(getMaxActiveIssues(), 5);
+    assert.equal(getEffectiveMaxActiveIssues(), 5);
     const row = getDb()
         .prepare("SELECT value_json FROM intake_settings WHERE key = ?")
         .get(ADMISSION_MAX_ACTIVE_ISSUES_KEY);
-    assert.equal(row.value_json, "2");
+    assert.equal(row.value_json, "5");
+});
+test("every integer 1–5 persists and reads back", () => {
+    for (const value of [1, 2, 3, 4, 5]) {
+        assert.equal(setMaxActiveIssues(value), value);
+        assert.equal(getMaxActiveIssues(), value);
+        assert.equal(getEffectiveMaxActiveIssues(), value);
+    }
+});
+test("an existing persisted value (e.g. 2) is unchanged after upgrade", () => {
+    getDb()
+        .prepare("INSERT INTO intake_settings (key, value_json) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value_json = excluded.value_json")
+        .run(ADMISSION_MAX_ACTIVE_ISSUES_KEY, "2");
+    assert.equal(getMaxActiveIssues(), 2);
+    assert.equal(getEffectiveMaxActiveIssues(), 2);
+    assert.deepEqual(admissionLimitOptions(), [1, 2, 3, 4, 5]);
 });
 test("corrupt or out-of-range stored values fall back to the default", () => {
     const upsert = getDb().prepare("INSERT INTO intake_settings (key, value_json) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value_json = excluded.value_json");
@@ -49,30 +69,66 @@ test("corrupt or out-of-range stored values fall back to the default", () => {
     assert.equal(getMaxActiveIssues(), 1);
     upsert.run(ADMISSION_MAX_ACTIVE_ISSUES_KEY, "0");
     assert.equal(getMaxActiveIssues(), 1);
+    upsert.run(ADMISSION_MAX_ACTIVE_ISSUES_KEY, "6");
+    assert.equal(getMaxActiveIssues(), 1);
 });
-test("validation rejects non-integers and values outside 1..2", () => {
-    for (const bad of [0, 3, 99, 1.5, NaN, "x", null, undefined, {}]) {
+test("validation rejects non-integers and values outside 1..5", () => {
+    for (const bad of [0, 6, 99, 1.5, NaN, "x", null, undefined, {}]) {
         assert.throws(() => setMaxActiveIssues(bad), /maxActiveIssues/, `rejects ${String(bad)}`);
     }
     assert.equal(getMaxActiveIssues(), 1, "a rejected write leaves the stored value alone");
 });
+test("range rejection names the exact 1–5 bounds", () => {
+    assert.throws(() => setMaxActiveIssues(0), /maxActiveIssues must be between 1 and 5/);
+    assert.throws(() => setMaxActiveIssues(6), /maxActiveIssues must be between 1 and 5/);
+    assert.throws(() => setMaxActiveIssues(1.5), /maxActiveIssues must be an integer/);
+});
 test("values above the worker/spawn ceiling are rejected, never silently stored", () => {
     process.env.MAX_COORDINATOR_CONCURRENCY = "1";
     assert.equal(workerSpawnCeiling(), 1);
     assert.deepEqual(admissionLimitOptions(), [1]);
-    assert.throws(() => setMaxActiveIssues(2), /ceiling/);
+    assert.throws(() => setMaxActiveIssues(2), /maxActiveIssues 2 exceeds the effective worker\/spawn ceiling of 1/);
     assert.equal(getMaxActiveIssues(), 1);
 });
-test("the ceiling is the lower of the coordinator and spawn bounds", () => {
+test("NOT-378: the default ceiling is 5 with options 1–5 and no overrides", () => {
+    assert.equal(workerSpawnCeiling(), 5);
+    assert.deepEqual(admissionLimitOptions(), [1, 2, 3, 4, 5]);
+});
+test("NOT-378: a lower coordinator bound clamps the ceiling and options to 3", () => {
+    process.env.MAX_COORDINATOR_CONCURRENCY = "3";
+    assert.equal(workerSpawnCeiling(), 3);
+    assert.deepEqual(admissionLimitOptions(), [1, 2, 3]);
+    assert.equal(setMaxActiveIssues(3), 3);
+    assert.throws(() => setMaxActiveIssues(4), /maxActiveIssues 4 exceeds the effective worker\/spawn ceiling of 3/);
+    assert.equal(getMaxActiveIssues(), 3, "a rejected write leaves the stored value alone");
+});
+test("NOT-378: a lower spawn bound clamps the ceiling and options to 2", () => {
+    process.env.MAX_CONCURRENT_RUNS = "2";
     assert.equal(workerSpawnCeiling(), 2);
     assert.deepEqual(admissionLimitOptions(), [1, 2]);
-    process.env.MAX_CONCURRENT_RUNS = "1";
-    assert.equal(workerSpawnCeiling(), 1);
-    assert.deepEqual(admissionLimitOptions(), [1]);
+    assert.equal(setMaxActiveIssues(2), 2);
+    assert.throws(() => setMaxActiveIssues(3), /maxActiveIssues 3 exceeds the effective worker\/spawn ceiling of 2/);
+    assert.equal(getMaxActiveIssues(), 2, "a rejected write leaves the stored value alone");
+});
+test("the ceiling is the lower of the coordinator and spawn bounds", () => {
+    assert.equal(workerSpawnCeiling(), 5);
+    assert.deepEqual(admissionLimitOptions(), [1, 2, 3, 4, 5]);
+    process.env.MAX_COORDINATOR_CONCURRENCY = "3";
+    process.env.MAX_CONCURRENT_RUNS = "2";
+    assert.equal(workerSpawnCeiling(), 2, "the minimum of the two bounds wins");
+    assert.deepEqual(admissionLimitOptions(), [1, 2]);
+    process.env.MAX_CONCURRENT_RUNS = "4";
+    assert.equal(workerSpawnCeiling(), 3);
+    assert.deepEqual(admissionLimitOptions(), [1, 2, 3]);
 });
 test("the effective limit clamps a persisted value when the ceiling drops below it", () => {
-    assert.equal(setMaxActiveIssues(2), 2);
+    assert.equal(setMaxActiveIssues(5), 5);
     process.env.MAX_CONCURRENT_RUNS = "1";
-    assert.equal(getMaxActiveIssues(), 2, "persisted setting is untouched");
+    assert.equal(getMaxActiveIssues(), 5, "persisted setting is untouched");
     assert.equal(getEffectiveMaxActiveIssues(), 1, "admission uses the clamped value");
 });
+test("NOT-378: authoritative runtime defaults agree on the five-process ceiling", () => {
+    assert.equal(workerSpawnCeiling(), 5);
+    assert.equal(coordinatorConfig.maxConcurrency, 5);
+    assert.equal(maxConcurrentSpawns(), 5);
+});

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

@@ -137,6 +137,7 @@ export function listIssues(status) {
 /** NOT-228: page-size bounds for the Issues list (matches the report default/max). */
 export const ISSUES_LIST_DEFAULT_LIMIT = 25;
 export const ISSUES_LIST_MAX_LIMIT = 100;
+export const DEFAULT_ISSUES_LIST_DIRECTION = "desc";
 /** Escape the LIKE metacharacters in a user query so `%`/`_` match literally. */
 function escapeLikePattern(raw) {
     return raw.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
@@ -146,6 +147,9 @@ function escapeLikePattern(raw) {
  * Ordering is `updated_at DESC, rowid DESC` so pages are repeatable when many
  * rows share a timestamp; the filter applies before pagination so `total` and
  * `totalPages` describe the full matching cohort.
+ * NOT-385: `direction: "asc"` reverses both to `updated_at ASC, rowid ASC` —
+ * the tie-breaker always follows the timestamp direction so equal-timestamp
+ * rows paginate without duplicates or skips in either direction.
  */
 export function queryIssues(query = {}) {
     const db = getDb();
@@ -183,8 +187,11 @@ export function queryIssues(query = {}) {
         .get(...params);
     const totalPages = total === 0 ? 0 : Math.ceil(total / limit);
     const offset = (page - 1) * limit;
+    // NOT-385: the direction is a ternary over literals, never interpolated —
+    // anything but an explicit "asc" orders newest-first.
+    const dir = query.direction === "asc" ? "ASC" : "DESC";
     const rows = db
-        .prepare(`SELECT * FROM issues ${where} ORDER BY updated_at DESC, rowid DESC LIMIT ? OFFSET ?`)
+        .prepare(`SELECT * FROM issues ${where} ORDER BY updated_at ${dir}, rowid ${dir} LIMIT ? OFFSET ?`)
         .all(...params, limit, offset);
     return { rows: rows.map(rowToIssue), page, limit, total, totalPages };
 }

package/bundle/server/dist/repository/issues.test.js

@@ -139,6 +139,40 @@ test("NOT-228: page/limit bounds clamp instead of erroring", () => {
     assert.equal(empty.total, 0);
     assert.equal(empty.totalPages, 0);
 });
+test("NOT-385: the default direction is newest-first by updated_at", () => {
+    const oldId = createIssue(makeInput("NOT385 default old")).id;
+    const newId = createIssue(makeInput("NOT385 default new")).id;
+    getDb().prepare("UPDATE issues SET updated_at = ? WHERE id = ?").run("2026-08-01T00:00:00.000Z", oldId);
+    getDb().prepare("UPDATE issues SET updated_at = ? WHERE id = ?").run("2026-09-01T00:00:00.000Z", newId);
+    for (const query of [{ search: "NOT385 default" }, { search: "NOT385 default", direction: "desc" }]) {
+        const res = queryIssues(query);
+        assert.deepEqual(res.rows.map((i) => i.id), [newId, oldId], `newest updated_at first (${JSON.stringify(query)})`);
+    }
+    // Anything but an explicit "asc" falls back to newest-first.
+    const fallback = queryIssues({ search: "NOT385 default", direction: "sideways" });
+    assert.deepEqual(fallback.rows.map((i) => i.id), [newId, oldId]);
+});
+test("NOT-385: ascending reverses to oldest-first with an ascending rowid tiebreaker", () => {
+    const stamp = "2026-09-01T00:00:00.000Z";
+    const ids = ["NOT385 tie one", "NOT385 tie two", "NOT385 tie three"].map((t) => createIssue(makeInput(t)).id);
+    for (const id of ids) {
+        getDb().prepare("UPDATE issues SET updated_at = ? WHERE id = ?").run(stamp, id);
+    }
+    const first = queryIssues({ search: "NOT385 tie", direction: "asc", limit: 2, page: 1 });
+    const second = queryIssues({ search: "NOT385 tie", direction: "asc", limit: 2, page: 2 });
+    assert.equal(first.total, 3);
+    assert.equal(first.totalPages, 2);
+    // Oldest rowid first: creation order was one, two, three.
+    assert.deepEqual(first.rows.map((i) => i.id), [ids[0], ids[1]]);
+    assert.deepEqual(second.rows.map((i) => i.id), [ids[2]]);
+    const again = queryIssues({ search: "NOT385 tie", direction: "asc", limit: 2, page: 1 });
+    assert.deepEqual(again.rows.map((i) => i.id), first.rows.map((i) => i.id), "repeatable");
+    assert.deepEqual(new Set([...first.rows, ...second.rows].map((i) => i.id)).size, 3, "pages neither duplicate nor skip rows");
+    // The reverse is the exact mirror of the default across the same cohort.
+    const descAll = queryIssues({ search: "NOT385 tie", limit: 10 });
+    const ascAll = queryIssues({ search: "NOT385 tie", direction: "asc", limit: 10 });
+    assert.deepEqual(ascAll.rows.map((i) => i.id), [...descAll.rows.map((i) => i.id)].reverse());
+});
 test("NOT-228: needsAttention returns only issues with an open human action", () => {
     const flagged = createIssue(makeInput("NOT228 flagged attention"));
     const quiet = createIssue(makeInput("NOT228 quiet no-action"));

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

@@ -588,6 +588,299 @@ test("NOT-363: a contract-validation failure on refreshed text leaves everything
     assert.ok(!listWorkflowEventsForIssue(id).some((e) => e.type === "issue.source_reloaded"));
     await app.close();
 });
+// NOT-422: product-scope pause contract adoption — a `needs_human` issue with an
+// active workflow and an open `product_scope_decision` accepts PATCH task edits
+// and Linear source reload while nothing runs and nothing is pending/leased.
+const { startWorkflow } = await import("../coordinator/commands.js");
+const { enqueueWorkItem, cancelWorkItem } = await import("../repository/work-items.js");
+const { getActiveWorkflowInstance } = await import("../repository/workflow-events.js");
+const { getHumanAction } = await import("../repository/human-actions.js");
+let scopeParkCounter = 0;
+async function parkLinearAtProductScope(app) {
+    // Unique external ids per park: several tests park more than one issue, and
+    // a repeated import of a live ticket is a 409, not a second row (NOT-141).
+    scopeParkCounter += 1;
+    const suffix = scopeParkCounter;
+    const res = await app.inject({
+        method: "POST",
+        url: "/api/issues",
+        payload: { ...LINEAR_ISSUE_PAYLOAD, externalId: `linear-uuid-scope-${suffix}` },
+    });
+    assert.equal(res.statusCode, 200, res.body);
+    const { id } = res.json();
+    assert.equal(startWorkflow(id).ok, true);
+    const dev = claimWorkItem("route-test", { leaseMs: 60_000 });
+    await applyCompletion(dev.id, dev.leaseToken, {
+        kind: "clean_handoff",
+        branch: "b",
+        headSha: "abc",
+        baseSha: "base",
+        prNumber: 1,
+        prUrl: "https://gh/pr/1",
+    });
+    const rev = claimWorkItem("route-test", { leaseMs: 60_000 });
+    await applyCompletion(rev.id, rev.leaseToken, {
+        kind: "verdict",
+        result: ReviewerResult.parse({
+            verdict: "escalated",
+            productScopeQuestion: "Should deleted users retain sessions?",
+            baseSha: "b",
+            headSha: "h",
+            acceptanceCriteriaAssessment: "ok",
+            evidenceAssessment: "ok",
+            findings: [],
+            risks: [],
+        }),
+    });
+    assert.equal(getIssue(id).status, "needs_human");
+    return id;
+}
+test("NOT-422: a product-scope pause accepts PATCH task edits and reports them pending for the next snapshot", async () => {
+    const app = await buildApp();
+    const id = await parkLinearAtProductScope(app);
+    const actionId = listHumanActionsForIssue(id).find((a) => a.actionType === "product_scope_decision").id;
+    const patchRes = await app.inject({
+        method: "PATCH",
+        url: `/api/issues/${id}`,
+        payload: { description: RELOADED_DESCRIPTION },
+    });
+    assert.equal(patchRes.statusCode, 200, patchRes.body);
+    const patched = patchRes.json();
+    assert.equal(patched.description, RELOADED_DESCRIPTION);
+    assert.deepStrictEqual(patched.executionContract, EXPECTED_RELOADED_CONTRACT);
+    // The scope action stays open and the frozen snapshot stays stale until Resume.
+    assert.equal(getHumanAction(actionId).status, "open");
+    assert.equal(getTaskSnapshot(getIssue(id)).description, CONTRACT_DESCRIPTION);
+    const detail = (await app.inject({ method: "GET", url: `/api/issues/${id}` })).json();
+    assert.ok(detail.pendingSnapshotChangedFields.includes("description"));
+    assert.ok(detail.pendingSnapshotChangedFields.includes("executionContract"));
+    await app.close();
+});
+test("NOT-422: a product-scope pause accepts Linear source reload and preserves the workflow", async () => {
+    resetLinearMock(linearNodeForTest(RELOADED_DESCRIPTION));
+    const app = await buildApp();
+    const id = await parkLinearAtProductScope(app);
+    const before = getIssue(id);
+    const instanceBefore = getActiveWorkflowInstance(id);
+    const actionId = listHumanActionsForIssue(id).find((a) => a.actionType === "product_scope_decision").id;
+    const res = await app.inject({ method: "POST", url: `/api/issues/${id}/reload-source` });
+    assert.equal(res.statusCode, 200, res.body);
+    const reloaded = res.json();
+    assert.equal(reloaded.title, "NOT-123: Refreshed title from Linear");
+    assert.equal(reloaded.description, RELOADED_DESCRIPTION);
+    assert.deepStrictEqual(reloaded.executionContract, EXPECTED_RELOADED_CONTRACT);
+    assert.ok(reloaded.acceptanceCriteria.includes("- [ ] Reloaded ticket compiles into the refreshed structured schema"));
+    assert.ok(!reloaded.acceptanceCriteria.includes("Operator-typed override"));
+    const after = getIssue(id);
+    assert.equal(after.status, "needs_human");
+    assert.equal(after.repo, before.repo);
+    assert.equal(after.baseBranch, before.baseBranch);
+    assert.equal(after.developerAgentId, before.developerAgentId);
+    assert.equal(after.reviewerAgentId, before.reviewerAgentId);
+    assert.equal(after.maxReviewRounds, before.maxReviewRounds);
+    assert.equal(after.maxInfraAttempts, before.maxInfraAttempts);
+    assert.equal(after.autoMerge, before.autoMerge);
+    assert.equal(after.currentRound, before.currentRound);
+    assert.equal(after.infraAttempts, before.infraAttempts);
+    assert.equal(after.branch, before.branch);
+    assert.equal(after.baseSha, before.baseSha);
+    assert.equal(after.headSha, before.headSha);
+    assert.equal(after.prNumber, before.prNumber);
+    assert.equal(after.prUrl, before.prUrl);
+    assert.equal(getActiveWorkflowInstance(id).id, instanceBefore.id);
+    assert.equal(getHumanAction(actionId).status, "open");
+    const reloadEvents = listWorkflowEventsForIssue(id).filter((e) => e.type === "issue.source_reloaded");
+    assert.equal(reloadEvents.length, 1);
+    assert.equal(reloadEvents[0].stage, "needs_human");
+    // Still stale until the explicit Resume re-freezes.
+    assert.equal(getTaskSnapshot(after).description, CONTRACT_DESCRIPTION);
+    await app.close();
+});
+test("NOT-422: PATCH at a scope pause fails closed on pending/leased work, running sessions, and other parks", async () => {
+    const app = await buildApp();
+    const patch = (id, payload) => app.inject({ method: "PATCH", url: `/api/issues/${id}`, payload });
+    // Pending work blocks the edit with no row or event change.
+    const pendingId = await parkLinearAtProductScope(app);
+    const pendingInstance = getActiveWorkflowInstance(pendingId);
+    const item = enqueueWorkItem({
+        issueId: pendingId,
+        workflowInstanceId: pendingInstance.id,
+        kind: "developer",
+        round: 1,
+        payload: {},
+        idempotencyKey: `${pendingInstance.id}:test:n422-route-pending`,
+    });
+    const beforePending = JSON.stringify(getIssue(pendingId));
+    const eventsPending = listWorkflowEventsForIssue(pendingId).length;
+    assert.equal((await patch(pendingId, { title: "Racing edit" })).statusCode, 409);
+    // Leased work blocks it too.
+    const leased = claimWorkItem("route-test", { leaseMs: 60_000 });
+    assert.equal(leased.id, item.id);
+    assert.equal((await patch(pendingId, { title: "Racing edit" })).statusCode, 409);
+    cancelWorkItem(item.id);
+    assert.equal(JSON.stringify(getIssue(pendingId)), beforePending);
+    assert.equal(listWorkflowEventsForIssue(pendingId).length, eventsPending);
+    // A running session blocks the edit.
+    const runningId = await parkLinearAtProductScope(app);
+    const session = createWorkerSession({
+        issueId: runningId,
+        role: "developer",
+        round: 1,
+        agentId: BUILTIN_AGENT_CLAUDE_ID,
+        runtime: "claude_code",
+    });
+    startSession(session.id);
+    const beforeRunning = JSON.stringify(getIssue(runningId));
+    const eventsRunning = listWorkflowEventsForIssue(runningId).length;
+    const runningRes = await patch(runningId, { title: "Racing session" });
+    assert.equal(runningRes.statusCode, 409);
+    assert.match(runningRes.json().error, /actively running session/);
+    assert.equal(JSON.stringify(getIssue(runningId)), beforeRunning);
+    assert.equal(listWorkflowEventsForIssue(runningId).length, eventsRunning);
+    // An agent swap at a scope pause is a 409, not a silent accept.
+    const swapId = await parkLinearAtProductScope(app);
+    const swapRes = await patch(swapId, { developerAgentId: BUILTIN_AGENT_CURSOR_ID });
+    assert.equal(swapRes.statusCode, 409);
+    assert.match(swapRes.json().error, /Only title, description and acceptanceCriteria/);
+    // A final_review pause is a different park — still 409 on an active workflow.
+    const { id: finalId } = await createLinearIssue(app);
+    assert.equal(startWorkflow(finalId).ok, true);
+    const finalDev = claimWorkItem("route-test", { leaseMs: 60_000 });
+    await applyCompletion(finalDev.id, finalDev.leaseToken, {
+        kind: "clean_handoff",
+        branch: "b",
+        headSha: "abc",
+        baseSha: "base",
+        prNumber: 1,
+        prUrl: "https://gh/pr/1",
+    });
+    const finalRev = claimWorkItem("route-test", { leaseMs: 60_000 });
+    await applyCompletion(finalRev.id, finalRev.leaseToken, {
+        kind: "verdict",
+        result: ReviewerResult.parse({
+            verdict: "approved",
+            baseSha: "b",
+            headSha: "h",
+            acceptanceCriteriaAssessment: "ok",
+            evidenceAssessment: "ok",
+            findings: [],
+            risks: [],
+        }),
+    });
+    assert.equal(getIssue(finalId).status, "final_review");
+    const beforeFinal = JSON.stringify(getIssue(finalId));
+    const eventsFinal = listWorkflowEventsForIssue(finalId).length;
+    assert.equal((await patch(finalId, { title: "Wrong park" })).statusCode, 409);
+    assert.equal(JSON.stringify(getIssue(finalId)), beforeFinal);
+    assert.equal(listWorkflowEventsForIssue(finalId).length, eventsFinal);
+    await app.close();
+});
+test("NOT-422: reload at a scope pause fails closed on pending/leased work, running sessions, and other parks", async () => {
+    resetLinearMock(linearNodeForTest(RELOADED_DESCRIPTION));
+    const app = await buildApp();
+    const reload = (id) => app.inject({ method: "POST", url: `/api/issues/${id}/reload-source` });
+    const pendingId = await parkLinearAtProductScope(app);
+    const pendingInstance = getActiveWorkflowInstance(pendingId);
+    const item = enqueueWorkItem({
+        issueId: pendingId,
+        workflowInstanceId: pendingInstance.id,
+        kind: "developer",
+        round: 1,
+        payload: {},
+        idempotencyKey: `${pendingInstance.id}:test:n422-route-reload-pending`,
+    });
+    const beforePending = JSON.stringify(getIssue(pendingId));
+    const eventsPending = listWorkflowEventsForIssue(pendingId).length;
+    assert.equal((await reload(pendingId)).statusCode, 409);
+    const leased = claimWorkItem("route-test", { leaseMs: 60_000 });
+    assert.equal(leased.id, item.id);
+    assert.equal((await reload(pendingId)).statusCode, 409);
+    cancelWorkItem(item.id);
+    assert.equal(JSON.stringify(getIssue(pendingId)), beforePending);
+    assert.equal(listWorkflowEventsForIssue(pendingId).length, eventsPending);
+    assert.ok(!listWorkflowEventsForIssue(pendingId).some((e) => e.type === "issue.source_reloaded"));
+    const runningId = await parkLinearAtProductScope(app);
+    const session = createWorkerSession({
+        issueId: runningId,
+        role: "developer",
+        round: 1,
+        agentId: BUILTIN_AGENT_CLAUDE_ID,
+        runtime: "claude_code",
+    });
+    startSession(session.id);
+    const beforeRunning = JSON.stringify(getIssue(runningId));
+    const runningRes = await reload(runningId);
+    assert.equal(runningRes.statusCode, 409);
+    assert.match(runningRes.json().error, /actively running session/);
+    assert.equal(JSON.stringify(getIssue(runningId)), beforeRunning);
+    // An attempts-exhausted park accepts PATCH but never a source reload.
+    const exhausted = (await app.inject({
+        method: "POST",
+        url: "/api/issues",
+        payload: {
+            ...LINEAR_ISSUE_PAYLOAD,
+            externalId: "linear-uuid-exhausted",
+            title: "NOT-123: exhausted",
+            maxReviewRounds: 1,
+        },
+    })).json();
+    assert.equal(startWorkflow(exhausted.id).ok, true);
+    const exhaustedDev = claimWorkItem("route-test", { leaseMs: 60_000 });
+    await applyCompletion(exhaustedDev.id, exhaustedDev.leaseToken, {
+        kind: "clean_handoff",
+        branch: "b",
+        headSha: "abc",
+        baseSha: "base",
+        prNumber: 1,
+        prUrl: "https://gh/pr/1",
+    });
+    const exhaustedRev = claimWorkItem("route-test", { leaseMs: 60_000 });
+    await applyCompletion(exhaustedRev.id, exhaustedRev.leaseToken, {
+        kind: "verdict",
+        result: ReviewerResult.parse({
+            verdict: "changes_requested",
+            baseSha: "b",
+            headSha: "h",
+            acceptanceCriteriaAssessment: "ok",
+            evidenceAssessment: "ok",
+            findings: [],
+            risks: [],
+        }),
+    });
+    assert.ok(listHumanActionsForIssue(exhausted.id).some((a) => a.actionType === "attempts_exhausted" && a.status === "open"));
+    const beforeExhausted = JSON.stringify(getIssue(exhausted.id));
+    const eventsExhausted = listWorkflowEventsForIssue(exhausted.id).length;
+    assert.equal((await reload(exhausted.id)).statusCode, 409);
+    assert.equal(JSON.stringify(getIssue(exhausted.id)), beforeExhausted);
+    assert.equal(listWorkflowEventsForIssue(exhausted.id).length, eventsExhausted);
+    await app.close();
+});
+test("NOT-422: a malformed amended contract at a scope pause is a 400 that changes nothing", async () => {
+    resetLinearMock(linearNodeForTest(CONTRACT_DESCRIPTION.replace("feature", "teleport")));
+    const app = await buildApp();
+    const patchId = await parkLinearAtProductScope(app);
+    const beforePatch = JSON.stringify(getIssue(patchId));
+    const eventsPatch = listWorkflowEventsForIssue(patchId).length;
+    const badPatch = await app.inject({
+        method: "PATCH",
+        url: `/api/issues/${patchId}`,
+        payload: { description: CONTRACT_DESCRIPTION.replace("feature", "teleport") },
+    });
+    assert.equal(badPatch.statusCode, 400, badPatch.body);
+    assert.match(badPatch.json().error, /unknown execution mode/);
+    assert.equal(JSON.stringify(getIssue(patchId)), beforePatch);
+    assert.equal(listWorkflowEventsForIssue(patchId).length, eventsPatch);
+    const reloadId = await parkLinearAtProductScope(app);
+    const beforeReload = JSON.stringify(getIssue(reloadId));
+    const eventsReload = listWorkflowEventsForIssue(reloadId).length;
+    const badReload = await app.inject({ method: "POST", url: `/api/issues/${reloadId}/reload-source` });
+    assert.equal(badReload.statusCode, 400, badReload.body);
+    assert.match(badReload.json().error, /unknown execution mode/);
+    assert.equal(JSON.stringify(getIssue(reloadId)), beforeReload);
+    assert.equal(listWorkflowEventsForIssue(reloadId).length, eventsReload);
+    assert.ok(!listWorkflowEventsForIssue(reloadId).some((e) => e.type === "issue.source_reloaded"));
+    await app.close();
+});
 test("NOT-363: the frozen snapshot after reload contains exactly the refreshed text", async () => {
     resetLinearMock(linearNodeForTest(RELOADED_DESCRIPTION));
     const app = await buildApp();