agent-dealer 1.0.0 → 1.0.2

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

@@ -0,0 +1,165 @@
+// packages/server/src/adapters/linear-graphql.ts
+//
+// Shared Linear GraphQL POST helper (NOT-152): log HTTP failures with rate-limit
+// headers, and surface a structured error so NOT-104 can back off until reset.
+export const LINEAR_API = "https://api.linear.app/graphql";
+const BODY_SNIPPET_MAX = 300;
+/** Bounded default when Linear returns 429 without a usable reset / Retry-After. */
+export const DEFAULT_RATE_LIMIT_BACKOFF_MS = 60_000;
+export class LinearHttpError extends Error {
+    status;
+    operation;
+    rateLimit;
+    bodySnippet;
+    /** ms until the rate-limit window reopens; null when not a rate-limit / unknown. */
+    retryAfterMs;
+    constructor(init) {
+        const remaining = init.rateLimit.requestsRemaining;
+        const reset = init.rateLimit.requestsReset;
+        const parts = [
+            `Linear HTTP ${init.status}`,
+            `operation=${init.operation}`,
+            remaining != null ? `requests-remaining=${remaining}` : null,
+            reset != null ? `requests-reset=${reset}` : null,
+        ].filter(Boolean);
+        super(parts.join(" "));
+        this.name = "LinearHttpError";
+        this.status = init.status;
+        this.operation = init.operation;
+        this.rateLimit = init.rateLimit;
+        this.bodySnippet = init.bodySnippet;
+        this.retryAfterMs = init.retryAfterMs;
+    }
+}
+export function parseLinearRateLimitHeaders(headers) {
+    const out = {};
+    const set = (key, name) => {
+        const v = headers.get(name);
+        if (v != null && v !== "")
+            out[key] = v;
+    };
+    set("requestsLimit", "x-ratelimit-requests-limit");
+    set("requestsRemaining", "x-ratelimit-requests-remaining");
+    set("requestsReset", "x-ratelimit-requests-reset");
+    set("complexityLimit", "x-ratelimit-complexity-limit");
+    set("complexityRemaining", "x-ratelimit-complexity-remaining");
+    set("complexityReset", "x-ratelimit-complexity-reset");
+    set("complexity", "x-complexity");
+    set("retryAfter", "retry-after");
+    return out;
+}
+/**
+ * How long to wait before retrying a rate-limited call.
+ * Linear's `X-RateLimit-Requests-Reset` is UTC epoch **milliseconds**.
+ * Prefer that reset header when present (NOT-152); Retry-After / default are fallbacks.
+ */
+export function computeRetryAfterMs(status, rateLimit, nowMs = Date.now()) {
+    if (status !== 429 && rateLimit.requestsRemaining !== "0")
+        return null;
+    if (rateLimit.requestsReset) {
+        const resetMs = Number(rateLimit.requestsReset);
+        if (Number.isFinite(resetMs) && resetMs > 0) {
+            // Accept seconds-epoch (10 digits) in case a proxy rewrites the header.
+            const absolute = resetMs < 1e12 ? resetMs * 1000 : resetMs;
+            return Math.max(0, absolute - nowMs);
+        }
+    }
+    if (rateLimit.retryAfter) {
+        const seconds = Number(rateLimit.retryAfter);
+        if (Number.isFinite(seconds) && seconds >= 0)
+            return Math.ceil(seconds * 1000);
+    }
+    if (status === 429)
+        return DEFAULT_RATE_LIMIT_BACKOFF_MS;
+    return null;
+}
+export function formatLinearFailureLog(err) {
+    const rl = err.rateLimit;
+    const bits = [
+        `[linear] ${err.operation} failed`,
+        `status=${err.status}`,
+        rl.requestsRemaining != null ? `requests-remaining=${rl.requestsRemaining}` : null,
+        rl.requestsReset != null ? `requests-reset=${rl.requestsReset}` : null,
+        rl.requestsLimit != null ? `requests-limit=${rl.requestsLimit}` : null,
+        rl.complexityRemaining != null ? `complexity-remaining=${rl.complexityRemaining}` : null,
+        rl.complexityReset != null ? `complexity-reset=${rl.complexityReset}` : null,
+        rl.complexity != null ? `complexity=${rl.complexity}` : null,
+        err.bodySnippet ? `body=${err.bodySnippet}` : null,
+    ].filter(Boolean);
+    return bits.join(" ");
+}
+function truncateBody(text) {
+    const oneLine = text.replace(/\s+/g, " ").trim();
+    if (oneLine.length <= BODY_SNIPPET_MAX)
+        return oneLine;
+    return `${oneLine.slice(0, BODY_SNIPPET_MAX)}…`;
+}
+function isGraphqlRateLimited(errors) {
+    return errors.some((e) => {
+        if (!e || typeof e !== "object")
+            return false;
+        const ext = e.extensions;
+        return ext?.code === "RATELIMITED";
+    });
+}
+/**
+ * POST to Linear GraphQL. On non-OK HTTP (and GraphQL RATELIMITED), logs once and throws
+ * {@link LinearHttpError}. Callers keep their own catch for user-facing 502s.
+ */
+export async function linearGraphqlRequest(opts) {
+    const key = process.env.LINEAR_API_KEY;
+    if (!key)
+        throw new Error("LINEAR_API_KEY not set");
+    const res = await fetch(LINEAR_API, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: key },
+        body: JSON.stringify({ query: opts.query, variables: opts.variables }),
+        ...(opts.timeoutMs ? { signal: AbortSignal.timeout(opts.timeoutMs) } : {}),
+    });
+    const rateLimit = parseLinearRateLimitHeaders(res.headers instanceof Headers ? res.headers : new Headers());
+    const rawBody = typeof res.text === "function"
+        ? await res.text()
+        : JSON.stringify(await res.json());
+    const bodySnippet = truncateBody(rawBody);
+    if (!res.ok) {
+        const err = new LinearHttpError({
+            status: res.status,
+            operation: opts.operation,
+            rateLimit,
+            bodySnippet,
+            retryAfterMs: computeRetryAfterMs(res.status, rateLimit),
+        });
+        console.error(formatLinearFailureLog(err));
+        throw err;
+    }
+    let json;
+    try {
+        json = JSON.parse(rawBody);
+    }
+    catch {
+        const err = new LinearHttpError({
+            status: res.status,
+            operation: opts.operation,
+            rateLimit,
+            bodySnippet,
+            retryAfterMs: null,
+        });
+        console.error(formatLinearFailureLog(err));
+        throw new Error(`Linear GraphQL returned non-JSON for ${opts.operation}`);
+    }
+    if (json.errors?.length) {
+        if (isGraphqlRateLimited(json.errors) || rateLimit.requestsRemaining === "0") {
+            const err = new LinearHttpError({
+                status: 429,
+                operation: opts.operation,
+                rateLimit,
+                bodySnippet,
+                retryAfterMs: computeRetryAfterMs(429, rateLimit),
+            });
+            console.error(formatLinearFailureLog(err));
+            throw err;
+        }
+        throw new Error(JSON.stringify(json.errors));
+    }
+    return json.data;
+}

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

