agent-dealer 1.2.13 → 1.2.15

package/bundle/server/dist/coordinator/linear-merge-verify.test.js

@@ -0,0 +1,376 @@
+// NOT-362 acceptance: after Dealer merges a PR for a `source = linear` issue,
+// the coordinator re-reads the Linear issue and either confirms it advanced,
+// advances it once via the conditional fallback, or raises the one human action.
+import { test, before, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-not362-"));
+process.env.LINEAR_API_KEY = "test-key";
+const { migrate, getDb } = await import("../db/index.js");
+const { BUILTIN_AGENT_CLAUDE_ID, BUILTIN_AGENT_CURSOR_ID } = await import("@agent-dealer/shared");
+const { createIssue, getIssue } = await import("../repository/issues.js");
+const { listArtifactsForIssueByKind } = await import("../repository/artifacts-for-issue.js");
+const { listHumanActionsForIssue } = await import("../repository/human-actions.js");
+const { claimWorkItem } = await import("../repository/work-items.js");
+const { startWorkflow, applyCompletion } = await import("./commands.js");
+const { ReviewerResult } = await import("./reviewer-result.js");
+const { setMergePrForTests, clearFinalizeInflightForTests } = await import("./auto-merge.js");
+const { clearWorkflowStateCacheForTests } = await import("../adapters/linear-sync.js");
+const { verifyLinearPostMerge, setPostMergeDelaysForTests, LINEAR_MERGE_VERIFY_ARTIFACT_KIND, linearMergeStaleRequestId, drainLinearPostMergeForTests, resolveLinearMergeStaleAction, isLinearMergeStaleAction, } = await import("./linear-merge-verify.js");
+/** Real local checkout so resolveAutoMergeCwd accepts the default legacy repo. */
+let fixtureRepo = "";
+function initFixtureRepo() {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-not362-repo-"));
+    execFileSync("git", ["init", "-b", "main"], { cwd: dir });
+    execFileSync("git", ["config", "user.email", "test@example.com"], { cwd: dir });
+    execFileSync("git", ["config", "user.name", "Test"], { cwd: dir });
+    fs.writeFileSync(path.join(dir, "README.md"), "hi\n");
+    execFileSync("git", ["add", "."], { cwd: dir });
+    execFileSync("git", ["commit", "-m", "init"], { cwd: dir });
+    return dir;
+}
+before(() => {
+    migrate();
+    fixtureRepo = initFixtureRepo();
+    setPostMergeDelaysForTests([0, 0]);
+});
+beforeEach(() => {
+    getDb().exec(`
+    DELETE FROM work_items;
+    DELETE FROM human_actions;
+    DELETE FROM workflow_events;
+    DELETE FROM findings;
+    DELETE FROM review_publications;
+    DELETE FROM worker_sessions;
+    DELETE FROM artifacts;
+    DELETE FROM usage_events;
+    DELETE FROM workflow_instances;
+    DELETE FROM issues;
+  `);
+    clearFinalizeInflightForTests();
+    clearWorkflowStateCacheForTests();
+    setMergePrForTests(async () => ({ ok: true }));
+});
+const realFetch = globalThis.fetch;
+afterEach(() => {
+    setMergePrForTests(null);
+    clearFinalizeInflightForTests();
+    globalThis.fetch = realFetch;
+});
+const PR_URL = "https://github.com/o/r/pull/42";
+function newLinearIssue() {
+    return createIssue({
+        title: "NOT-362: linear work",
+        description: "d",
+        acceptanceCriteria: "It works",
+        repo: fixtureRepo,
+        developerAgentId: BUILTIN_AGENT_CLAUDE_ID,
+        reviewerAgentId: BUILTIN_AGENT_CURSOR_ID,
+        baseBranch: "main",
+        maxReviewRounds: 3,
+        maxInfraAttempts: 3,
+        source: "linear",
+        externalId: "lin-uuid-1",
+        externalLabel: "NOT-362",
+        externalUrl: "https://linear.app/not-so-fat/issue/NOT-362/work",
+        autoMerge: true,
+    }).id;
+}
+const okReview = ReviewerResult.parse({
+    verdict: "approved",
+    baseSha: "b",
+    headSha: "h",
+    acceptanceCriteriaAssessment: "ok",
+    evidenceAssessment: "ok",
+    findings: [],
+    risks: [],
+});
+/** Drive the full merged transition: developer handoff + reviewer approve → merge → done. */
+async function mergeThroughReview(issueId) {
+    startWorkflow(issueId);
+    const handoff = claimWorkItem(`test-${issueId}`, { leaseMs: 60_000 });
+    assert.ok(handoff && handoff.issueId === issueId);
+    await applyCompletion(handoff.id, handoff.leaseToken, {
+        kind: "clean_handoff",
+        branch: "issue-1",
+        headSha: "abc123",
+        baseSha: "base1",
+        prNumber: 42,
+        prUrl: PR_URL,
+    });
+    const review = claimWorkItem(`test-${issueId}-r`, { leaseMs: 60_000 });
+    assert.ok(review && review.issueId === issueId);
+    const result = await applyCompletion(review.id, review.leaseToken, { kind: "verdict", result: okReview });
+    // The merged transition triggers the Linear post-merge check fire-and-forget
+    // (finalizeAutoMerge must not hold the merge caller for the retry window) —
+    // await it here so assertions below do not race it.
+    await drainLinearPostMergeForTests();
+    return result;
+}
+function stubLinear(state) {
+    globalThis.fetch = (async (_url, init) => {
+        const body = JSON.parse(String(init?.body ?? "{}"));
+        const query = body.query ?? "";
+        if (query.includes("PostMergeState")) {
+            state.calls.reads += 1;
+            return {
+                ok: true,
+                status: 200,
+                headers: new Headers(),
+                text: async () => JSON.stringify({ data: { issue: state.linearIssue } }),
+            };
+        }
+        if (query.includes("TeamStates")) {
+            return {
+                ok: true,
+                status: 200,
+                headers: new Headers(),
+                text: async () => JSON.stringify({
+                    data: {
+                        team: {
+                            states: {
+                                nodes: state.noCompletedState
+                                    ? [{ id: "s-todo", name: "Todo" }]
+                                    : [{ id: "s-done", name: "Done" }],
+                            },
+                        },
+                    },
+                }),
+            };
+        }
+        if (query.includes("commentCreate")) {
+            state.calls.comments += 1;
+            return {
+                ok: true,
+                status: 200,
+                headers: new Headers(),
+                text: async () => JSON.stringify({ data: { commentCreate: { success: true } } }),
+            };
+        }
+        if (query.includes("issueUpdate")) {
+            state.calls.stateWrites += 1;
+            if (state.failStateWriteWith)
+                throw new Error(state.failStateWriteWith);
+            return {
+                ok: true,
+                status: 200,
+                headers: new Headers(),
+                text: async () => JSON.stringify({ data: { issueUpdate: { success: true } } }),
+            };
+        }
+        throw new Error(`unexpected Linear query: ${query.slice(0, 80)}`);
+    });
+}
+function freshStub(linearIssue) {
+    return { linearIssue, failStateWriteWith: null, noCompletedState: false, calls: { reads: 0, comments: 0, stateWrites: 0 } };
+}
+const startedIssue = () => ({
+    identifier: "NOT-362",
+    url: "https://linear.app/not-so-fat/issue/NOT-362/work",
+    state: { name: "In Progress", type: "started" },
+    team: { id: "team-1" },
+    attachments: { nodes: [] },
+});
+const staleIssue = (attachments = []) => ({
+    identifier: "NOT-362",
+    url: "https://linear.app/not-so-fat/issue/NOT-362/work",
+    state: { name: "Backlog", type: "backlog" },
+    team: { id: "team-1" },
+    attachments: { nodes: attachments },
+});
+function verifyArtifacts(issueId) {
+    return listArtifactsForIssueByKind(issueId, LINEAR_MERGE_VERIFY_ARTIFACT_KIND);
+}
+test("advanced via state type: merged transition records one artifact, no write, no action", async () => {
+    const state = freshStub(startedIssue());
+    stubLinear(state);
+    const issueId = newLinearIssue();
+    await mergeThroughReview(issueId);
+    assert.equal(getIssue(issueId).status, "done");
+    const artifacts = verifyArtifacts(issueId);
+    assert.equal(artifacts.length, 1);
+    const content = JSON.parse(artifacts[0].contentJson);
+    assert.equal(content.outcome, "advanced");
+    assert.equal(content.advancedVia, "state");
+    assert.equal(state.calls.stateWrites, 0);
+    assert.equal(state.calls.comments, 0);
+    assert.deepEqual(listHumanActionsForIssue(issueId).filter((a) => a.status === "open"), []);
+});
+test("advanced via attachment: Backlog state with the merged PR attached verifies", async () => {
+    const state = freshStub(staleIssue([{ url: PR_URL }]));
+    stubLinear(state);
+    const issueId = newLinearIssue();
+    await mergeThroughReview(issueId);
+    assert.equal(getIssue(issueId).status, "done");
+    const artifacts = verifyArtifacts(issueId);
+    assert.equal(artifacts.length, 1);
+    const content = JSON.parse(artifacts[0].contentJson);
+    assert.equal(content.outcome, "advanced");
+    assert.equal(content.advancedVia, "attachment");
+    assert.equal(state.calls.stateWrites, 0);
+    assert.equal(state.calls.comments, 0);
+    assert.deepEqual(listHumanActionsForIssue(issueId).filter((a) => a.status === "open"), []);
+});
+test("stale twice: exactly one completed-state write plus one comment, issue stays done", async () => {
+    const state = freshStub(staleIssue());
+    stubLinear(state);
+    const issueId = newLinearIssue();
+    const first = await mergeThroughReview(issueId);
+    // The merged transition itself succeeds — the post-check never fails it.
+    assert.equal(first.applied, true);
+    assert.equal(getIssue(issueId).status, "done");
+    // Re-running the check must not write twice (the completed issue has no
+    // active workflow left, so the re-run goes through the check itself).
+    const second = await verifyLinearPostMerge(issueId);
+    assert.equal(second.checked, true);
+    assert.equal(getIssue(issueId).status, "done");
+    assert.equal(state.calls.stateWrites, 1);
+    assert.equal(state.calls.comments, 1);
+    const artifacts = verifyArtifacts(issueId);
+    assert.equal(artifacts.length, 2);
+    const contents = artifacts.map((a) => JSON.parse(a.contentJson));
+    assert.ok(contents.every((c) => c.outcome === "stale"));
+    assert.ok(contents.some((c) => c.fallback === "written"));
+});
+test("concurrent stale checks join one in-flight run: single fallback write", async () => {
+    const state = freshStub(staleIssue());
+    stubLinear(state);
+    // A done issue reached without the merge path (which would already have run
+    // the check): overlapping checks must share one in-flight run instead of
+    // each writing the fallback.
+    const { transitionIssue } = await import("../repository/issues.js");
+    const issueId = newLinearIssue();
+    transitionIssue(issueId, "developing", { prUrl: PR_URL });
+    transitionIssue(issueId, "reviewing");
+    transitionIssue(issueId, "final_review");
+    transitionIssue(issueId, "done");
+    const [first, second] = await Promise.all([
+        verifyLinearPostMerge(issueId),
+        verifyLinearPostMerge(issueId),
+    ]);
+    assert.equal(first.checked, true);
+    assert.equal(second.checked, true);
+    assert.equal(getIssue(issueId).status, "done");
+    assert.equal(state.calls.stateWrites, 1);
+    assert.equal(state.calls.comments, 1);
+});
+test("failed fallback twice: exactly one open human action naming identifier, PR URL, state", async () => {
+    const state = freshStub(staleIssue());
+    state.failStateWriteWith = "no write access";
+    stubLinear(state);
+    const issueId = newLinearIssue();
+    const first = await mergeThroughReview(issueId);
+    // The merged transition itself succeeds — the post-check never fails it.
+    assert.equal(first.applied, true);
+    assert.equal(getIssue(issueId).status, "done");
+    const rerun = await verifyLinearPostMerge(issueId);
+    assert.equal(rerun.checked, true);
+    assert.equal(getIssue(issueId).status, "done");
+    const open = listHumanActionsForIssue(issueId).filter((a) => a.status === "open");
+    assert.equal(open.length, 1);
+    const action = open[0];
+    assert.equal(action.actionType, "policy_escalation");
+    assert.equal(action.requestId, linearMergeStaleRequestId(issueId));
+    assert.match(action.reason, /NOT-362/);
+    assert.ok(action.reason.includes(PR_URL), "names the merged PR URL");
+    assert.match(action.reason, /Backlog/);
+});
+test("unavailable fallback (no completed state): one open human action, issue stays done", async () => {
+    const state = freshStub(staleIssue());
+    state.noCompletedState = true;
+    stubLinear(state);
+    const issueId = newLinearIssue();
+    const first = await mergeThroughReview(issueId);
+    // The merged transition itself succeeds — the post-check never fails it.
+    assert.equal(first.applied, true);
+    await verifyLinearPostMerge(issueId);
+    assert.equal(getIssue(issueId).status, "done");
+    assert.equal(state.calls.stateWrites, 0);
+    const open = listHumanActionsForIssue(issueId).filter((a) => a.status === "open");
+    assert.equal(open.length, 1);
+    assert.match(open[0].reason, /NOT-362/);
+    assert.ok(open[0].reason.includes(PR_URL));
+});
+test("stale notice resolves via acknowledge: closes without touching the done issue", async () => {
+    const state = freshStub(staleIssue());
+    state.failStateWriteWith = "no write access";
+    stubLinear(state);
+    const issueId = newLinearIssue();
+    await mergeThroughReview(issueId);
+    const open = listHumanActionsForIssue(issueId).filter((a) => a.status === "open");
+    assert.equal(open.length, 1);
+    assert.equal(isLinearMergeStaleAction(open[0]), true);
+    const resolved = resolveLinearMergeStaleAction(open[0].id, "tester", "acknowledge");
+    assert.equal(resolved.ok, true);
+    if (!resolved.ok)
+        return;
+    assert.equal(resolved.issueStatus, "done");
+    assert.equal(listHumanActionsForIssue(issueId).filter((a) => a.status === "open").length, 0, "acknowledge closes the notice");
+    assert.equal(getIssue(issueId).status, "done", "resolving the notice never moves the done issue");
+    const again = resolveLinearMergeStaleAction(open[0].id, "tester", "acknowledge");
+    assert.equal(again.ok, false);
+    if (again.ok)
+        return;
+    assert.equal(again.code, 409);
+});
+test("stale notice recheck after a hand advance clears with an advanced artifact", async () => {
+    const state = freshStub(staleIssue());
+    state.failStateWriteWith = "no write access";
+    stubLinear(state);
+    const issueId = newLinearIssue();
+    await mergeThroughReview(issueId);
+    const open = listHumanActionsForIssue(issueId).filter((a) => a.status === "open");
+    assert.equal(open.length, 1);
+    // The human advances the Linear issue by hand; re-check must see it.
+    state.linearIssue = startedIssue();
+    state.failStateWriteWith = null;
+    const rechecked = resolveLinearMergeStaleAction(open[0].id, "tester", "recheck");
+    assert.equal(rechecked.ok, true);
+    if (!rechecked.ok)
+        return;
+    assert.equal(rechecked.rechecked, true);
+    await drainLinearPostMergeForTests();
+    assert.equal(listHumanActionsForIssue(issueId).filter((a) => a.status === "open").length, 0, "a verified re-check raises no new notice");
+    const contents = verifyArtifacts(issueId).map((a) => JSON.parse(a.contentJson));
+    assert.ok(contents.some((c) => c.outcome === "stale"), "the original stale verdict is kept");
+    assert.ok(contents.some((c) => c.outcome === "advanced" && c.advancedVia === "state"), "the re-check records the hand-advanced verdict");
+    assert.equal(getIssue(issueId).status, "done");
+});
+test("stale-notice resolution rejects unknown actions and bad choices", async () => {
+    const missing = resolveLinearMergeStaleAction("no-such-action", "tester", "acknowledge");
+    assert.equal(missing.ok, false);
+    if (missing.ok)
+        return;
+    assert.equal(missing.code, 404);
+    const state = freshStub(staleIssue());
+    state.failStateWriteWith = "no write access";
+    stubLinear(state);
+    const issueId = newLinearIssue();
+    await mergeThroughReview(issueId);
+    const open = listHumanActionsForIssue(issueId).filter((a) => a.status === "open");
+    assert.equal(open.length, 1);
+    const badChoice = resolveLinearMergeStaleAction(open[0].id, "tester", "resume");
+    assert.equal(badChoice.ok, false);
+    if (badChoice.ok)
+        return;
+    assert.equal(badChoice.code, 400);
+    assert.equal(listHumanActionsForIssue(issueId).filter((a) => a.status === "open").length, 1, "a rejected choice leaves the notice open");
+    const { createHumanAction } = await import("../repository/human-actions.js");
+    const other = createHumanAction({
+        issueId,
+        workflowInstanceId: null,
+        actionType: "policy_escalation",
+        reason: "something else",
+        question: "something else?",
+        responseOptions: [{ choice: "close", label: "Close" }],
+    });
+    assert.equal(isLinearMergeStaleAction(other), false);
+    const wrongKind = resolveLinearMergeStaleAction(other.id, "tester", "acknowledge");
+    assert.equal(wrongKind.ok, false);
+    if (wrongKind.ok)
+        return;
+    assert.equal(wrongKind.code, 400);
+});

package/bundle/server/dist/coordinator/prompts.js

@@ -1,3 +1,4 @@
+import { sourceAttachmentsDeveloperSection, sourceAttachmentsReviewerSection, } from "./source-attachments.js";
 import { MUSE_SANDBOX_CAPABILITIES } from "../runners/muse-code-args.js";
 import { checkMuseVisualQa, museVisualQaPromptSection, } from "../adapters/muse-visual-qa.js";
 import { formatVerificationReceiptSection, } from "./verification-receipt.js";
@@ -260,7 +261,11 @@ export function buildDeveloperPrompt(input) {
     // stay byte-for-byte.
     ...(input.museDeveloper
         ? tagSemanticsDeveloperSection(input.taskSnapshot.acceptanceCriteria)
-        : []), ...executionContractSection(input.taskSnapshot.executionContract));
+        : []), ...executionContractSection(input.taskSnapshot.executionContract), 
+    // NOT-364: frozen source-attachment manifest — local file paths plus
+    // external-link metadata and the trust boundary. Empty/absent renders
+    // nothing so attachment-free prompts stay byte-for-byte.
+    ...sourceAttachmentsDeveloperSection(input.taskSnapshot.sourceAttachments));
     if (input.findings?.length) {
         parts.push(`## Findings to address`);
         for (const f of input.findings) {
@@ -385,6 +390,9 @@ export function buildReviewerPrompt(input) {
         // the tags, so untagged reviewer prompts stay byte-for-byte.
         ...tagSemanticsReviewerSection(input.taskSnapshot.acceptanceCriteria),
         ...executionContractSection(input.taskSnapshot.executionContract),
+        // NOT-364: the immutable manifest as metadata only — reviewers have no
+        // shell, so no file bytes and no worktree path are promised.
+        ...sourceAttachmentsReviewerSection(input.taskSnapshot.sourceAttachments),
         `## Diff (base ${input.baseSha.slice(0, 8)} → head ${input.headSha.slice(0, 8)})`,
         "```diff",
         formatDiffForPrompt(input.diff).text,

package/bundle/server/dist/coordinator/prompts.test.js

@@ -483,3 +483,96 @@ test("NOT-316: untagged reviewer prompt carries no tag-judging section", () => {
     assert.doesNotMatch(without, /## Criterion tags/);
     assert.equal(buildReviewerPrompt(reviewerBase), without);
 });
+// NOT-364: the frozen attachment manifest renders in the developer prompt as
+// local file paths plus link metadata with the trust boundary — and stays out
+// entirely when the manifest is empty.
+test("NOT-364: developer prompt lists frozen attachment files and links", () => {
+    const withManifest = buildDeveloperPrompt({
+        taskSnapshot: {
+            ...taskSnapshot,
+            sourceAttachments: [
+                {
+                    linearAttachmentId: "att-file-1",
+                    kind: "file",
+                    title: "repro.tar.gz",
+                    safeFileName: "repro.tar.gz",
+                    blobPath: "/blobs/repro.tar.gz",
+                    sizeBytes: 18,
+                    sha256: "ab".repeat(32),
+                    url: "https://uploads.linear.app/a/repro.tar.gz",
+                },
+                {
+                    linearAttachmentId: "att-link-1",
+                    kind: "link",
+                    title: "Design doc",
+                    url: "https://docs.example.com/x",
+                },
+            ],
+        },
+        round: 1,
+    });
+    assert.match(withManifest, /## Source attachments \(untrusted ticket inputs/);
+    assert.match(withManifest, /`\.agent-dealer-inputs\/linear\/repro\.tar\.gz`/);
+    assert.match(withManifest, /link: "Design doc" — https:\/\/docs\.example\.com\/x/);
+    assert.match(withManifest, /never commit them/);
+    assert.match(withManifest, /never extract archives outside a fresh contained directory/);
+    // Repair rounds see the same frozen section.
+    const repair = buildDeveloperPrompt({
+        taskSnapshot: {
+            ...taskSnapshot,
+            sourceAttachments: [
+                {
+                    linearAttachmentId: "att-file-1",
+                    kind: "file",
+                    title: "repro.tar.gz",
+                    safeFileName: "repro.tar.gz",
+                    blobPath: "/blobs/repro.tar.gz",
+                    sizeBytes: 18,
+                    sha256: "ab".repeat(32),
+                    url: "https://uploads.linear.app/a/repro.tar.gz",
+                },
+            ],
+        },
+        round: 2,
+    });
+    assert.match(repair, /`\.agent-dealer-inputs\/linear\/repro\.tar\.gz`/);
+});
+test("NOT-364: attachment-free developer prompts render no source-attachment section", () => {
+    const without = buildDeveloperPrompt({ taskSnapshot, round: 1 });
+    assert.doesNotMatch(without, /## Source attachments/);
+    assert.equal(buildDeveloperPrompt({ taskSnapshot, round: 1 }), without);
+});
+// NOT-364: reviewers get the immutable manifest as metadata only — no
+// worktree path, no server blob path, no file contents.
+test("NOT-364: reviewer prompt carries manifest metadata without file paths", () => {
+    const prompt = buildReviewerPrompt({
+        ...reviewerBase,
+        taskSnapshot: {
+            ...taskSnapshot,
+            sourceAttachments: [
+                {
+                    linearAttachmentId: "att-file-1",
+                    kind: "file",
+                    title: "repro.tar.gz",
+                    safeFileName: "repro.tar.gz",
+                    blobPath: "/blobs/repro.tar.gz",
+                    sizeBytes: 18,
+                    sha256: "ab".repeat(32),
+                    url: "https://uploads.linear.app/a/repro.tar.gz",
+                },
+                {
+                    linearAttachmentId: "att-link-1",
+                    kind: "link",
+                    title: "Design doc",
+                    url: "https://docs.example.com/x",
+                },
+            ],
+        },
+    });
+    assert.match(prompt, /## Source attachments \(frozen manifest — metadata only/);
+    assert.match(prompt, /"repro\.tar\.gz"/);
+    assert.doesNotMatch(prompt, /\.agent-dealer-inputs/);
+    assert.doesNotMatch(prompt, /\/blobs\//);
+    const without = buildReviewerPrompt(reviewerBase);
+    assert.doesNotMatch(without, /## Source attachments/);
+});