agent-dealer 1.2.13 → 1.2.15

package/bundle/server/dist/adapters/git-worktree.js

@@ -1042,6 +1042,21 @@ export async function resolveDeveloperWorktree(opts) {
             ref = `origin/${opts.branchName}`;
             newBranch = opts.branchName;
         }
+        else if (reuseRemoteSha === null && !(await branchExists(opts.repo, opts.branchName))) {
+            // NOT-362: the reuse path was taken for a branch that exists nowhere — a
+            // freshly seeded Linear `branchName` (or `issue-<id>` fallback) has no
+            // local ref and the remote never saw it (`git worktree add <path>
+            // <branch>` would reject the unknown ref). Cut it fresh from the base
+            // instead of checking out a branch that does not exist.
+            const fresh = await fetchFreshBase(opts.repo, opts.baseBranch, opts.fetchTimeoutMs);
+            if (!fresh.ok) {
+                return { kind: "base_unavailable", reason: fresh.reason };
+            }
+            ref = fresh.ref;
+            newBranch = opts.branchName;
+            baseSha = fresh.sha;
+            baseRef = fresh.ref;
+        }
         else {
             // NOT-219: when the remote tip is known and the local ref is strictly behind
             // it (an ancestor of it), advance the local ref to the pushed tip before

package/bundle/server/dist/adapters/git-worktree.test.js

@@ -1183,6 +1183,36 @@ test("NOT-197: a fresh developer branch starts from the fetched origin/<base>, n
         fs.rmSync(isoRemote, { recursive: true, force: true });
     }
 });