@@ -0,0 +1,129 @@
+// packages/server/src/adapters/linear-graphql.test.ts
+//
+// NOT-152: failed Linear GraphQL calls must log HTTP status + rate-limit headers,
+// and expose a structured error so NOT-104 can back off until the reset window.
+import { test, mock } from "node:test";
+import assert from "node:assert/strict";
+const { LinearHttpError, computeRetryAfterMs, linearGraphqlRequest, parseLinearRateLimitHeaders, } = await import("./linear-graphql.js");
+test("parseLinearRateLimitHeaders reads requests + complexity headers", () => {
+    const headers = new Headers({
+        "X-RateLimit-Requests-Limit": "2500",
+        "X-RateLimit-Requests-Remaining": "0",
+        "X-RateLimit-Requests-Reset": "1760000000000",
+        "X-RateLimit-Complexity-Limit": "1000000",
+        "X-RateLimit-Complexity-Remaining": "12",
+        "X-RateLimit-Complexity-Reset": "1760000000000",
+        "X-Complexity": "42",
+    });
+    assert.deepEqual(parseLinearRateLimitHeaders(headers), {
+        requestsLimit: "2500",
+        requestsRemaining: "0",
+        requestsReset: "1760000000000",
+        complexityLimit: "1000000",
+        complexityRemaining: "12",
+        complexityReset: "1760000000000",
+        complexity: "42",
+    });
+});
+test("computeRetryAfterMs uses Linear reset epoch-ms on 429", () => {
+    const now = 1_760_000_000_000;
+    const ms = computeRetryAfterMs(429, { requestsRemaining: "0", requestsReset: String(now + 45_000) }, now);
+    assert.equal(ms, 45_000);
+});
+test("computeRetryAfterMs prefers requests-reset over Retry-After when both are set", () => {
+    const now = 1_760_000_000_000;
+    const ms = computeRetryAfterMs(429, {
+        requestsRemaining: "0",
+        requestsReset: String(now + 45_000),
+        retryAfter: "5",
+    }, now);
+    assert.equal(ms, 45_000);
+});
+test("computeRetryAfterMs falls back to Retry-After seconds when reset missing", () => {
+    const ms = computeRetryAfterMs(429, { retryAfter: "30" }, 1_000);
+    assert.equal(ms, 30_000);
+});
+test("linearGraphqlRequest logs HTTP status and rate-limit headers on non-OK", async () => {
+    process.env.LINEAR_API_KEY = "lin_test";
+    const errors = [];
+    const errorMock = mock.method(console, "error", (...args) => {
+        errors.push(args);
+    });
+    const fetchMock = mock.method(globalThis, "fetch", async () => {
+        return new Response("rate limited", {
+            status: 429,
+            headers: {
+                "X-RateLimit-Requests-Remaining": "0",
+                "X-RateLimit-Requests-Reset": "1760000045000",
+                "X-RateLimit-Requests-Limit": "2500",
+            },
+        });
+    });
+    try {
+        await assert.rejects(() => linearGraphqlRequest({
+            operation: "listLinearCandidates",
+            query: "query { viewer { id } }",
+        }), (err) => {
+            assert.ok(err instanceof LinearHttpError);
+            assert.equal(err.status, 429);
+            assert.equal(err.operation, "listLinearCandidates");
+            assert.equal(err.rateLimit.requestsRemaining, "0");
+            assert.equal(err.rateLimit.requestsReset, "1760000045000");
+            assert.match(err.message, /429/);
+            return true;
+        });
+        const joined = errors.map((a) => a.map(String).join(" ")).join("\n");
+        assert.match(joined, /\[linear\]/);
+        assert.match(joined, /listLinearCandidates/);
+        assert.match(joined, /429/);
+        assert.match(joined, /requests-remaining[=:]?\s*0/i);
+        assert.match(joined, /requests-reset[=:]?\s*1760000045000/i);
+    }
+    finally {
+        errorMock.mock.restore();
+        fetchMock.mock.restore();
+    }
+});
+test("listLinearCandidates leaves a [linear] log line on HTTP 502 (intake path)", async () => {
+    // Mirrors GET /api/intake/linear: route returns String(e) to the client; dealer logs must
+    // still carry status + rate-limit headers from linearGraphqlRequest.
+    const fs = await import("node:fs");
+    const os = await import("node:os");
+    const path = await import("node:path");
+    process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-not152-"));
+    process.env.LINEAR_API_KEY = "lin_test";
+    const { migrate } = await import("../db/index.js");
+    migrate();
+    const { listLinearCandidates } = await import("./linear-inbox.js");
+    const errors = [];
+    const errorMock = mock.method(console, "error", (...args) => {
+        errors.push(args);
+    });
+    const fetchMock = mock.method(globalThis, "fetch", async () => {
+        return new Response("bad gateway", {
+            status: 502,
+            headers: {
+                "X-RateLimit-Requests-Remaining": "12",
+                "X-RateLimit-Requests-Reset": "1760000099000",
+            },
+        });
+    });
+    try {
+        await assert.rejects(() => listLinearCandidates(), (err) => {
+            assert.ok(err instanceof LinearHttpError);
+            assert.equal(err.status, 502);
+            assert.equal(err.operation, "listLinearCandidates");
+            return true;
+        });
+        const joined = errors.map((a) => a.map(String).join(" ")).join("\n");
+        assert.match(joined, /\[linear\]/);
+        assert.match(joined, /listLinearCandidates/);
+        assert.match(joined, /status=502/);
+        assert.match(joined, /requests-remaining=12/);
+        assert.match(joined, /requests-reset=1760000099000/);
+    }
+    finally {
+        errorMock.mock.restore();
+        fetchMock.mock.restore();
+    }
+});

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

