agent-dealer 1.3.1 → 1.3.2

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();

package/bundle/server/dist/routes/issues-source-attachments.test.js

@@ -1,6 +1,7 @@
 // NOT-364: atomic Linear attachment import and reload reconciliation.
 import { test, before, after, beforeEach } from "node:test";
 import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
@@ -445,3 +446,279 @@ test("failed reload preserves the old task text and attachment snapshot", async
     assert.equal(createHash("sha256").update(fs.readFileSync(afterRows[0].blobPath)).digest("hex"), beforeBlobHash, "old blob bytes intact");
     await app.close();
 });
+// NOT-422: parked scope reload — the same atomic reconciliation as the
+// pre-execution path, preserving the active workflow and the open action.
+const PARKED_CONTRACT_V1 = [
+    "Ship the friend-path run command.",
+    "",
+    "## Builder execution mode",
+    "feature",
+    "",
+    "## Non-goals",
+    "- Rewriting the installer",
+    "",
+    "## Exit predicate",
+    "The friend-path run command works on a clean machine with operator proof.",
+    "",
+    "## One-PR stopping point",
+    "Stop after the run command lands with its regression test.",
+    "",
+    "## Acceptance criteria",
+    "- [ ] Friend-path run works",
+    "  Evidence: run fixtures | run the tests | green",
+    "- [ ] [operator] Clean-machine proof attached",
+    "  Evidence: operator run | paste the output | reviewed",
+    "",
+].join("\n");
+const PARKED_CONTRACT_V2 = [
+    "Ship the friend-path run command.",
+    "",
+    "## Builder execution mode",
+    "feature",
+    "",
+    "## Non-goals",
+    "- Rewriting the installer",
+    "",
+    "## Exit predicate",
+    "The friend-path run command works with simulator proof; clean-machine proof moved out.",
+    "",
+    "## One-PR stopping point",
+    "Stop after the run command lands with its regression test.",
+    "",
+    "## Acceptance criteria",
+    "- [ ] Friend-path run works",
+    "  Evidence: run fixtures | run the tests | green",
+    "- [ ] Simulator proof attached",
+    "  Evidence: simulator run | paste the output | reviewed",
+    "",
+].join("\n");
+function parkedNodeWith(description, attachments) {
+    return { ...linearNodeWith(attachments), description };
+}
+let scopeAttachCounter = 0;
+async function parkScopeWithAttachments(app) {
+    const { startWorkflow, applyCompletion } = await import("../coordinator/commands.js");
+    const { claimWorkItem } = await import("../repository/work-items.js");
+    const { ReviewerResult } = await import("../coordinator/reviewer-result.js");
+    const { getIssue } = await import("../repository/issues.js");
+    scopeAttachCounter += 1;
+    const created = (await (await app.inject({
+        method: "POST",
+        url: "/api/issues",
+        payload: {
+            ...BASE_LINEAR,
+            externalId: `linear-uuid-scope-att-${scopeAttachCounter}`,
+            description: PARKED_CONTRACT_V1,
+            linearAttachments: [FILE_ATT, LINK_ATT],
+        },
+    })).json());
+    assert.equal(startWorkflow(created.id).ok, true);
+    const dev = claimWorkItem("scope-att-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("scope-att-test", { leaseMs: 60_000 });
+    await applyCompletion(rev.id, rev.leaseToken, {
+        kind: "verdict",
+        result: ReviewerResult.parse({
+            verdict: "escalated",
+            productScopeQuestion: "Is clean-machine proof still required?",
+            baseSha: "b",
+            headSha: "h",
+            acceptanceCriteriaAssessment: "ok",
+            evidenceAssessment: "ok",
+            findings: [],
+            risks: [],
+        }),
+    });
+    assert.equal(getIssue(created.id).status, "needs_human");
+    return created.id;
+}
+test("NOT-422: parked scope reload recompiles the contract, reconciles attachments, and preserves the workflow", async () => {
+    downloadBytes.set(FILE_URL, TARBALL_V1);
+    const app = await buildApp();
+    const id = await parkScopeWithAttachments(app);
+    const { getIssue } = await import("../repository/issues.js");
+    const { getActiveWorkflowInstance, listWorkflowEventsForIssue } = await import("../repository/workflow-events.js");
+    const { getHumanAction, listHumanActionsForIssue } = await import("../repository/human-actions.js");
+    const { listWorkerSessionsForIssue } = await import("../repository/worker-sessions.js");
+    const { getTaskSnapshot } = await import("../coordinator/commands.js");
+    const before = getIssue(id);
+    const instanceBefore = getActiveWorkflowInstance(id);
+    const actionBefore = listHumanActionsForIssue(id).find((a) => a.actionType === "product_scope_decision");
+    const sessionsBefore = listWorkerSessionsForIssue(id);
+    const frozenBefore = getTaskSnapshot(before);
+    const oldBlob = listSourceAttachments(id).find((r) => r.kind === "file").blobPath;
+    assert.ok(fs.existsSync(oldBlob));
+    // Linear now: amended contract (the [operator] criterion is gone), the same
+    // file id with new bytes, a brand-new file, and the link removed.
+    const FILE_B_URL = "https://uploads.linear.app/abc/b.bin";
+    const TARBALL_B = Buffer.from("brand-new-bytes");
+    downloadBytes.set(FILE_URL, TARBALL_V2);
+    downloadBytes.set(FILE_B_URL, TARBALL_B);
+    linearNode = parkedNodeWith(PARKED_CONTRACT_V2, [
+        { id: "att-file-1", title: "repro.tar.gz", url: FILE_URL },
+        { id: "att-file-3", title: "b.bin", url: FILE_B_URL },
+    ]);
+    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-1: Reloaded title");
+    assert.equal(reloaded.description, PARKED_CONTRACT_V2);
+    assert.equal(reloaded.executionContract.exitPredicate, "The friend-path run command works with simulator proof; clean-machine proof moved out.");
+    assert.ok(!reloaded.acceptanceCriteria.includes("[operator] Clean-machine proof attached"));
+    assert.ok(reloaded.acceptanceCriteria.includes("Simulator proof attached"));
+    // Attachments reconciled atomically: changed bytes land, the new file
+    // appears, and the removed link disappears. The replaced blob is retained —
+    // the frozen snapshot still references it until Resume re-freezes.
+    const rows = listSourceAttachments(id);
+    assert.deepEqual(rows.map((r) => r.linearAttachmentId).sort(), ["att-file-1", "att-file-3"]);
+    const changed = rows.find((r) => r.linearAttachmentId === "att-file-1");
+    assert.equal(changed.sha256, createHash("sha256").update(TARBALL_V2).digest("hex"));
+    assert.deepEqual(fs.readFileSync(changed.blobPath), TARBALL_V2);
+    assert.ok(fs.existsSync(oldBlob), "blob still referenced by the frozen snapshot is retained");
+    // Everything else is preserved: repository/configuration, workflow
+    // instance, PR/head/branch, rounds, counters, sessions, and the open action.
+    const after = getIssue(id);
+    const preserved = (issue) => ({
+        repo: issue.repo,
+        baseBranch: issue.baseBranch,
+        developerAgentId: issue.developerAgentId,
+        reviewerAgentId: issue.reviewerAgentId,
+        maxReviewRounds: issue.maxReviewRounds,
+        maxInfraAttempts: issue.maxInfraAttempts,
+        maxCiAttempts: issue.maxCiAttempts,
+        autoMerge: issue.autoMerge,
+        status: issue.status,
+        currentRound: issue.currentRound,
+        infraAttempts: issue.infraAttempts,
+        ciAttempts: issue.ciAttempts,
+        branch: issue.branch,
+        baseSha: issue.baseSha,
+        headSha: issue.headSha,
+        prNumber: issue.prNumber,
+        prUrl: issue.prUrl,
+        source: issue.source,
+        externalId: issue.externalId,
+        externalLabel: issue.externalLabel,
+        externalUrl: issue.externalUrl,
+    });
+    assert.deepEqual(preserved(after), preserved(before));
+    assert.equal(getActiveWorkflowInstance(id).id, instanceBefore.id);
+    assert.deepEqual(getHumanAction(actionBefore.id), { ...actionBefore });
+    assert.deepEqual(listWorkerSessionsForIssue(id), sessionsBefore);
+    assert.equal(listWorkflowEventsForIssue(id).filter((e) => e.type === "issue.source_reloaded").length, 1);
+    // The frozen snapshot still carries the old text AND the old manifest until Resume.
+    const frozenAfter = getTaskSnapshot(after);
+    assert.equal(frozenAfter.description, PARKED_CONTRACT_V1);
+    assert.ok(frozenAfter.acceptanceCriteria.includes("[operator] Clean-machine proof attached"));
+    assert.deepEqual(frozenAfter.sourceAttachments, frozenBefore.sourceAttachments);
+    assert.ok(frozenAfter.sourceAttachments.some((a) => a.linearAttachmentId === "att-link-1"));
+    await app.close();
+});
+test("NOT-422: attachment-only parked reload shows sourceAttachments pending and Resume re-freezes the manifest", async () => {
+    downloadBytes.set(FILE_URL, TARBALL_V1);
+    const app = await buildApp();
+    const id = await parkScopeWithAttachments(app);
+    const { getIssue } = await import("../repository/issues.js");
+    const { listWorkflowEventsForIssue } = await import("../repository/workflow-events.js");
+    const { listHumanActionsForIssue } = await import("../repository/human-actions.js");
+    const { getTaskSnapshot, resolveHumanActionAndAdvance, TASK_SNAPSHOT_ARTIFACT_KIND } = await import("../coordinator/commands.js");
+    const { listArtifactsForIssue } = await import("../repository/artifacts-for-issue.js");
+    const { materializeSourceAttachments } = await import("../coordinator/source-attachments.js");
+    const oldBlob = listSourceAttachments(id).find((r) => r.kind === "file").blobPath;
+    const snapshotsBefore = listArtifactsForIssue(id).filter((a) => a.kind === TASK_SNAPSHOT_ARTIFACT_KIND).length;
+    assert.equal(snapshotsBefore, 1);
+    // Linear changed only the inputs: identical contract text (and the same
+    // derived title), new bytes for the file, the link removed.
+    downloadBytes.set(FILE_URL, TARBALL_V2);
+    linearNode = {
+        ...parkedNodeWith(PARKED_CONTRACT_V1, [{ id: "att-file-1", title: "repro.tar.gz", url: FILE_URL }]),
+        title: "import me",
+    };
+    const res = await app.inject({ method: "POST", url: `/api/issues/${id}/reload-source` });
+    assert.equal(res.statusCode, 200, res.body);
+    // Text byte-identical, rows swapped, the replaced blob retained for the
+    // frozen snapshot that still references it.
+    const parked = getIssue(id);
+    assert.equal(parked.title, BASE_LINEAR.title);
+    assert.equal(parked.description, PARKED_CONTRACT_V1);
+    assert.ok(parked.acceptanceCriteria.includes("[operator] Clean-machine proof attached"));
+    assert.deepEqual(listSourceAttachments(id).map((r) => r.linearAttachmentId), ["att-file-1"]);
+    assert.ok(fs.existsSync(oldBlob), "replaced blob retained while the frozen snapshot references it");
+    assert.ok(getTaskSnapshot(parked).sourceAttachments.some((a) => a.linearAttachmentId === "att-link-1"));
+    // Issue Detail reads the amended inputs as pending for the next snapshot —
+    // and only the manifest is pending.
+    const detail = (await app.inject({ method: "GET", url: `/api/issues/${id}` })).json();
+    assert.deepEqual(detail.pendingSnapshotChangedFields, ["sourceAttachments"]);
+    // Resume re-freezes exactly one new snapshot carrying the amended manifest.
+    const action = listHumanActionsForIssue(id).find((a) => a.actionType === "product_scope_decision");
+    const resolved = resolveHumanActionAndAdvance(action.id, "operator", "resume");
+    assert.equal(resolved.ok, true);
+    const snapshots = listArtifactsForIssue(id).filter((a) => a.kind === TASK_SNAPSHOT_ARTIFACT_KIND);
+    assert.equal(snapshots.length, snapshotsBefore + 1);
+    const events = listWorkflowEventsForIssue(id);
+    const refreshed = events.filter((e) => e.type === "task_snapshot.refreshed");
+    assert.equal(refreshed.length, 1);
+    assert.deepEqual(JSON.parse(refreshed[0].payloadJson).changedFields, ["sourceAttachments"]);
+    const types = events.map((e) => e.type);
+    assert.ok(types.indexOf("task_snapshot.refreshed") < types.lastIndexOf("repair.started"));
+    const snap = getTaskSnapshot(getIssue(id));
+    assert.equal(snap.sourceAttachments.length, 1);
+    assert.equal(snap.sourceAttachments[0].sha256, createHash("sha256").update(TARBALL_V2).digest("hex"));
+    // The next round materializes the amended bytes — never "stored bytes are missing".
+    const worktree = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-scope-att-only-"));
+    execFileSync("git", ["init", "-q"], { cwd: worktree });
+    const materialized = materializeSourceAttachments(worktree, snap.sourceAttachments);
+    assert.equal(materialized.length, 1);
+    assert.deepEqual(fs.readFileSync(path.join(worktree, materialized[0].relativePath)), TARBALL_V2);
+    await app.close();
+});
+test("NOT-422: failed parked reloads preserve prior text, attachments, workflow, and the open action", async () => {
+    const { getIssue } = await import("../repository/issues.js");
+    const { getActiveWorkflowInstance, listWorkflowEventsForIssue } = await import("../repository/workflow-events.js");
+    const { getHumanAction, listHumanActionsForIssue } = await import("../repository/human-actions.js");
+    async function expectIntact(id, label) {
+        const issue = getIssue(id);
+        assert.equal(issue.title, BASE_LINEAR.title, `${label}: title intact`);
+        assert.equal(issue.description, PARKED_CONTRACT_V1, `${label}: description intact`);
+        assert.ok(issue.acceptanceCriteria.includes("[operator] Clean-machine proof attached"), `${label}: criteria intact`);
+        const rows = listSourceAttachments(id);
+        assert.deepEqual(rows.map((r) => r.linearAttachmentId).sort(), ["att-file-1", "att-link-1"], `${label}: attachment rows intact`);
+        const file = rows.find((r) => r.kind === "file");
+        assert.deepEqual(fs.readFileSync(file.blobPath), TARBALL_V1, `${label}: blob bytes intact`);
+        const action = listHumanActionsForIssue(id).find((a) => a.actionType === "product_scope_decision");
+        assert.equal(getHumanAction(action.id).status, "open", `${label}: scope action still open`);
+        assert.ok(getActiveWorkflowInstance(id), `${label}: workflow still active`);
+        assert.equal(issue.status, "needs_human", `${label}: still parked`);
+        assert.ok(!listWorkflowEventsForIssue(id).some((e) => e.type === "issue.source_reloaded"), `${label}: no reload event`);
+    }
+    // A new file whose download fails: 502, prior snapshot untouched.
+    downloadBytes.set(FILE_URL, TARBALL_V1);
+    const app = await buildApp();
+    const failedId = await parkScopeWithAttachments(app);
+    const BAD_URL = "https://uploads.linear.app/abc/missing.bin";
+    downloadBytes.set(BAD_URL, "http500");
+    linearNode = parkedNodeWith(PARKED_CONTRACT_V2, [
+        { id: "att-file-1", title: "repro.tar.gz", url: FILE_URL },
+        { id: "att-file-9", title: "missing.bin", url: BAD_URL },
+    ]);
+    const failed = await app.inject({ method: "POST", url: `/api/issues/${failedId}/reload-source` });
+    assert.equal(failed.statusCode, 502, failed.body);
+    await expectIntact(failedId, "download failure");
+    // A malformed amended contract: actionable 400, prior snapshot untouched.
+    const badId = await parkScopeWithAttachments(app);
+    const malformed = PARKED_CONTRACT_V2.replace("feature", "teleport");
+    downloadBytes.set(FILE_URL, TARBALL_V1);
+    linearNode = parkedNodeWith(malformed, [{ id: "att-file-1", title: "repro.tar.gz", url: FILE_URL }]);
+    const bad = await app.inject({ method: "POST", url: `/api/issues/${badId}/reload-source` });
+    assert.equal(bad.statusCode, 400, bad.body);
+    assert.match(bad.json().error, /unknown execution mode/);
+    await expectIntact(badId, "contract failure");
+    await app.close();
+});