agent-dealer 1.0.2 → 1.0.4

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

@@ -2,10 +2,18 @@
 //
 // 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.
+//
+// NOT-159: always-on per-operation success/error counters + last rate-limit headers,
+// so a burn to requests-remaining=0 is diagnosable without enabling per-call trace.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 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;
+/** How often to emit a `[linear-usage]` summary when traffic > 0 since the last line. */
+export const LINEAR_USAGE_SUMMARY_INTERVAL_MS = 60_000;
 export class LinearHttpError extends Error {
     status;
     operation;
@@ -102,6 +110,179 @@ function isGraphqlRateLimited(errors) {
         return ext?.code === "RATELIMITED";
     });
 }
+let usageSinceMs = Date.now();
+const usageByOp = new Map();
+let lastRateLimit = null;
+let lastOperation = null;
+let lastAtMs = null;
+let usageSummaryTimer = null;
+let loggedTotalAtLastSummary = 0;
+/** Tests redirect the durable log; null = default under AGENT_DEALER_HOME/logs. */
+let usageLogPathOverride = null;
+/** `$AGENT_DEALER_HOME/logs/linear-usage.jsonl` — one line per call + minute summaries. */
+export function getLinearUsageLogPath() {
+    if (usageLogPathOverride)
+        return usageLogPathOverride;
+    const home = process.env.AGENT_DEALER_HOME ?? path.join(os.homedir(), ".agent-dealer");
+    return path.join(home, "logs", "linear-usage.jsonl");
+}
+export function setLinearUsageLogPathForTests(p) {
+    usageLogPathOverride = p;
+}
+function appendUsageLog(record) {
+    try {
+        const logPath = getLinearUsageLogPath();
+        fs.mkdirSync(path.dirname(logPath), { recursive: true });
+        fs.appendFileSync(logPath, `${JSON.stringify(record)}\n`);
+    }
+    catch (err) {
+        // Observability must never break Linear calls.
+        console.error("[linear-usage] failed to append log", err);
+    }
+}
+function bumpUsage(operation, kind, rateLimit) {
+    let bucket = usageByOp.get(operation);
+    if (!bucket) {
+        bucket = { ok: 0, error: 0 };
+        usageByOp.set(operation, bucket);
+    }
+    bucket[kind] += 1;
+    lastOperation = operation;
+    lastAtMs = Date.now();
+    if (rateLimit)
+        lastRateLimit = { ...rateLimit };
+    appendUsageLog({
+        ts: new Date(lastAtMs).toISOString(),
+        kind: "call",
+        op: operation,
+        ok: kind === "ok",
+        pid: process.pid,
+        requestsRemaining: rateLimit?.requestsRemaining ?? null,
+        requestsReset: rateLimit?.requestsReset ?? null,
+        requestsLimit: rateLimit?.requestsLimit ?? null,
+    });
+    ensureUsageSummaryTimer();
+}
+function usageTotals() {
+    let ok = 0;
+    let error = 0;
+    for (const b of usageByOp.values()) {
+        ok += b.ok;
+        error += b.error;
+    }
+    return { ok, error };
+}
+/** Process-lifetime counters for every GraphQL op that went through {@link linearGraphqlRequest}. */
+export function getLinearUsageSnapshot() {
+    const byOperation = {};
+    for (const [op, b] of [...usageByOp.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+        byOperation[op] = { ok: b.ok, error: b.error };
+    }
+    const totals = usageTotals();
+    return {
+        since: new Date(usageSinceMs).toISOString(),
+        totalOk: totals.ok,
+        totalError: totals.error,
+        byOperation,
+        lastRateLimit: lastRateLimit ? { ...lastRateLimit } : null,
+        lastOperation,
+        lastAt: lastAtMs != null ? new Date(lastAtMs).toISOString() : null,
+        logPath: getLinearUsageLogPath(),
+    };
+}
+export function resetLinearUsageForTests() {
+    usageByOp.clear();
+    lastRateLimit = null;
+    lastOperation = null;
+    lastAtMs = null;
+    usageSinceMs = Date.now();
+    loggedTotalAtLastSummary = 0;
+    usageLogPathOverride = null;
+    stopLinearUsageSummary();
+}
+function formatUsageSummaryLine() {
+    const snap = getLinearUsageSnapshot();
+    const parts = Object.entries(snap.byOperation).map(([op, c]) => `${op}:${c.ok}/${c.error}`);
+    const rl = snap.lastRateLimit;
+    const bits = [
+        "[linear-usage]",
+        `ok=${snap.totalOk}`,
+        `error=${snap.totalError}`,
+        parts.length ? `ops=${parts.join(",")}` : null,
+        rl?.requestsRemaining != null ? `requests-remaining=${rl.requestsRemaining}` : null,
+        rl?.requestsLimit != null ? `requests-limit=${rl.requestsLimit}` : null,
+        rl?.requestsReset != null ? `requests-reset=${rl.requestsReset}` : null,
+        snap.lastOperation ? `last=${snap.lastOperation}` : null,
+    ].filter(Boolean);
+    return bits.join(" ");
+}
+function maybeLogUsageSummary() {
+    const totals = usageTotals();
+    const total = totals.ok + totals.error;
+    if (total <= loggedTotalAtLastSummary)
+        return;
+    loggedTotalAtLastSummary = total;
+    console.error(formatUsageSummaryLine());
+    const snap = getLinearUsageSnapshot();
+    appendUsageLog({
+        ts: new Date().toISOString(),
+        kind: "summary",
+        pid: process.pid,
+        totalOk: snap.totalOk,
+        totalError: snap.totalError,
+        byOperation: snap.byOperation,
+        requestsRemaining: snap.lastRateLimit?.requestsRemaining ?? null,
+        requestsReset: snap.lastRateLimit?.requestsReset ?? null,
+    });
+}
+function ensureUsageSummaryTimer() {
+    if (usageSummaryTimer)
+        return;
+    usageSummaryTimer = setInterval(maybeLogUsageSummary, LINEAR_USAGE_SUMMARY_INTERVAL_MS);
+    // Do not keep the process alive solely for the summary ticker.
+    if (typeof usageSummaryTimer === "object" && "unref" in usageSummaryTimer) {
+        usageSummaryTimer.unref();
+    }
+}
+/** Start the once-per-minute summary logger (idempotent). Called from server boot. */
+export function startLinearUsageSummary() {
+    ensureUsageSummaryTimer();
+    appendUsageLog({
+        ts: new Date().toISOString(),
+        kind: "boot",
+        pid: process.pid,
+        since: new Date(usageSinceMs).toISOString(),
+        logPath: getLinearUsageLogPath(),
+    });
+}
+export function stopLinearUsageSummary() {
+    if (!usageSummaryTimer)
+        return;
+    clearInterval(usageSummaryTimer);
+    usageSummaryTimer = null;
+}
+/** Set `AGENT_DEALER_LINEAR_TRACE=1` to log every GraphQL call (success + failure). */
+function linearTraceEnabled() {
+    const v = process.env.AGENT_DEALER_LINEAR_TRACE?.trim().toLowerCase();
+    return v === "1" || v === "true" || v === "yes";
+}
+let linearTraceSeq = 0;
+function logLinearTrace(operation, status, rateLimit) {
+    if (!linearTraceEnabled())
+        return;
+    linearTraceSeq += 1;
+    const bits = [
+        `[linear-trace] #${linearTraceSeq}`,
+        `operation=${operation}`,
+        `status=${status}`,
+        rateLimit.requestsRemaining != null ? `requests-remaining=${rateLimit.requestsRemaining}` : null,
+        rateLimit.requestsLimit != null ? `requests-limit=${rateLimit.requestsLimit}` : null,
+        rateLimit.complexityRemaining != null
+            ? `complexity-remaining=${rateLimit.complexityRemaining}`
+            : null,
+    ].filter(Boolean);
+    console.error(bits.join(" "));
+}
 /**
  * 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.
@@ -110,18 +291,27 @@ 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) } : {}),
-    });
+    let res;
+    try {
+        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) } : {}),
+        });
+    }
+    catch (err) {
+        bumpUsage(opts.operation, "error");
+        throw err;
+    }
     const rateLimit = parseLinearRateLimitHeaders(res.headers instanceof Headers ? res.headers : new Headers());
+    logLinearTrace(opts.operation, res.status, rateLimit);
     const rawBody = typeof res.text === "function"
         ? await res.text()
         : JSON.stringify(await res.json());
     const bodySnippet = truncateBody(rawBody);
     if (!res.ok) {
+        bumpUsage(opts.operation, "error", rateLimit);
         const err = new LinearHttpError({
             status: res.status,
             operation: opts.operation,
@@ -137,6 +327,7 @@ export async function linearGraphqlRequest(opts) {
         json = JSON.parse(rawBody);
     }
     catch {
+        bumpUsage(opts.operation, "error", rateLimit);
         const err = new LinearHttpError({
             status: res.status,
             operation: opts.operation,
@@ -149,6 +340,7 @@ export async function linearGraphqlRequest(opts) {
     }
     if (json.errors?.length) {
         if (isGraphqlRateLimited(json.errors) || rateLimit.requestsRemaining === "0") {
+            bumpUsage(opts.operation, "error", rateLimit);
             const err = new LinearHttpError({
                 status: 429,
                 operation: opts.operation,
@@ -159,7 +351,9 @@ export async function linearGraphqlRequest(opts) {
             console.error(formatLinearFailureLog(err));
             throw err;
         }
+        bumpUsage(opts.operation, "error", rateLimit);
         throw new Error(JSON.stringify(json.errors));
     }
+    bumpUsage(opts.operation, "ok", rateLimit);
     return json.data;
 }

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

@@ -4,7 +4,7 @@
 // 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");
+const { LinearHttpError, computeRetryAfterMs, getLinearUsageLogPath, getLinearUsageSnapshot, linearGraphqlRequest, parseLinearRateLimitHeaders, resetLinearUsageForTests, setLinearUsageLogPathForTests, } = await import("./linear-graphql.js");
 test("parseLinearRateLimitHeaders reads requests + complexity headers", () => {
     const headers = new Headers({
         "X-RateLimit-Requests-Limit": "2500",
@@ -45,6 +45,7 @@ test("computeRetryAfterMs falls back to Retry-After seconds when reset missing",
 });
 test("linearGraphqlRequest logs HTTP status and rate-limit headers on non-OK", async () => {
     process.env.LINEAR_API_KEY = "lin_test";
+    resetLinearUsageForTests();
     const errors = [];
     const errorMock = mock.method(console, "error", (...args) => {
         errors.push(args);
@@ -78,10 +79,99 @@ test("linearGraphqlRequest logs HTTP status and rate-limit headers on non-OK", a
         assert.match(joined, /429/);
         assert.match(joined, /requests-remaining[=:]?\s*0/i);
         assert.match(joined, /requests-reset[=:]?\s*1760000045000/i);
+        const usage = getLinearUsageSnapshot();
+        assert.equal(usage.byOperation.listLinearCandidates?.error, 1);
+        assert.equal(usage.byOperation.listLinearCandidates?.ok, 0);
+        assert.equal(usage.lastRateLimit?.requestsRemaining, "0");
     }
     finally {
         errorMock.mock.restore();
         fetchMock.mock.restore();
+        resetLinearUsageForTests();
+    }
+});
+test("NOT-159: successful GraphQL increments ok counter and last requests-remaining", async () => {
+    process.env.LINEAR_API_KEY = "lin_test";
+    resetLinearUsageForTests();
+    const fs = await import("node:fs");
+    const os = await import("node:os");
+    const path = await import("node:path");
+    const logPath = path.join(fs.mkdtempSync(path.join(os.tmpdir(), "lin-usage-")), "linear-usage.jsonl");
+    setLinearUsageLogPathForTests(logPath);
+    const fetchMock = mock.method(globalThis, "fetch", async () => {
+        return new Response(JSON.stringify({ data: { viewer: { id: "u1" } } }), {
+            status: 200,
+            headers: {
+                "Content-Type": "application/json",
+                "X-RateLimit-Requests-Remaining": "2497",
+                "X-RateLimit-Requests-Limit": "2500",
+                "X-RateLimit-Requests-Reset": "1760000100000",
+            },
+        });
+    });
+    try {
+        const data = await linearGraphqlRequest({
+            operation: "getLinearViewer",
+            query: "query { viewer { id } }",
+        });
+        assert.deepEqual(data, { viewer: { id: "u1" } });
+        const usage = getLinearUsageSnapshot();
+        assert.equal(usage.totalOk, 1);
+        assert.equal(usage.totalError, 0);
+        assert.equal(usage.byOperation.getLinearViewer?.ok, 1);
+        assert.equal(usage.lastOperation, "getLinearViewer");
+        assert.equal(usage.lastRateLimit?.requestsRemaining, "2497");
+        assert.equal(usage.lastRateLimit?.requestsLimit, "2500");
+        assert.equal(usage.logPath, logPath);
+        assert.equal(getLinearUsageLogPath(), logPath);
+        const lines = fs.readFileSync(logPath, "utf8").trim().split("\n");
+        assert.equal(lines.length, 1);
+        const row = JSON.parse(lines[0]);
+        assert.equal(row.kind, "call");
+        assert.equal(row.op, "getLinearViewer");
+        assert.equal(row.ok, true);
+        assert.equal(row.requestsRemaining, "2497");
+    }
+    finally {
+        fetchMock.mock.restore();
+        resetLinearUsageForTests();
+    }
+});
+test("NOT-159: counters accumulate per operation across success and failure", async () => {
+    process.env.LINEAR_API_KEY = "lin_test";
+    resetLinearUsageForTests();
+    let n = 0;
+    const fetchMock = mock.method(globalThis, "fetch", async () => {
+        n += 1;
+        if (n === 2) {
+            return new Response("nope", {
+                status: 502,
+                headers: { "X-RateLimit-Requests-Remaining": "9" },
+            });
+        }
+        return new Response(JSON.stringify({ data: { ok: true } }), {
+            status: 200,
+            headers: {
+                "Content-Type": "application/json",
+                "X-RateLimit-Requests-Remaining": String(11 - n),
+            },
+        });
+    });
+    const errorMock = mock.method(console, "error", () => { });
+    try {
+        await linearGraphqlRequest({ operation: "fetchLinearBlockers", query: "query { a }" });
+        await assert.rejects(() => linearGraphqlRequest({ operation: "fetchLinearBlockers", query: "query { a }" }));
+        await linearGraphqlRequest({ operation: "listLinearCandidates", query: "query { b }" });
+        const usage = getLinearUsageSnapshot();
+        assert.deepEqual(usage.byOperation.fetchLinearBlockers, { ok: 1, error: 1 });
+        assert.deepEqual(usage.byOperation.listLinearCandidates, { ok: 1, error: 0 });
+        assert.equal(usage.totalOk, 2);
+        assert.equal(usage.totalError, 1);
+    }
+    finally {
+        errorMock.mock.restore();
+        fetchMock.mock.restore();
+        resetLinearUsageForTests();
     }
 });
 test("listLinearCandidates leaves a [linear] log line on HTTP 502 (intake path)", async () => {

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

@@ -55,36 +55,47 @@ function listOccupyingIssues() {
     return listIssues([...occupyingStatuses]).map((i) => ({ id: i.id, status: i.status }));
 }
 let healthChecker = null;
-/** Tests inject a pure checker so admission does not hit real CLIs. */
+/** Tests inject a pure checker so admission / pre-spawn health do not hit real CLIs. */
 export function setAdmissionHealthCheckerForTests(checker) {
     healthChecker = checker;
 }
-async function defaultAgentHealth(agent, deckOnline) {
+async function defaultAgentHealth(agent, role, deckOnline) {
+    // Unit/CI tests must not call real CLIs / Agent Deck — runners usually have no deck MCP.
+    // Production leaves this unset. NOT-133 clears it so the real auth classifier still runs.
+    if (process.env.AGENT_DEALER_SKIP_AGENT_HEALTH === "1") {
+        return { ok: true };
+    }
     const health = await healthForAgent(agent, deckOnline);
     // usage_capped is owned by runtimeAvailable — keep agentsHealthy for CLI/workspace/deck.
     const nonCap = health.issues.filter((i) => i.code !== "usage_capped");
     if (nonCap.length > 0) {
         return {
             ok: false,
-            reason: `agent unhealthy: ${agent.name} — ${nonCap.map((i) => i.message).join("; ")}`,
+            // NOT-156: name the role so a parked review is not read as a blocked developer admit.
+            reason: `${role} unhealthy: ${agent.name} — ${nonCap.map((i) => i.message).join("; ")}`,
         };
     }
     return { ok: true };
 }
+/**
+ * Fail-closed health for one role (NOT-156). Admission checks the role about to start
+ * (developer for `startWorkflowCore`); the worker loop re-checks the leased item's role
+ * before spawn so a later reviewer round parks without burning infra when only the
+ * reviewer is unhealthy.
+ */
+export async function checkRoleAgentHealthy(issue, role, ctx) {
+    const agentId = role === "developer" ? issue.developerAgentId : issue.reviewerAgentId;
+    if (!agentId)
+        return { ok: false, reason: `missing ${role} agent` };
+    const agent = getAgent(agentId);
+    if (!agent)
+        return { ok: false, reason: `${role} agent not found` };
+    const check = healthChecker ?? ((a, r) => defaultAgentHealth(a, r, ctx.deckOnline));
+    return check(agent, role);
+}
 async function checkAgentsHealthy(issue, ctx) {
-    const check = healthChecker ?? ((agent) => defaultAgentHealth(agent, ctx.deckOnline));
-    for (const role of ["developer", "reviewer"]) {
-        const agentId = role === "developer" ? issue.developerAgentId : issue.reviewerAgentId;
-        if (!agentId)
-            return { ok: false, reason: `missing ${role} agent` };
-        const agent = getAgent(agentId);
-        if (!agent)
-            return { ok: false, reason: `${role} agent not found` };
-        const result = await check(agent);
-        if (!result.ok)
-            return result;
-    }
-    return { ok: true };
+    // Admit always starts a developer round — do not require reviewer health yet (NOT-156).
+    return checkRoleAgentHealthy(issue, "developer", ctx);
 }
 /**
  * Status must be startable (`ready`, or `needs_human` with no active workflow) and
@@ -107,20 +118,20 @@ function issueReadinessRule(issue) {
     return { ok: true };
 }
 function runtimeAvailableRule(issue) {
-    for (const role of ["developer", "reviewer"]) {
-        const agentId = role === "developer" ? issue.developerAgentId : issue.reviewerAgentId;
-        if (!agentId)
-            continue;
-        const agent = getAgent(agentId);
-        if (!agent)
-            continue;
-        const avail = runtimeAvailability(agent.runtime);
-        if (!avail.available) {
-            return {
-                ok: false,
-                reason: `runtime capped: ${agent.runtime} until ${avail.until} (${avail.reason})`,
-            };
-        }
+    // NOT-156: only the developer runtime gates admit; reviewer caps are enforced at lease
+    // time in the worker loop (same place as role health for the active work item).
+    const agentId = issue.developerAgentId;
+    if (!agentId)
+        return { ok: true };
+    const agent = getAgent(agentId);
+    if (!agent)
+        return { ok: true };
+    const avail = runtimeAvailability(agent.runtime);
+    if (!avail.available) {
+        return {
+            ok: false,
+            reason: `runtime capped: ${agent.runtime} until ${avail.until} (${avail.reason})`,
+        };
     }
     return { ok: true };
 }

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

@@ -310,7 +310,10 @@ test("NOT-133: a logged-out Cursor runtime is not admitted; it waits with an aut
     fs.writeFileSync(stub, `#!/bin/sh\ncat ${JSON.stringify(fixture)}\nexit 0\n`);
     fs.chmodSync(stub, 0o755);
     const prev = process.env.CURSOR_CLI;
+    const prevSkipHealth = process.env.AGENT_DEALER_SKIP_AGENT_HEALTH;
     process.env.CURSOR_CLI = stub;
+    // Real classifier path — must not short-circuit via the unit-test skip.
+    delete process.env.AGENT_DEALER_SKIP_AGENT_HEALTH;
     setAdmissionHealthCheckerForTests(null);
     clearAgentHealthCaches();
     try {
@@ -323,7 +326,7 @@ test("NOT-133: a logged-out Cursor runtime is not admitted; it waits with an aut
         assert.equal(getActiveWorkflowInstance(issue.id), null);
         const entry = getQueuedEntryForIssue(issue.id);
         assert.equal(entry?.state, "queued");
-        assert.match(entry.waitReason, /agent unhealthy/);
+        assert.match(entry.waitReason, /developer unhealthy/);
         assert.match(entry.waitReason, /not authenticated/i);
         assert.match(entry.waitReason, /cursor-agent login/);
     }
@@ -332,6 +335,94 @@ test("NOT-133: a logged-out Cursor runtime is not admitted; it waits with an aut
             delete process.env.CURSOR_CLI;
         else
             process.env.CURSOR_CLI = prev;
+        if (prevSkipHealth === undefined)
+            delete process.env.AGENT_DEALER_SKIP_AGENT_HEALTH;
+        else
+            process.env.AGENT_DEALER_SKIP_AGENT_HEALTH = prevSkipHealth;
+        clearAgentHealthCaches();
+        setAdmissionHealthCheckerForTests(async () => ({ ok: true }));
+    }
+});
+// NOT-156: reviewer health must not block developer admit; developer health still fails closed.
+test("NOT-156: developer healthy + reviewer unhealthy still admits and leases developer work", async () => {
+    const { listWorkItemsForIssue } = await import("../repository/work-items.js");
+    const issue = readyIssue("rev-unhealthy");
+    setAdmissionHealthCheckerForTests(async (_agent, role) => {
+        if (role === "reviewer") {
+            return {
+                ok: false,
+                reason: `reviewer unhealthy: ${_agent.name} — Run agent-deck setup --client claude --start (Claude MCP not registered)`,
+            };
+        }
+        return { ok: true };
+    });
+    enqueueIssue(issue.id);
+    const result = await admitNext();
+    assert.equal(result?.issueId, issue.id);
+    assert.equal(getIssue(issue.id).status, "developing");
+    assert.ok(getActiveWorkflowInstance(issue.id));
+    const developerItems = listWorkItemsForIssue(issue.id).filter((w) => w.kind === "developer");
+    assert.equal(developerItems.length, 1);
+    assert.equal(developerItems[0].status, "pending");
+});
+test("NOT-156: developer unhealthy + reviewer healthy parks with a developer-named wait_reason", async () => {
+    const issue = readyIssue("dev-unhealthy");
+    setAdmissionHealthCheckerForTests(async (_agent, role) => {
+        if (role === "developer") {
+            return {
+                ok: false,
+                reason: `developer unhealthy: ${_agent.name} — not authenticated — run cursor-agent login`,
+            };
+        }
+        return { ok: true };
+    });
+    enqueueIssue(issue.id);
+    assert.equal(await admitNext(), null);
+    assert.equal(getIssue(issue.id).status, "ready");
+    assert.equal(getActiveWorkflowInstance(issue.id), null);
+    const entry = getQueuedEntryForIssue(issue.id);
+    assert.equal(entry.state, "queued");
+    assert.match(entry.waitReason ?? "", /developer unhealthy/);
+    assert.doesNotMatch(entry.waitReason ?? "", /reviewer unhealthy/);
+});
+// NOT-157: soft probe failure wait_reason must name the probe, not "not authenticated".
+test("NOT-157: soft Cursor probe timeout waits with probe-timeout reason, not logged-out copy", async () => {
+    const { clearAgentHealthCaches, setCursorProbeTimingForTests, } = await import("../adapters/agent-health.js");
+    // Real hang stub (same style as NOT-133) so this file does not share runCommand inject
+    // state with agent-health.test.ts when the suite runs files in parallel.
+    const stubDir = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-cursor-timeout-"));
+    const stub = path.join(stubDir, "cursor-agent");
+    fs.writeFileSync(stub, "#!/bin/sh\nsleep 30\n");
+    fs.chmodSync(stub, 0o755);
+    const prev = process.env.CURSOR_CLI;
+    const prevSkipHealth = process.env.AGENT_DEALER_SKIP_AGENT_HEALTH;
+    process.env.CURSOR_CLI = stub;
+    delete process.env.AGENT_DEALER_SKIP_AGENT_HEALTH;
+    setCursorProbeTimingForTests({ timeoutMs: 150, retryBackoffsMs: [20] });
+    setAdmissionHealthCheckerForTests(null);
+    clearAgentHealthCaches();
+    try {
+        const issue = readyIssue("cursor-probe-timeout", {
+            runtimes: { dev: "cursor_local", rev: "cursor_local" },
+        });
+        enqueueIssue(issue.id);
+        assert.equal(await admitNext(), null);
+        const entry = getQueuedEntryForIssue(issue.id);
+        assert.equal(entry?.state, "queued");
+        assert.match(entry.waitReason, /developer unhealthy/);
+        assert.match(entry.waitReason, /probe timed out/i);
+        assert.doesNotMatch(entry.waitReason, /not authenticated/i);
+    }
+    finally {
+        if (prev === undefined)
+            delete process.env.CURSOR_CLI;
+        else
+            process.env.CURSOR_CLI = prev;
+        if (prevSkipHealth === undefined)
+            delete process.env.AGENT_DEALER_SKIP_AGENT_HEALTH;
+        else
+            process.env.AGENT_DEALER_SKIP_AGENT_HEALTH = prevSkipHealth;
+        setCursorProbeTimingForTests(null);
         clearAgentHealthCaches();
         setAdmissionHealthCheckerForTests(async () => ({ ok: true }));
     }