@@ -1,26 +1,17 @@
 import { DEFAULT_LINEAR_STATE_FILTER, getLinearIntakeConfig } from "../repository/intake-settings.js";
+import { linearGraphqlRequest } from "./linear-graphql.js";
 export { DEFAULT_LINEAR_STATE_FILTER };
-const LINEAR_API = "https://api.linear.app/graphql";
 const PAGE_SIZE = 50;
 function hasApiKey() {
     return Boolean(process.env.LINEAR_API_KEY);
 }
-async function linearQuery(query, variables, opts) {
-    const key = process.env.LINEAR_API_KEY;
-    if (!key)
-        throw new Error("LINEAR_API_KEY not set");
-    const res = await fetch(LINEAR_API, {
-        method: "POST",
-        headers: { "Content-Type": "application/json", Authorization: key },
-        body: JSON.stringify({ query, variables }),
-        ...(opts?.timeoutMs ? { signal: AbortSignal.timeout(opts.timeoutMs) } : {}),
+async function linearQuery(operation, query, variables, opts) {
+    return linearGraphqlRequest({
+        operation,
+        query,
+        variables,
+        timeoutMs: opts?.timeoutMs,
     });
-    if (!res.ok)
-        throw new Error(`Linear HTTP ${res.status}: ${await res.text()}`);
-    const json = (await res.json());
-    if (json.errors?.length)
-        throw new Error(JSON.stringify(json.errors));
-    return json.data;
 }
 function nodeToCandidate(n) {
     return {
@@ -47,7 +38,7 @@ const ISSUE_FIELDS = `
 export async function getLinearViewer() {
     if (!hasApiKey())
         return null;
-    const data = (await linearQuery(`query { viewer { id name email } }`));
+    const data = (await linearQuery("getLinearViewer", `query { viewer { id name email } }`));
     return data.viewer;
 }
 export function buildIssueFilter(settings, viewerId) {
@@ -95,7 +86,7 @@ export async function listLinearCandidates() {
     const nodes = [];
     let after;
     for (;;) {
-        const data = (await linearQuery(`query PollIssues($filter: IssueFilter, $after: String) {
+        const data = (await linearQuery("listLinearCandidates", `query PollIssues($filter: IssueFilter, $after: String) {
         issues(filter: $filter, first: ${PAGE_SIZE}, after: $after) {
           nodes { ${ISSUE_FIELDS} }
           pageInfo { hasNextPage endCursor }
@@ -109,7 +100,7 @@ export async function listLinearCandidates() {
     return nodes.map(nodeToCandidate);
 }
 export async function getLinearIssue(issueId) {
-    const data = (await linearQuery(`query Issue($id: String!) {
+    const data = (await linearQuery("getLinearIssue", `query Issue($id: String!) {
       issue(id: $id) { ${ISSUE_FIELDS} }
     }`, { id: issueId }));
     if (!data.issue)
@@ -172,7 +163,7 @@ export async function fetchLinearBlockers(issueIds, opts = {}) {
     let paging = [];
     let after;
     for (;;) {
-        const data = (await linearQuery(`query BlockingRelations($ids: [ID!], $after: String) {
+        const data = (await linearQuery("fetchLinearBlockers", `query BlockingRelations($ids: [ID!], $after: String) {
         issues(filter: { id: { in: $ids } }, first: ${PAGE_SIZE}, after: $after, includeArchived: true) {
           nodes {
             id
@@ -263,7 +254,7 @@ async function fetchInverseRelationRound(pending, remaining) {
         variables[`ids${i}`] = [entry.id];
         variables[`after${i}`] = entry.after;
     });
-    const data = (await linearQuery(`query BlockingRelationsPage(${varDefs.join(", ")}) {\n${selections.join("\n")}\n}`, variables, { timeoutMs: remaining() }));
+    const data = (await linearQuery("fetchLinearBlockersPage", `query BlockingRelationsPage(${varDefs.join(", ")}) {\n${selections.join("\n")}\n}`, variables, { timeoutMs: remaining() }));
     const out = new Map();
     pending.forEach((entry, i) => {
         const page = data[`r${i}`]?.nodes?.find((n) => n.id === entry.id)?.inverseRelations;

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

@@ -1,7 +1,7 @@
 import { addArtifact } from "../repository/runs.js";
 import { getLinearIntakeConfig } from "../repository/intake-settings.js";
 import { getLinearIssue } from "./linear-inbox.js";
-const LINEAR_API = "https://api.linear.app/graphql";
+import { linearGraphqlRequest } from "./linear-graphql.js";
 const STATE_BY_EVENT = {
     // TODO(P2): configurable per team — see docs/LINEAR_INTEGRATION.md
     done: "Done",
@@ -10,27 +10,14 @@ const workflowStateCache = new Map();
 function webBaseUrl() {
     return process.env.AGENT_DEALER_WEB_URL ?? "http://localhost:2222";
 }
-async function linearMutate(query, variables) {
-    const key = process.env.LINEAR_API_KEY;
-    if (!key)
-        throw new Error("LINEAR_API_KEY not set");
-    const res = await fetch(LINEAR_API, {
-        method: "POST",
-        headers: { "Content-Type": "application/json", Authorization: key },
-        body: JSON.stringify({ query, variables }),
-    });
-    if (!res.ok)
-        throw new Error(`Linear HTTP ${res.status}: ${await res.text()}`);
-    const json = (await res.json());
-    if (json.errors?.length)
-        throw new Error(JSON.stringify(json.errors));
-    return json.data;
+async function linearMutate(operation, query, variables) {
+    return linearGraphqlRequest({ operation, query, variables });
 }
 async function getWorkflowStates(teamId) {
     const cached = workflowStateCache.get(teamId);
     if (cached)
         return cached;
-    const data = (await linearMutate(`query TeamStates($teamId: String!) {
+    const data = (await linearMutate("getWorkflowStates", `query TeamStates($teamId: String!) {
       team(id: $teamId) {
         states { nodes { id name } }
       }
@@ -43,12 +30,12 @@ async function getWorkflowStates(teamId) {
     return map;
 }
 async function commentCreate(issueId, body) {
-    await linearMutate(`mutation Comment($issueId: String!, $body: String!) {
+    await linearMutate("commentCreate", `mutation Comment($issueId: String!, $body: String!) {
       commentCreate(input: { issueId: $issueId, body: $body }) { success }
     }`, { issueId, body });
 }
 async function issueUpdateState(issueId, stateId) {
-    await linearMutate(`mutation UpdateIssue($issueId: String!, $stateId: String!) {
+    await linearMutate("issueUpdateState", `mutation UpdateIssue($issueId: String!, $stateId: String!) {
       issueUpdate(id: $issueId, input: { stateId: $stateId }) { success }
     }`, { issueId, stateId });
 }

package/bundle/server/dist/adapters/managed-repo.js

@@ -26,6 +26,17 @@ async function git(cwd, args) {
 export function managedRepoPath(identity) {
     return path.join(getExecutionRoot(), "repos", identity);
 }
+/**
+ * Test helper: mark a managed identity as having a local clone so merge cwd resolution
+ * (and similar) does not fail closed. Does not create a real git repo.
+ */
+export function stubManagedCloneForTests(repoInput) {
+    const classified = classifyIssueRepo(repoInput);
+    if (classified.kind === "managed") {
+        fs.mkdirSync(path.join(classified.repoPath, ".git"), { recursive: true });
+    }
+    return classified.repoPath;
+}
 export function managedWorktreePath(identity, sessionId, role) {
     return path.join(getExecutionRoot(), "worktrees", identity, `${sessionId}-${role}`);
 }

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

@@ -1,9 +1,11 @@
 // NOT-102 acceptance: auto-merge on/off, merge failure escalation, recent repos.
+// NOT-151: portable github.com/… issue.repo must resolve to managed clone cwd, not the identity.
 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-not102-"));
 const { migrate, getDb } = await import("../db/index.js");
 const { BUILTIN_AGENT_CLAUDE_ID, BUILTIN_AGENT_CURSOR_ID } = await import("@agent-dealer/shared");
@@ -14,7 +16,23 @@ const { claimWorkItem, listWorkItemsForIssue } = await import("../repository/wor
 const { startWorkflow, applyCompletion } = await import("./commands.js");
 const { ReviewerResult } = await import("./reviewer-result.js");
 const { setMergePrForTests, clearFinalizeInflightForTests } = await import("./auto-merge.js");
-before(() => migrate());
+const { managedRepoPath } = await import("../adapters/managed-repo.js");
+/** Real local checkout so resolveAutoMergeCwd accepts the default legacy repo. */
+let fixtureRepo = "";
+function initFixtureRepo() {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-not102-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();
+});
 beforeEach(() => {
     getDb().exec(`
     DELETE FROM work_items;
@@ -40,7 +58,7 @@ function newIssue(opts = {}) {
         title: "Coordinate me",
         description: "d",
         acceptanceCriteria: "It works",
-        repo: opts.repo ?? "/repo/a",
+        repo: opts.repo ?? fixtureRepo,
         developerAgentId: BUILTIN_AGENT_CLAUDE_ID,
         reviewerAgentId: BUILTIN_AGENT_CURSOR_ID,
         baseBranch: "main",
@@ -110,7 +128,7 @@ test("autoMerge off: final_review complete undrafts+merges then marks done", asy
         assert.equal(resolved.instanceCompleted, true);
         assert.equal(resolved.triggerReflect, true);
     }
-    assert.deepEqual(calls, [{ cwd: "/repo/a", number: 42 }]);
+    assert.deepEqual(calls, [{ cwd: fixtureRepo, number: 42 }]);
     assert.equal(getIssue(issueId).status, "done");
     assert.equal(getActiveWorkflowInstance(issueId), null);
     assert.equal(listHumanActionsForIssue(issueId).filter((a) => a.status === "open").length, 0);
@@ -153,9 +171,42 @@ test("autoMerge on: reviewer approve merges PR, marks done, skips final_review h
     assert.equal(issue.status, "done");
     assert.equal(getActiveWorkflowInstance(issueId), null);
     assert.equal(listHumanActionsForIssue(issueId).filter((a) => a.actionType === "final_review").length, 0);
-    assert.deepEqual(calls, [{ cwd: "/repo/a", number: 42 }]);
+    assert.deepEqual(calls, [{ cwd: fixtureRepo, number: 42 }]);
     assert.ok(listWorkflowEventsForIssue(issueId).some((e) => e.type === "issue.completed"));
 });
+test("NOT-151: portable github.com repo merges via managed clone path, not identity string", async () => {
+    const identity = "github.com/not-so-fat/agent-dealer";
+    const managed = managedRepoPath(identity);
+    fs.mkdirSync(path.join(managed, ".git"), { recursive: true });
+    const calls = [];
+    setMergePrForTests(async (opts) => {
+        calls.push(opts);
+        return { ok: true };
+    });
+    const issueId = newIssue({ autoMerge: true, repo: identity });
+    startWorkflow(issueId);
+    await complete(issueId, cleanHandoff);
+    await complete(issueId, { kind: "verdict", result: okReview("approved") });
+    assert.equal(getIssue(issueId).status, "done");
+    assert.deepEqual(calls, [{ cwd: managed, number: 42 }]);
+    assert.notEqual(calls[0]?.cwd, identity);
+});
+test("NOT-151: missing managed clone escalates clearly without spawn gh ENOENT", async () => {
+    let mergeCalled = false;
+    setMergePrForTests(async () => {
+        mergeCalled = true;
+        return { ok: true };
+    });
+    const issueId = newIssue({ autoMerge: true, repo: "github.com/missing/no-clone" });
+    startWorkflow(issueId);
+    await complete(issueId, cleanHandoff);
+    await complete(issueId, { kind: "verdict", result: okReview("approved") });
+    assert.equal(mergeCalled, false);
+    const issue = getIssue(issueId);
+    assert.equal(issue.status, "needs_human");
+    assert.match(issue.currentIntent ?? "", /Managed clone missing/);
+    assert.doesNotMatch(issue.currentIntent ?? "", /ENOENT/);
+});
 test("autoMerge on: merge failure escalates to policy_escalation; issue not left half-done as final_review", async () => {
     setMergePrForTests(async () => ({ ok: false, reason: "required status checks failed" }));
     const issueId = newIssue({ autoMerge: true });

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

@@ -15,8 +15,15 @@
 //
 // Concurrency: finalizeAutoMerge is single-flight per issueId (in-process). Success and
 // escalate txns are also defensive if a racer already wrote done / needs_human.
+//
+// NOT-151: issue.repo is a portable GitHub identity after NOT-149 — never pass it to
+// execFile as cwd (Node reports that as misleading `spawn gh ENOENT`). Resolve via
+// classifyIssueRepo → managed/legacy local path first.
 import { execFile } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
 import { promisify } from "node:util";
+import { classifyIssueRepo } from "../adapters/managed-repo.js";
 import { getDb } from "../db/index.js";
 import { getIssue, listIssues, transitionIssue } from "../repository/issues.js";
 import { appendWorkflowEvent, completeWorkflowInstance, getActiveWorkflowInstance, } from "../repository/workflow-events.js";
@@ -27,17 +34,69 @@ export const GH_MERGE_TIMEOUT_MS = 20_000;
 /** Must match projection.ts's auto_merge currentIntent — recovery keys off this string. */
 export const AUTO_MERGE_INTENT = "Auto-merging approved PR";
 const ALREADY_MERGED = /already (been )?merged|pull request is not mergeable:.*merged/i;
+/**
+ * Map issue.repo (portable identity or legacy local path) to a real filesystem cwd for
+ * `gh pr merge`. Missing managed clones fail closed with a clear reason — never hand the
+ * identity string to execFile.
+ */
+export function resolveAutoMergeCwd(repoField) {
+    try {
+        const classified = classifyIssueRepo(repoField);
+        const cwd = classified.repoPath;
+        if (classified.kind === "managed") {
+            const hasGit = fs.existsSync(path.join(cwd, ".git")) || fs.existsSync(path.join(cwd, "HEAD"));
+            if (!hasGit) {
+                return {
+                    ok: false,
+                    reason: `Managed clone missing for ${classified.identity} (${cwd}). Re-run the developer step so Dealer can clone it, or restore the checkout under execution/repos.`,
+                };
+            }
+        }
+        return { ok: true, cwd };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            reason: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
 /** True when Node killed the child for exceeding `timeout` (promisify(execFile)). */
 export function isGhTimeoutError(err) {
     const e = err;
     return Boolean(e.killed || e.signal === "SIGTERM");
 }
+/** True when Node failed to spawn (missing binary *or* missing cwd — both surface ENOENT). */
+export function isGhSpawnEnoent(err) {
+    const e = err;
+    if (e.code === "ENOENT")
+        return true;
+    const msg = (e.message ?? "").toLowerCase();
+    return msg.includes("spawn") && msg.includes("enoent");
+}
+/**
+ * Distinguish "cwd is not a real directory" from "gh missing on PATH" — both look like
+ * `spawn gh ENOENT` from Node. Prefer checking the cwd on disk over trusting the message.
+ */
+export function ghSpawnEnoentReason(err, cwd) {
+    if (!isGhSpawnEnoent(err))
+        return null;
+    if (!fs.existsSync(cwd)) {
+        return `invalid merge cwd (${cwd}) — path does not exist (portable issue.repo must not be used as cwd)`;
+    }
+    return "gh not on PATH — install GitHub CLI (`gh`) and ensure the daemon can see it";
+}
 /** Map an execFile failure to a stable reason string (timeout vs stderr/stdout). */
-export function ghErrorReason(err, fallback) {
+export function ghErrorReason(err, fallback, cwd) {
     const e = err;
     if (isGhTimeoutError(err)) {
         return `gh timed out after ${GH_MERGE_TIMEOUT_MS}ms`;
     }
+    if (cwd) {
+        const spawnReason = ghSpawnEnoentReason(err, cwd);
+        if (spawnReason)
+            return spawnReason;
+    }
     return (e.stderr || e.stdout || e.message || fallback).trim() || fallback;
 }
 /** Production: mark draft ready (ignore if already), then squash-merge — async + timed. */
@@ -52,7 +111,12 @@ export const realMergePr = async ({ cwd, number }) => {
     catch (err) {
         // Timeout is a hang, not "already ready" — fail closed so we do not burn another 20s on merge.
         if (isGhTimeoutError(err)) {
-            return { ok: false, reason: ghErrorReason(err, "gh pr ready failed") };
+            return { ok: false, reason: ghErrorReason(err, "gh pr ready failed", cwd) };
+        }
+        // Bad cwd / missing gh on the ready step would also fail merge — surface now.
+        const spawnReason = ghSpawnEnoentReason(err, cwd);
+        if (spawnReason) {
+            return { ok: false, reason: spawnReason };
         }
         // Already ready / not a draft — ignore; merge is the authority.
     }
@@ -65,7 +129,7 @@ export const realMergePr = async ({ cwd, number }) => {
         return { ok: true };
     }
     catch (err) {
-        const reason = ghErrorReason(err, "gh pr merge failed");
+        const reason = ghErrorReason(err, "gh pr merge failed", cwd);
         // Crash between a successful merge and the done-transition: retry must not escalate.
         if (ALREADY_MERGED.test(reason))
             return { ok: true };
@@ -118,7 +182,11 @@ async function finalizeAutoMergeOnce(issueId) {
     if (issue.prNumber == null) {
         return escalateMergeFailure(issue, instance.id, "Reviewer approved but the issue has no PR number to merge.");
     }
-    const merge = await mergePrImpl({ cwd: issue.repo, number: issue.prNumber });
+    const resolvedCwd = resolveAutoMergeCwd(issue.repo);
+    if (!resolvedCwd.ok) {
+        return escalateMergeFailure(issue, instance.id, `Auto-merge failed: ${resolvedCwd.reason}`);
+    }
+    const merge = await mergePrImpl({ cwd: resolvedCwd.cwd, number: issue.prNumber });
     if (!merge.ok) {
         return escalateMergeFailure(issue, instance.id, `Auto-merge failed: ${merge.reason}`);
     }