agent-dealer 1.2.12 → 1.2.14

package/bundle/server/dist/adapters/linear-inbox.test.js

@@ -1,6 +1,9 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { buildIssueFilter, nodeToCandidate, parseLinearIssueRef } from "./linear-inbox.js";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { buildIssueFilter, getLinearIssue, LINEAR_CANDIDATE_PAGE_SIZE, listLinearCandidates, fetchLinearIntakeMetadata, nodeToCandidate, parseLinearIssueRef, } from "./linear-inbox.js";
 test("parseLinearIssueRef accepts identifier, URL, and UUID", () => {
     assert.equal(parseLinearIssueRef("NOT-103"), "NOT-103");
     assert.equal(parseLinearIssueRef("  not-90  "), "NOT-90");
@@ -81,3 +84,480 @@ test("buildIssueFilter includes assignee when assigneeMe is true", () => {
         assignee: { id: { eq: "viewer-1" } },
     });
 });
+// NOT-361: bounded candidate fetch — AND filters, updatedAt order, first page only.
+test("listLinearCandidates requests AND filters, updatedAt order, and a single page", async () => {
+    process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-linear-inbox-"));
+    process.env.LINEAR_API_KEY = "test-key";
+    delete process.env.LINEAR_STATE_FILTER;
+    delete process.env.LINEAR_TEAM_ID;
+    const { migrate } = await import("../db/index.js");
+    migrate();
+    const { patchLinearIntakeConfig } = await import("../repository/intake-settings.js");
+    patchLinearIntakeConfig({
+        stateFilter: ["Todo", "In Progress"],
+        teamId: "team-9",
+        assigneeMe: true,
+    });
+    const requests = [];
+    const realFetch = globalThis.fetch;
+    globalThis.fetch = (async (_url, init) => {
+        const body = JSON.parse(String(init?.body ?? "{}"));
+        requests.push({ query: body.query ?? "", variables: body.variables });
+        if ((body.query ?? "").includes("viewer {")) {
+            return {
+                ok: true,
+                status: 200,
+                headers: new Headers(),
+                text: async () => JSON.stringify({ data: { viewer: { id: "viewer-1", name: "Ada" } } }),
+            };
+        }
+        return {
+            ok: true,
+            status: 200,
+            headers: new Headers(),
+            text: async () => JSON.stringify({
+                data: {
+                    issues: {
+                        nodes: [
+                            {
+                                id: "i1",
+                                identifier: "NOT-1",
+                                title: "one",
+                                url: "https://linear.app/x/issue/NOT-1/one",
+                                state: { name: "Todo" },
+                                team: { id: "team-9" },
+                                labels: { nodes: [] },
+                            },
+                        ],
+                        pageInfo: { hasNextPage: true },
+                    },
+                },
+            }),
+        };
+    });
+    try {
+        const page = await listLinearCandidates();
+        assert.equal(page.candidates.length, 1);
+        assert.equal(page.hasMore, true);
+        // viewer (assigneeMe) + one issues page — never a second cursor page.
+        assert.equal(requests.length, 2);
+        const issuesReq = requests.find((r) => r.query.includes("issues("));
+        assert.ok(issuesReq, "issues query sent");
+        assert.match(issuesReq.query, /orderBy:\s*updatedAt/);
+        assert.match(issuesReq.query, new RegExp(`first:\\s*${LINEAR_CANDIDATE_PAGE_SIZE}`));
+        assert.ok(!issuesReq.query.includes("$after"), "no cursor variable");
+        assert.deepEqual(issuesReq.variables?.filter, {
+            state: { name: { in: ["Todo", "In Progress"] } },
+            team: { id: { eq: "team-9" } },
+            assignee: { id: { eq: "viewer-1" } },
+        });
+    }
+    finally {
+        globalThis.fetch = realFetch;
+        delete process.env.LINEAR_API_KEY;
+    }
+});
+test("fetchLinearIntakeMetadata returns teams, statuses, and viewer", async () => {
+    process.env.LINEAR_API_KEY = "test-key";
+    const realFetch = globalThis.fetch;
+    const bodies = [];
+    globalThis.fetch = (async (_input, init) => {
+        bodies.push(JSON.parse(String(init?.body ?? "{}")));
+        const op = bodies[bodies.length - 1].query ?? "";
+        if (op.includes("IntakeMetadataViewer")) {
+            return new Response(JSON.stringify({
+                data: { viewer: { id: "v1", name: "Ada", email: "ada@example.com" } },
+            }), { status: 200, headers: { "Content-Type": "application/json" } });
+        }
+        return new Response(JSON.stringify({
+            data: {
+                teams: {
+                    nodes: [
+                        {
+                            id: "t1",
+                            name: "Core",
+                            key: "COR",
+                            states: {
+                                nodes: [
+                                    { name: "Todo", type: "unstarted" },
+                                    { name: "Done", type: "completed" },
+                                ],
+                            },
+                        },
+                    ],
+                    pageInfo: { hasNextPage: false, endCursor: null },
+                },
+            },
+        }), { status: 200, headers: { "Content-Type": "application/json" } });
+    });
+    try {
+        const meta = await fetchLinearIntakeMetadata();
+        assert.equal(meta.viewer?.name, "Ada");
+        assert.equal(meta.teams[0]?.name, "Core");
+        assert.ok(meta.workflowStates.some((s) => s.name === "Todo" && s.teamId === "t1"));
+    }
+    finally {
+        globalThis.fetch = realFetch;
+        delete process.env.LINEAR_API_KEY;
+    }
+});
+test("fetchLinearIntakeMetadata walks team pages beyond Linear's default first page", async () => {
+    process.env.LINEAR_API_KEY = "test-key";
+    const realFetch = globalThis.fetch;
+    let teamPageCalls = 0;
+    globalThis.fetch = (async (_input, init) => {
+        const body = JSON.parse(String(init?.body ?? "{}"));
+        if ((body.query ?? "").includes("IntakeMetadataViewer")) {
+            return new Response(JSON.stringify({ data: { viewer: { id: "v1", name: "Ada" } } }), {
+                status: 200,
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+        teamPageCalls += 1;
+        assert.equal(body.variables?.first, 50, "requests a bounded team page");
+        if (teamPageCalls === 1) {
+            assert.equal(body.variables?.after ?? null, null, "first page has no cursor");
+            return new Response(JSON.stringify({
+                data: {
+                    teams: {
+                        nodes: [
+                            {
+                                id: "t1",
+                                name: "Alpha",
+                                states: { nodes: [{ name: "Todo", type: "unstarted" }] },
+                            },
+                        ],
+                        pageInfo: { hasNextPage: true, endCursor: "cursor-1" },
+                    },
+                },
+            }), { status: 200, headers: { "Content-Type": "application/json" } });
+        }
+        assert.equal(body.variables?.after, "cursor-1", "follows endCursor");
+        return new Response(JSON.stringify({
+            data: {
+                teams: {
+                    nodes: [
+                        {
+                            id: "t2",
+                            name: "Zeta",
+                            states: { nodes: [{ name: "In Progress", type: "started" }] },
+                        },
+                    ],
+                    pageInfo: { hasNextPage: false, endCursor: null },
+                },
+            },
+        }), { status: 200, headers: { "Content-Type": "application/json" } });
+    });
+    try {
+        const meta = await fetchLinearIntakeMetadata();
+        assert.equal(teamPageCalls, 2, "walks a second team page");
+        assert.deepEqual(meta.teams.map((t) => t.name), ["Alpha", "Zeta"]);
+        assert.ok(meta.workflowStates.some((s) => s.name === "In Progress" && s.teamId === "t2"));
+    }
+    finally {
+        globalThis.fetch = realFetch;
+        delete process.env.LINEAR_API_KEY;
+    }
+});
+test("fetchLinearIntakeMetadata fails clearly without LINEAR_API_KEY", async () => {
+    delete process.env.LINEAR_API_KEY;
+    await assert.rejects(() => fetchLinearIntakeMetadata(), /LINEAR_API_KEY/);
+});
+// NOT-364: issue attachment metadata on candidates — hosted files and external
+// links, without regressing labels, repo resolution, or the 50-item page bound.
+test("nodeToCandidate carries file and link attachments with stable ids", () => {
+    const c = nodeToCandidate({
+        id: "uuid-1",
+        identifier: "NOT-364",
+        title: "t",
+        url: "https://linear.app/x/issue/NOT-364/t",
+        labels: { nodes: [{ name: "repo:github.com/not-so-fat/agent-dealer" }] },
+        attachments: {
+            nodes: [
+                {
+                    id: "att-file-1",
+                    title: "repro.tar.gz",
+                    url: "https://uploads.linear.app/abc/repro.tar.gz",
+                },
+                {
+                    id: "att-link-1",
+                    title: "Design doc",
+                    url: "https://docs.example.com/x",
+                    subtitle: "Spec",
+                    source: "google-docs",
+                },
+            ],
+        },
+    });
+    assert.equal(c.attachments?.length, 2);
+    assert.deepEqual(c.attachments?.[0], {
+        id: "att-file-1",
+        title: "repro.tar.gz",
+        url: "https://uploads.linear.app/abc/repro.tar.gz",
+    });
+    assert.deepEqual(c.attachments?.[1], {
+        id: "att-link-1",
+        title: "Design doc",
+        url: "https://docs.example.com/x",
+        subtitle: "Spec",
+        source: "google-docs",
+    });
+    // Labels and repo resolution are untouched by the attachment connection.
+    assert.deepEqual(c.labels, ["repo:github.com/not-so-fat/agent-dealer"]);
+    assert.equal(c.repoResolution?.status, "resolved");
+});
+test("nodeToCandidate drops malformed attachments and coerces source metadata", () => {
+    const c = nodeToCandidate({
+        id: "uuid-1",
+        identifier: "NOT-364",
+        title: "t",
+        url: "https://linear.app/x/issue/NOT-364/t",
+        labels: { nodes: [] },
+        attachments: {
+            nodes: [
+                { id: "", title: "no id", url: "https://uploads.linear.app/x" },
+                { id: "att-no-url", title: "no url", url: "" },
+                { id: "att-obj-source", title: "f", url: "https://uploads.linear.app/f", source: { kind: "slack" } },
+            ],
+        },
+    });
+    assert.equal(c.attachments?.length, 1);
+    assert.equal(c.attachments?.[0]?.id, "att-obj-source");
+    assert.equal(c.attachments?.[0]?.source, `{"kind":"slack"}`);
+});
+test("getLinearIssue carries attachment metadata on exact lookup", async () => {
+    process.env.LINEAR_API_KEY = "test-key";
+    const realFetch = globalThis.fetch;
+    globalThis.fetch = (async (_url) => ({
+        ok: true,
+        status: 200,
+        headers: new Headers(),
+        text: async () => JSON.stringify({
+            data: {
+                issue: {
+                    id: "linear-uuid-9",
+                    identifier: "NOT-9",
+                    title: "exact",
+                    url: "https://linear.app/x/issue/NOT-9/exact",
+                    state: { name: "Todo" },
+                    team: { id: "team-1" },
+                    labels: { nodes: [] },
+                    attachments: {
+                        nodes: [
+                            { id: "a1", title: "repro.tar.gz", url: "https://uploads.linear.app/a/repro.tar.gz" },
+                        ],
+                    },
+                },
+            },
+        }),
+    }));
+    try {
+        const found = await getLinearIssue("NOT-9");
+        assert.equal(found?.identifier, "NOT-9");
+        assert.equal(found?.attachments?.length, 1);
+        assert.equal(found?.attachments?.[0]?.title, "repro.tar.gz");
+    }
+    finally {
+        globalThis.fetch = realFetch;
+        delete process.env.LINEAR_API_KEY;
+    }
+});
+test("nodeToCandidate defaults missing attachments to an empty list", () => {
+    const c = nodeToCandidate({
+        id: "uuid-1",
+        identifier: "NOT-1",
+        title: "t",
+        url: "https://linear.app/x/issue/NOT-1/t",
+        labels: { nodes: [] },
+    });
+    assert.deepEqual(c.attachments, []);
+});
+// NOT-364: the candidate page still requests one bounded page and now carries
+// the attachments connection on every issue selection.
+test("listLinearCandidates queries attachments within the single 50-item page", async () => {
+    process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-linear-inbox-att-"));
+    process.env.LINEAR_API_KEY = "test-key";
+    delete process.env.LINEAR_STATE_FILTER;
+    delete process.env.LINEAR_TEAM_ID;
+    const { migrate } = await import("../db/index.js");
+    migrate();
+    const { patchLinearIntakeConfig } = await import("../repository/intake-settings.js");
+    patchLinearIntakeConfig({ stateFilter: ["Todo"], teamId: null, assigneeMe: false });
+    const requests = [];
+    const realFetch = globalThis.fetch;
+    globalThis.fetch = (async (_url, init) => {
+        const body = JSON.parse(String(init?.body ?? "{}"));
+        requests.push({ query: body.query ?? "" });
+        return {
+            ok: true,
+            status: 200,
+            headers: new Headers(),
+            text: async () => JSON.stringify({
+                data: {
+                    issues: {
+                        nodes: [
+                            {
+                                id: "i1",
+                                identifier: "NOT-1",
+                                title: "one",
+                                url: "https://linear.app/x/issue/NOT-1/one",
+                                state: { name: "Todo" },
+                                team: { id: "team-9" },
+                                labels: { nodes: [] },
+                                attachments: {
+                                    nodes: [
+                                        { id: "a1", title: "repro.tar.gz", url: "https://uploads.linear.app/a/repro.tar.gz" },
+                                        { id: "a2", title: "Doc", url: "https://docs.example.com/x", subtitle: "s" },
+                                    ],
+                                },
+                            },
+                        ],
+                        pageInfo: { hasNextPage: false },
+                    },
+                },
+            }),
+        };
+    });
+    try {
+        const page = await listLinearCandidates();
+        assert.equal(page.candidates.length, 1);
+        assert.equal(requests.length, 1, "still a single page — no cursor walk");
+        assert.match(requests[0].query, /attachments\s*\{\s*nodes\s*\{\s*id title url subtitle source\s*\}\s*\}/);
+        assert.match(requests[0].query, new RegExp(`first:\\s*${LINEAR_CANDIDATE_PAGE_SIZE}`));
+        assert.equal(page.candidates[0].attachments?.length, 2);
+        assert.equal(page.candidates[0].attachments?.[0]?.id, "a1");
+        assert.equal(page.candidates[0].attachments?.[1]?.subtitle, "s");
+    }
+    finally {
+        globalThis.fetch = realFetch;
+        delete process.env.LINEAR_API_KEY;
+    }
+});
+// NOT-362: intake persists Linear's branchName as the Dealer issue's branch.
+async function stubGetLinearIssue(node) {
+    process.env.LINEAR_API_KEY = "test-key";
+    const { migrate } = await import("../db/index.js");
+    migrate();
+    const realFetch = globalThis.fetch;
+    globalThis.__not362RestoreFetch = realFetch;
+    globalThis.fetch = (async (_url) => {
+        return {
+            ok: true,
+            status: 200,
+            headers: new Headers(),
+            text: async () => JSON.stringify({ data: { issue: node } }),
+        };
+    });
+}
+function restoreFetch() {
+    const saved = globalThis.__not362RestoreFetch;
+    if (saved)
+        globalThis.fetch = saved;
+    delete process.env.LINEAR_API_KEY;
+}
+async function makeStoredIssue(source, externalId) {
+    const { BUILTIN_AGENT_CLAUDE_ID, BUILTIN_AGENT_CURSOR_ID } = await import("@agent-dealer/shared");
+    const { createIssue } = await import("../repository/issues.js");
+    return createIssue({
+        title: "branch seed",
+        repo: "acme/app",
+        developerAgentId: BUILTIN_AGENT_CLAUDE_ID,
+        reviewerAgentId: BUILTIN_AGENT_CURSOR_ID,
+        baseBranch: "main",
+        maxReviewRounds: 3,
+        maxInfraAttempts: 3,
+        source,
+        ...(externalId ? { externalId } : {}),
+    }).id;
+}
+test("persistLinearBranchForIssue stores Linear's branchName on the issue", async () => {
+    const { getLinearIssue, persistLinearBranchForIssue } = await import("./linear-inbox.js");
+    const { getIssue } = await import("../repository/issues.js");
+    await stubGetLinearIssue({
+        id: "lin-1",
+        identifier: "NOT-1",
+        title: "one",
+        url: "https://linear.app/x/issue/NOT-1/one",
+        branchName: "yusukemuraoka/ate-4-some-work",
+        state: { name: "Todo" },
+        team: { id: "team-9" },
+        labels: { nodes: [] },
+    });
+    try {
+        const candidate = await getLinearIssue("lin-1");
+        assert.equal(candidate?.branchName, "yusukemuraoka/ate-4-some-work");
+        const issueId = await makeStoredIssue("linear", "lin-1");
+        assert.equal(getIssue(issueId).branch, null);
+        await persistLinearBranchForIssue(issueId);
+        assert.equal(getIssue(issueId).branch, "yusukemuraoka/ate-4-some-work");
+    }
+    finally {
+        restoreFetch();
+    }
+});
+test("persistLinearBranchForIssue falls back to issue-<id> with no Linear branch name", async () => {
+    const { persistLinearBranchForIssue } = await import("./linear-inbox.js");
+    const { getIssue } = await import("../repository/issues.js");
+    await stubGetLinearIssue({
+        id: "lin-2",
+        identifier: "NOT-2",
+        title: "two",
+        url: "https://linear.app/x/issue/NOT-2/two",
+        state: { name: "Todo" },
+        team: { id: "team-9" },
+        labels: { nodes: [] },
+    });
+    try {
+        const issueId = await makeStoredIssue("linear", "lin-2");
+        await persistLinearBranchForIssue(issueId);
+        assert.equal(getIssue(issueId).branch, `issue-${issueId}`);
+    }
+    finally {
+        restoreFetch();
+    }
+});
+test("persistLinearBranchForIssue seeds issue-<id> on a second pass for the same ticket", async () => {
+    const { persistLinearBranchForIssue } = await import("./linear-inbox.js");
+    const { getIssue, transitionIssue } = await import("../repository/issues.js");
+    await stubGetLinearIssue({
+        id: "lin-3",
+        identifier: "NOT-3",
+        title: "three",
+        url: "https://linear.app/x/issue/NOT-3/three",
+        branchName: "owner/ate-3-shared-linear-branch",
+        state: { name: "Todo" },
+        team: { id: "team-9" },
+        labels: { nodes: [] },
+    });
+    try {
+        const firstId = await makeStoredIssue("linear", "lin-3");
+        await persistLinearBranchForIssue(firstId);
+        assert.equal(getIssue(firstId).branch, "owner/ate-3-shared-linear-branch");
+        // The first pass ran to completion (NOT-141): the ticket is re-imported as
+        // a fresh Dealer issue. Reusing the Linear branch would check out the old
+        // branch (still holding pre-squash commits) and `gh pr view <branch>` could
+        // return the old MERGED PR — so the second pass must not reuse it.
+        transitionIssue(firstId, "closed");
+        const secondId = await makeStoredIssue("linear", "lin-3");
+        await persistLinearBranchForIssue(secondId);
+        assert.equal(getIssue(secondId).branch, `issue-${secondId}`);
+    }
+    finally {
+        restoreFetch();
+    }
+});
+test("persistLinearBranchForIssue leaves manual issues unchanged", async () => {
+    const { persistLinearBranchForIssue } = await import("./linear-inbox.js");
+    const { getIssue } = await import("../repository/issues.js");
+    process.env.LINEAR_API_KEY = "test-key";
+    const { migrate } = await import("../db/index.js");
+    migrate();
+    try {
+        const issueId = await makeStoredIssue("manual");
+        await persistLinearBranchForIssue(issueId);
+        assert.equal(getIssue(issueId).branch, null);
+    }
+    finally {
+        delete process.env.LINEAR_API_KEY;
+    }
+});

package/bundle/server/dist/adapters/linear-sync.js

@@ -7,9 +7,17 @@ const STATE_BY_EVENT = {
     done: "Done",
 };
 const workflowStateCache = new Map();
+/** Test hook — drop cached team workflow states between cases. */
+export function clearWorkflowStateCacheForTests() {
+    workflowStateCache.clear();
+}
 function webBaseUrl() {
     return process.env.AGENT_DEALER_WEB_URL ?? "http://localhost:2222";
 }
+/** Link back to a Dealer issue for Linear comments. */
+export function dealerIssueUrl(issueId) {
+    return `${webBaseUrl()}/?issue=${issueId}`;
+}
 async function linearMutate(operation, query, variables) {
     return linearGraphqlRequest({ operation, query, variables });
 }
@@ -29,25 +37,41 @@ async function getWorkflowStates(teamId) {
     workflowStateCache.set(teamId, map);
     return map;
 }
-async function commentCreate(issueId, body) {
+/** Post a comment on a Linear issue — shared by the run-scoped delivery path and
+ * NOT-362's post-merge fallback (which reuses this writer instead of adding a second). */
+export async function postLinearIssueComment(issueId, body) {
     await linearMutate("commentCreate", `mutation Comment($issueId: String!, $body: String!) {
       commentCreate(input: { issueId: $issueId, body: $body }) { success }
     }`, { issueId, body });
 }
-async function issueUpdateState(issueId, stateId) {
+/** Move a Linear issue to a workflow state by id — shared writer, see above. */
+export async function setLinearIssueState(issueId, stateId) {
     await linearMutate("issueUpdateState", `mutation UpdateIssue($issueId: String!, $stateId: String!) {
       issueUpdate(id: $issueId, input: { stateId: $stateId }) { success }
     }`, { issueId, stateId });
 }
-function buildComment(run) {
-    const label = run.externalLabel ?? run.externalId ?? run.id;
-    const link = `${webBaseUrl()}/?run=${run.id}`;
+/**
+ * Resolve the team's completed-state id for the terminal event — the one
+ * STATE_BY_EVENT mapping (NOT-362 reuses this resolution for the fallback
+ * instead of adding a second writer). Null when the team has no matching state.
+ */
+export async function resolveCompletedStateId(teamId) {
+    const states = await getWorkflowStates(teamId);
+    return states.get(STATE_BY_EVENT.done.toLowerCase()) ?? null;
+}
+/** The Dealer comment posted alongside the terminal write — one voice for the
+ * run-scoped delivery path and NOT-362's post-merge fallback. */
+export function buildDoneComment(label, link, linkLabel = "View run") {
     return [
         `**agent-dealer** — approved and marked done (${label})`,
         ``,
-        `[View run](${link})`,
+        `[${linkLabel}](${link})`,
     ].join("\n");
 }
+function buildComment(run) {
+    const label = run.externalLabel ?? run.externalId ?? run.id;
+    return buildDoneComment(label, `${webBaseUrl()}/?run=${run.id}`);
+}
 function recordSyncAttempt(run, event, ok, detail) {
     addArtifact(run.id, "linear_sync", { event, ok, at: new Date().toISOString(), ...detail }, "system");
 }
@@ -63,12 +87,11 @@ export async function syncLinearForRun(run, event) {
         return;
     }
     const targetStateName = STATE_BY_EVENT[event];
-    const states = await getWorkflowStates(issue.teamId);
-    const stateId = states.get(targetStateName.toLowerCase());
+    const stateId = await resolveCompletedStateId(issue.teamId);
     try {
-        await commentCreate(run.externalId, buildComment(run));
+        await postLinearIssueComment(run.externalId, buildComment(run));
         if (stateId) {
-            await issueUpdateState(run.externalId, stateId);
+            await setLinearIssueState(run.externalId, stateId);
         }
         else {
             recordSyncAttempt(run, event, false, {

package/bundle/server/dist/coordinator/auto-merge.js

@@ -30,6 +30,7 @@ import { appendWorkflowEvent, completeWorkflowInstance, getActiveWorkflowInstanc
 import { createHumanAction, findOpenHumanAction, findOpenHumanActionByRequestId, resolveHumanAction, } from "../repository/human-actions.js";
 import { MERGE_FAILURE_EVIDENCE_KEY, MERGE_FAILURE_RESPONSE_OPTIONS } from "./human-resolution.js";
 import { isMergeConflictFailure, runMergeConflictSync } from "./merge-conflict-sync.js";
+import { triggerLinearPostMerge } from "./linear-merge-verify.js";
 import { startBaseAdvancedScan } from "./base-advanced-scan.js";
 import { OPERATOR_VERIFICATION_RESPONSE_OPTIONS, formatOperatorCriteria, getOperatorCriteriaForIssue, hasOperatorVerificationForHead, operatorVerificationRequestId, } from "./operator-criteria.js";
 const run = promisify(execFile);
@@ -313,6 +314,15 @@ async function finalizeAutoMergeOnce(issueId) {
             triggerReflect: true,
         };
     })();
+    // NOT-362: the merge landed — confirm the Linear source issue advanced (or
+    // advance/flag it). Fire-and-forget: the check's bounded retry window (tens of
+    // seconds) must not hold this finalize, which runs while holding the reviewer
+    // session and slot. Never touches this issue's status, so it cannot change
+    // the merge's result. Runs on every `done` landing, including the
+    // already-merged recovery path.
+    if (merged.issueStatus === "done") {
+        triggerLinearPostMerge(issueId);
+    }
     // NOT-356: the base just moved under every other open Dealer PR on this repo +
     // base — probe them and resolve the idle conflicting ones. Background and
     // self-contained: nothing it does can change this merge's result. Only for a

package/bundle/server/dist/coordinator/branch-progress.js

@@ -15,10 +15,11 @@
 // here; wrongly re-running is only the status quo.
 import { branchExists, countCommitsBetween, fetchRef, refExists, } from "../adapters/git-worktree.js";
 /**
- * The branch a developer round works on. `issue.branch` is only written on a verified
- * clean_handoff (it is ground truth, not agent self-report), so an attempt that died before
- * that still left its commits on the conventional name — which is why the fallback here has
- * to match developer-effect.ts's.
+ * The branch a developer round works on. `issue.branch` is the branch NAME (written
+ * on a verified clean_handoff, or seeded from Linear's branchName at intake —
+ * NOT-362), so an attempt that died before any handoff still left its commits on
+ * the conventional name — which is why the fallback here has to match
+ * developer-effect.ts's.
  */
 export function developerBranchName(issue) {
     return issue.branch ?? `issue-${issue.id}`;