+test("NOT-362: a seeded Linear branch name that exists nowhere starts round 1 from a fresh base cut", async () => {
+    // Round-1 shape after intake seeding: developer-effect computes
+    // reuseBranch = true from the seeded issue.branch, but the branch has no
+    // local ref and the remote never saw it. Pre-fix this reached
+    // `git worktree add <path> <branch>` with no newBranch and git rejected the
+    // unknown ref; now it cuts the seeded name fresh from the fetched base.
+    const { isoRepo, isoRemote } = makeIsoRepoPair("362seed");
+    const branch = "yusukemuraoka/ate-4-some-work";
+    try {
+        assert.equal(await branchExists(isoRepo, branch), false);
+        const resolved = await resolveDeveloperWorktree({
+            repo: isoRepo,
+            sessionId: "s-362-seed",
+            branchName: branch,
+            baseBranch: "main",
+            reuseBranch: true,
+        });
+        assert.equal(resolved.kind, "created");
+        if (resolved.kind !== "created")
+            return;
+        const originTip = git(isoRepo, "rev-parse", "origin/main");
+        assert.equal(git(resolved.path, "rev-parse", "HEAD"), originTip);
+        assert.equal(git(isoRepo, "rev-parse", branch), originTip);
+        await removeIsoWorktree(isoRepo, resolved.path, branch);
+    }
+    finally {
+        fs.rmSync(isoRepo, { recursive: true, force: true });
+        fs.rmSync(isoRemote, { recursive: true, force: true });
+    }
+});
 test("NOT-197: a failed pre-branch fetch returns base_unavailable and creates no branch", async () => {
     const { isoRepo, isoRemote } = makeIsoRepoPair("fail");
     try {

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

@@ -1,4 +1,6 @@
 import { resolveLinearRepoWithMappings } from "@agent-dealer/shared";
+import { getDb } from "../db/index.js";
+import { getIssue, listIssuesByExternalId } from "../repository/issues.js";
 import { DEFAULT_LINEAR_STATE_FILTER, getLinearIntakeConfig } from "../repository/intake-settings.js";
 import { listRepositoryMappings } from "../repository/repository-mappings.js";
 import { LinearApiKeyMissingError, linearGraphqlRequest } from "./linear-graphql.js";
@@ -23,8 +25,45 @@ async function linearQuery(operation, query, variables, opts) {
  * deterministic (one valid label resolves, zero is unresolved, several
  * conflict, a bad value is invalid) and never guesses from anything else.
  */
+/**
+ * NOT-364: the issue's own `attachments` connection — file uploads and
+ * external links attached to the ticket itself. Comment bodies and files
+ * uploaded only inside comments are never queried and never snapshotted.
+ * `source` is Linear's own metadata scalar; non-string values are coerced to
+ * a short string so the contract stays stable regardless of shape.
+ */
+export function nodeToAttachment(a) {
+    if (!a || typeof a.id !== "string" || !a.id)
+        return null;
+    if (typeof a.url !== "string" || !a.url)
+        return null;
+    const out = {
+        id: a.id,
+        title: typeof a.title === "string" && a.title ? a.title : a.id,
+        url: a.url,
+    };
+    if (typeof a.subtitle === "string" && a.subtitle)
+        out.subtitle = a.subtitle;
+    if (typeof a.source === "string" && a.source) {
+        out.source = a.source;
+    }
+    else if (a.source != null && typeof a.source === "object") {
+        try {
+            const rendered = JSON.stringify(a.source);
+            if (rendered && rendered !== "{}")
+                out.source = rendered;
+        }
+        catch {
+            // ignore unserializable source metadata
+        }
+    }
+    return out;
+}
 export function nodeToCandidate(n, mappings) {
     const labels = n.labels?.nodes.map((l) => l.name) ?? [];
+    const attachments = (n.attachments?.nodes ?? [])
+        .map(nodeToAttachment)
+        .filter((a) => a !== null);
     return {
         id: n.id,
         identifier: n.identifier,
@@ -33,8 +72,15 @@ export function nodeToCandidate(n, mappings) {
         url: n.url,
         state: n.state?.name,
         teamId: n.team?.id,
+        // NOT-362: Linear's suggested branch name, when it returns one.
+        ...(typeof n.branchName === "string" && n.branchName.trim()
+            ? { branchName: n.branchName }
+            : {}),
         labels,
         repoResolution: resolveLinearRepoWithMappings(labels, mappings ?? []),
+        // Always present (possibly empty) so the UI can distinguish "no
+        // attachments" from "queried before attachments existed".
+        attachments,
     };
 }
 const ISSUE_FIELDS = `
@@ -43,9 +89,11 @@ const ISSUE_FIELDS = `
   title
   description
   url
+  branchName
   state { name }
   team { id }
   labels { nodes { name } }
+  attachments { nodes { id title url subtitle source } }
 `;
 export async function getLinearViewer() {
     if (!hasApiKey())
@@ -339,3 +387,52 @@ export async function lookupLinearIssue(raw) {
         return null;
     return getLinearIssue(id);
 }
+/**
+ * NOT-362: seed a freshly imported Linear issue's branch from Linear's own
+ * `branchName`, so published branches carry the Linear identifier on
+ * repositories Linear's GitHub integration covers.
+ *
+ * Runs once at intake (POST /api/issues, source `linear`): a branch the
+ * workflow already wrote (clean_handoff ground truth) is never overwritten,
+ * manual (`source != 'linear'`) issues are untouched, and a Linear issue with
+ * no branch name falls back to the conventional `issue-<id>` — the same value
+ * `developerBranchName` would derive, materialized so the stored row says it.
+ * First pass only: a second Dealer issue for the same ticket (NOT-141) keeps
+ * `issue-<id>` so it never reuses the first pass's branch.
+ * Best-effort: an unreadable Linear (no key, outage) leaves the branch null
+ * and never fails the import.
+ */
+export async function persistLinearBranchForIssue(issueId) {
+    try {
+        const issue = getIssue(issueId);
+        if (!issue || issue.source !== "linear" || !issue.externalId)
+            return issue?.branch ?? null;
+        if (issue.branch)
+            return issue.branch;
+        // NOT-362 round 3: Linear's branchName is per Linear ticket, but each Dealer
+        // issue needs a unique branch per pass. routes/issues.ts (NOT-141) creates a
+        // fresh Dealer issue when an earlier pass for the same ticket is done/closed,
+        // and auto-merge squashes without deleting the branch — so a second pass
+        // seeded with the same Linear name would check out the first pass's branch
+        // (still holding pre-squash commits) and `gh pr view <branch>` could return
+        // the old MERGED PR. Seed the Linear name only for the first pass; later
+        // passes keep the conventional `issue-<id>`.
+        const priorPass = listIssuesByExternalId(issue.source, issue.externalId).some((row) => row.id !== issue.id);
+        if (priorPass) {
+            const fallback = `issue-${issue.id}`;
+            getDb()
+                .prepare("UPDATE issues SET branch = ?, updated_at = ? WHERE id = ? AND branch IS NULL")
+                .run(fallback, new Date().toISOString(), issue.id);
+            return getIssue(issue.id)?.branch ?? fallback;
+        }
+        const candidate = await getLinearIssue(issue.externalId);
+        const branch = candidate?.branchName?.trim() || `issue-${issue.id}`;
+        getDb()
+            .prepare("UPDATE issues SET branch = ?, updated_at = ? WHERE id = ? AND branch IS NULL")
+            .run(branch, new Date().toISOString(), issue.id);
+        return getIssue(issue.id)?.branch ?? branch;
+    }
+    catch {
+        return getIssue(issueId)?.branch ?? null;
+    }
+}

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

@@ -3,7 +3,7 @@ import assert from "node:assert/strict";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { buildIssueFilter, LINEAR_CANDIDATE_PAGE_SIZE, listLinearCandidates, fetchLinearIntakeMetadata, nodeToCandidate, parseLinearIssueRef, } from "./linear-inbox.js";
+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");
@@ -263,3 +263,301 @@ 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/capacity/claude-events.js

@@ -319,6 +319,15 @@ export function extractClaudeCapacityFromEvents(events, nowMs = Date.now(), fall
         return null;
     return { runtime: CLAUDE_RUNTIME, windows: [...byKey.values()], unavailable: [] };
 }
+let claudeCriticalReadingSeq = 0;
+/**
+ * Monotonic count of successful Claude 5H/1W writes from any source (probe,
+ * local cache, live session). The probe's in-memory failure streak compares
+ * against it so a non-probe success breaks the streak too (NOT-366).
+ */
+export function claudeCriticalReadingWriteSeq() {
+    return claudeCriticalReadingSeq;
+}
 /**
  * Persist Claude window readings as normalized capacity snapshots
  * (per-window upserts — siblings not in this observation are left untouched,
@@ -338,21 +347,32 @@ export function recordClaudeWindowReadings(readings, runtime, nowMs = Date.now()
     const persistable = normalized.filter((n) => n.unavailableReason === null && n.remainingPercent !== null);
     if (persistable.length === 0)
         return null;
-    const storedObservedAt = new Map(listCapacitySnapshots(runtime).map((row) => [row.windowKey, row.observedAt]));
+    const stored = new Map(listCapacitySnapshots(runtime).map((row) => [row.windowKey, row]));
     const fresh = persistable.filter((w) => {
-        const prev = storedObservedAt.get(w.windowKey);
-        if (!prev)
+        const prevRow = stored.get(w.windowKey);
+        if (!prevRow)
             return true;
-        const prevMs = Date.parse(prev);
+        // NOT-366: an unavailable row (probe failure recorded over a stale
+        // reading) keeps the last-good value and its `observedAt` only for this
+        // arbitration. With no last-good value any reading wins; otherwise only
+        // a strictly newer one does — re-ingesting the same stale cache sample
+        // every poll must not wipe the recorded failure reason.
+        const unavailable = prevRow.source === "unavailable" || prevRow.unavailableReason !== null;
+        if (unavailable && prevRow.remainingPercent === null)
+            return true;
+        const prevMs = Date.parse(prevRow.observedAt);
         const nextMs = Date.parse(w.observedAt);
         if (!Number.isFinite(prevMs))
             return true;
         if (!Number.isFinite(nextMs))
             return false;
-        return nextMs >= prevMs;
+        return unavailable ? nextMs > prevMs : nextMs >= prevMs;
     });
     if (fresh.length === 0)
         return 0;
+    if (fresh.some((w) => w.criticalRole === "five_hour" || w.criticalRole === "weekly")) {
+        claudeCriticalReadingSeq += 1;
+    }
     recordCapacitySnapshots(runtime, fresh.map((w) => ({
         windowKey: w.windowKey,
         providerBucket: w.providerBucket,