agent-dealer 1.0.2 → 1.0.4

package/bundle/server/dist/adapters/agent-deck.js

@@ -154,34 +154,89 @@ export async function updatePlaybookBody(playbookId, body) {
 export function readClaudeMcpConfigPath() {
     return process.env.CLAUDE_MCP_CONFIG ?? path.join(process.env.HOME ?? "", ".claude.json");
 }
-export function isAgentDeckMcpRegistered() {
+function expectedAgentDeckMcpEndpoint() {
+    const expected = new URL(getAgentDeckMcpUrl().replace(/\/mcp\/?$/, "") + "/mcp");
+    const port = expected.port || (expected.protocol === "https:" ? "443" : "80");
+    return { hostname: expected.hostname, port };
+}
+function isAgentDeckMcpServerName(name) {
+    const lower = name.toLowerCase();
+    return lower.includes("agent-deck") || name === "agent-deck";
+}
+/** Basename of `agent-deck` (PATH lookup or absolute install path). */
+function commandInvokesAgentDeck(command) {
+    if (!command?.trim())
+        return false;
+    const base = path.basename(command.trim()).replace(/\.(cmd|exe|bat)$/i, "");
+    return base === "agent-deck";
+}
+function argsIncludeMcpLaunch(args) {
+    return Array.isArray(args) && args.some((a) => a === "mcp-launch");
+}
+/**
+ * Classify Claude MCP config for Agent Deck.
+ * Accepts legacy HTTP `url` entries and current `agent-deck mcp-launch` stdio + env ports
+ * from `agent-deck setup --client claude`.
+ */
+export function checkAgentDeckMcpRegistration() {
     try {
         const configPath = readClaudeMcpConfigPath();
         if (!fs.existsSync(configPath))
-            return false;
+            return { status: "missing" };
         const raw = fs.readFileSync(configPath, "utf8");
         const config = JSON.parse(raw);
-        const expected = new URL(getAgentDeckMcpUrl().replace(/\/mcp\/?$/, "") + "/mcp");
+        const expected = expectedAgentDeckMcpEndpoint();
+        let mismatch = null;
         for (const [name, server] of Object.entries(config.mcpServers ?? {})) {
-            if (!name.toLowerCase().includes("agent-deck") && name !== "agent-deck")
+            if (!isAgentDeckMcpServerName(name))
                 continue;
-            if (!server.url)
+            if (server.url) {
+                try {
+                    const u = new URL(server.url);
+                    const foundPort = u.port || (u.protocol === "https:" ? "443" : "80");
+                    if (u.hostname === expected.hostname && foundPort === expected.port) {
+                        return { status: "registered" };
+                    }
+                    mismatch = {
+                        status: "endpoint_mismatch",
+                        expectedHost: expected.hostname,
+                        expectedPort: expected.port,
+                        foundHost: u.hostname,
+                        foundPort,
+                    };
+                }
+                catch {
+                    // skip invalid url
+                }
                 continue;
-            try {
-                const u = new URL(server.url);
-                if (u.hostname === expected.hostname && u.port === expected.port)
-                    return true;
             }
-            catch {
-                // skip invalid url
+            // Current Claude setup: stdio `agent-deck mcp-launch` with AGENT_DECK_* env.
+            if (commandInvokesAgentDeck(server.command) && argsIncludeMcpLaunch(server.args)) {
+                const foundHost = server.env?.AGENT_DECK_HOST?.trim() || "127.0.0.1";
+                const foundPort = server.env?.AGENT_DECK_MCP_PORT?.trim() ?? "";
+                if (foundHost === expected.hostname && foundPort === expected.port) {
+                    return { status: "registered" };
+                }
+                mismatch = {
+                    status: "endpoint_mismatch",
+                    expectedHost: expected.hostname,
+                    expectedPort: expected.port,
+                    foundHost,
+                    foundPort: foundPort || "(missing)",
+                };
             }
         }
-        return false;
+        if (mismatch)
+            return mismatch;
+        return { status: "missing" };
     }
     catch {
-        return false;
+        return { status: "missing" };
     }
 }
+export function isAgentDeckMcpRegistered() {
+    return checkAgentDeckMcpRegistration().status === "registered";
+}
 /** Map PRD toolCall to deck MCP call_service_tool args (serviceName → serviceId). */
 export function toCallServiceToolPayload(toolCall) {
     return {

package/bundle/server/dist/adapters/agent-deck.test.js

@@ -8,8 +8,30 @@ import os from "node:os";
 import path from "node:path";
 process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-agentdeck-"));
 const { migrate } = await import("../db/index.js");
-const { fetchDecks, fetchAuthorizedDecks } = await import("./agent-deck.js");
+const { fetchDecks, fetchAuthorizedDecks, isAgentDeckMcpRegistered, checkAgentDeckMcpRegistration, } = await import("./agent-deck.js");
 migrate();
+function writeClaudeMcpFixture(mcpServers) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "claude-mcp-"));
+    const configPath = path.join(dir, ".claude.json");
+    fs.writeFileSync(configPath, JSON.stringify({ mcpServers }, null, 2));
+    return configPath;
+}
+function withClaudeMcpConfig(configPath, fn) {
+    const prev = process.env.CLAUDE_MCP_CONFIG;
+    if (configPath === null)
+        delete process.env.CLAUDE_MCP_CONFIG;
+    else
+        process.env.CLAUDE_MCP_CONFIG = configPath;
+    try {
+        return fn();
+    }
+    finally {
+        if (prev === undefined)
+            delete process.env.CLAUDE_MCP_CONFIG;
+        else
+            process.env.CLAUDE_MCP_CONFIG = prev;
+    }
+}
 test("fetchDecks returns decks on success from /api/launch/decks", async () => {
     let capturedUrl = "";
     const fetchMock = mock.method(globalThis, "fetch", async (url, init) => {
@@ -61,3 +83,71 @@ test("fetchDecks reports DECK_UNAVAILABLE on a network error, never an empty lis
 test("fetchAuthorizedDecks is an alias of fetchDecks", () => {
     assert.equal(fetchAuthorizedDecks, fetchDecks);
 });
+// Default Agent Deck MCP endpoint under a fresh AGENT_DEALER_HOME is 127.0.0.1:1110
+// (API port 1111 − 1). Fixtures below match that unless noted.
+test("isAgentDeckMcpRegistered: stdio mcp-launch with matching env is registered (no url)", () => {
+    const configPath = writeClaudeMcpFixture({
+        "agent-deck": {
+            type: "stdio",
+            command: "agent-deck",
+            args: ["mcp-launch"],
+            env: { AGENT_DECK_MCP_PORT: "1110", AGENT_DECK_HOST: "127.0.0.1" },
+        },
+    });
+    withClaudeMcpConfig(configPath, () => {
+        assert.equal(isAgentDeckMcpRegistered(), true);
+        assert.equal(checkAgentDeckMcpRegistration().status, "registered");
+    });
+});
+test("isAgentDeckMcpRegistered: legacy HTTP url with matching host/port is registered", () => {
+    const configPath = writeClaudeMcpFixture({
+        "agent-deck": { url: "http://127.0.0.1:1110/mcp" },
+    });
+    withClaudeMcpConfig(configPath, () => {
+        assert.equal(isAgentDeckMcpRegistered(), true);
+    });
+});
+test("isAgentDeckMcpRegistered: missing entry returns false / missing", () => {
+    const configPath = writeClaudeMcpFixture({
+        other: { url: "http://127.0.0.1:9999/mcp" },
+    });
+    withClaudeMcpConfig(configPath, () => {
+        assert.equal(isAgentDeckMcpRegistered(), false);
+        assert.equal(checkAgentDeckMcpRegistration().status, "missing");
+    });
+});
+test("checkAgentDeckMcpRegistration: wrong stdio port is endpoint_mismatch, not registered", () => {
+    const configPath = writeClaudeMcpFixture({
+        "agent-deck": {
+            type: "stdio",
+            command: "agent-deck",
+            args: ["mcp-launch"],
+            env: { AGENT_DECK_MCP_PORT: "9999", AGENT_DECK_HOST: "127.0.0.1" },
+        },
+    });
+    withClaudeMcpConfig(configPath, () => {
+        assert.equal(isAgentDeckMcpRegistered(), false);
+        const result = checkAgentDeckMcpRegistration();
+        assert.equal(result.status, "endpoint_mismatch");
+        if (result.status === "endpoint_mismatch") {
+            assert.equal(result.expectedPort, "1110");
+            assert.equal(result.foundPort, "9999");
+            assert.equal(result.expectedHost, "127.0.0.1");
+            assert.equal(result.foundHost, "127.0.0.1");
+        }
+    });
+});
+test("isAgentDeckMcpRegistered: stdio without mcp-launch args is not registered", () => {
+    const configPath = writeClaudeMcpFixture({
+        "agent-deck": {
+            type: "stdio",
+            command: "agent-deck",
+            args: ["mcp"],
+            env: { AGENT_DECK_MCP_PORT: "1110", AGENT_DECK_HOST: "127.0.0.1" },
+        },
+    });
+    withClaudeMcpConfig(configPath, () => {
+        assert.equal(isAgentDeckMcpRegistered(), false);
+        assert.equal(checkAgentDeckMcpRegistration().status, "missing");
+    });
+});

package/bundle/server/dist/adapters/agent-health.js

@@ -1,7 +1,7 @@
 import { spawn, spawnSync } from "node:child_process";
 import { CODEX_AUTH_REMEDIATION, cursorAuthIssueFromOutput, runtimeAuthIssueFromOutput, } from "@agent-dealer/shared";
 import { claudeBinExists, cursorBinExists, resolveClaudeBin, cursorInvokeArgs, resolveCursorBin, resolveCodexBin, codexBinExists, } from "../cli-env.js";
-import { checkAgentDeckHealth, fetchDecks, isAgentDeckMcpRegistered } from "./agent-deck.js";
+import { checkAgentDeckHealth, checkAgentDeckMcpRegistration, fetchDecks, } from "./agent-deck.js";
 import { runtimeAvailability } from "../repository/runtime-availability.js";
 const RUNTIME_LABEL = {
     claude_code: "Claude",
@@ -21,23 +21,63 @@ function capHealthIssues(runtime) {
     ];
 }
 const RUNTIME_CACHE_MS = 60_000;
+/** Soft probe failures must not stick for the full health TTL — sleep/wake flakes recover on the next tick. */
+const SOFT_PROBE_CACHE_MS = 15_000;
+const DEFAULT_PROBE_TIMEOUT_MS = 8000;
+/** After the first soft fail, retry with these delays before publishing unconfirmed auth. */
+const DEFAULT_SOFT_RETRY_BACKOFFS_MS = [250, 750];
+/** Require this many consecutive soft-fail rounds (each round already retried) before flipping healthy→unhealthy. */
+const SOFT_FAIL_STREAK_TO_UNHEALTHY = 2;
+/** Hold a recent healthy result across a single soft-fail streak after host sleep. */
+const HEALTHY_GRACE_MS = 5 * 60_000;
 const runtimeIssueCache = new Map();
 let githubIssueCache = null;
-/** Exported for tests — clears the shared github + runtime health caches. */
-export function clearAgentHealthCaches() {
-    runtimeIssueCache.clear();
-    githubIssueCache = null;
+/** Cursor soft-fail streak across health ticks (NOT-157). Reset on hard auth or success. */
+let cursorSoftFailStreak = 0;
+let cursorLastHealthyAt = null;
+let probeTimeoutMsForTests = null;
+let softRetryBackoffsMsForTests = null;
+/**
+ * Shorten probe timeout / retry backoff in unit tests so sleep-stub scenarios stay fast.
+ * Pass `null` to restore production defaults.
+ */
+export function setCursorProbeTimingForTests(opts) {
+    if (opts == null) {
+        probeTimeoutMsForTests = null;
+        softRetryBackoffsMsForTests = null;
+        return;
+    }
+    probeTimeoutMsForTests = opts.timeoutMs === undefined ? probeTimeoutMsForTests : opts.timeoutMs;
+    softRetryBackoffsMsForTests =
+        opts.retryBackoffsMs === undefined ? softRetryBackoffsMsForTests : opts.retryBackoffsMs;
+}
+function probeTimeoutMs() {
+    return probeTimeoutMsForTests ?? DEFAULT_PROBE_TIMEOUT_MS;
 }
-function runCommand(cmd, args, timeoutMs = 8000) {
+function softRetryBackoffsMs() {
+    return softRetryBackoffsMsForTests ?? DEFAULT_SOFT_RETRY_BACKOFFS_MS;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function defaultRunCommand(cmd, args, timeoutMs = DEFAULT_PROBE_TIMEOUT_MS) {
     return new Promise((resolve) => {
         const child = spawn(cmd, args, {
             stdio: ["ignore", "pipe", "pipe"],
             env: process.env,
         });
         let output = "";
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(result);
+        };
         const timer = setTimeout(() => {
             child.kill("SIGTERM");
-            resolve({ ok: false, output: output || "timeout" });
+            finish({ ok: false, output: output || "timeout", timedOut: true });
         }, timeoutMs);
         child.stdout?.on("data", (d) => {
             output += d.toString();
@@ -46,15 +86,102 @@ function runCommand(cmd, args, timeoutMs = 8000) {
             output += d.toString();
         });
         child.on("error", (err) => {
-            clearTimeout(timer);
-            resolve({ ok: false, output: err.message });
+            finish({ ok: false, output: err.message, timedOut: false });
         });
         child.on("close", (code) => {
-            clearTimeout(timer);
-            resolve({ ok: code === 0, output });
+            finish({ ok: code === 0, output, timedOut: false });
         });
     });
 }
+let runCommandImpl = defaultRunCommand;
+/**
+ * Replace the process spawner in unit tests (sequence injection for soft-fail / timeout).
+ * Pass `null` to restore the real spawner.
+ */
+export function setRunCommandForTests(fn) {
+    runCommandImpl = fn ?? defaultRunCommand;
+}
+function runCommand(cmd, args, timeoutMs = DEFAULT_PROBE_TIMEOUT_MS) {
+    return runCommandImpl(cmd, args, timeoutMs);
+}
+/** Exported for tests — clears the shared github + runtime health caches and soft-fail streak. */
+export function clearAgentHealthCaches() {
+    runtimeIssueCache.clear();
+    githubIssueCache = null;
+    cursorSoftFailStreak = 0;
+    cursorLastHealthyAt = null;
+}
+function isSoftCursorProbeIssue(issue) {
+    return (issue.code === "runtime_auth" &&
+        (/probe timed out/i.test(issue.message) || /probe failed/i.test(issue.message)));
+}
+function softCursorProbeIssue(result) {
+    if (result.timedOut || result.output.trim() === "timeout") {
+        return {
+            code: "runtime_auth",
+            message: "Could not confirm Cursor auth — `cursor-agent status` probe timed out",
+        };
+    }
+    const detail = result.output.trim().split("\n").slice(-1)[0] ?? "no output";
+    return {
+        code: "runtime_auth",
+        message: `Could not confirm Cursor auth — \`cursor-agent status\` probe failed (${detail})`,
+    };
+}
+/**
+ * NOT-157: classified logged-out / keychain is a hard fail (immediate). Probe timeout /
+ * unclassified non-zero exit is soft — retry with backoff, and do not flip a recent healthy
+ * result on a single soft-fail streak after host sleep.
+ */
+async function cursorRuntimeIssues() {
+    const backoffs = softRetryBackoffsMs();
+    const attempts = 1 + backoffs.length;
+    let last = { ok: false, output: "no probe", timedOut: false };
+    for (let i = 0; i < attempts; i++) {
+        if (i > 0)
+            await sleep(backoffs[i - 1]);
+        last = await runCommand(resolveCursorBin(), cursorInvokeArgs(["status"]), probeTimeoutMs());
+        // A failed *spawn* resolves with the error message as its output (`spawn cursor-agent
+        // ENOENT`), not with empty output — so an absent binary must be recognised here or it
+        // falls through to the unconfirmed-auth branch below and names the wrong remedy.
+        if (!last.ok && (/\bENOENT\b/.test(last.output) || (!last.output.trim() && !cursorBinExists()))) {
+            cursorSoftFailStreak = 0;
+            cursorLastHealthyAt = null;
+            return [
+                {
+                    code: "cli_missing",
+                    message: "cursor-agent not found — run: curl https://cursor.com/install -fsS | bash",
+                },
+            ];
+        }
+        const authIssue = cursorAuthIssueFromOutput(last.output);
+        if (authIssue) {
+            cursorSoftFailStreak = 0;
+            cursorLastHealthyAt = null;
+            console.warn(`[agent-health] cursor-agent status: classified auth failure (${authIssue.code})`);
+            return [authIssue];
+        }
+        if (last.ok) {
+            cursorSoftFailStreak = 0;
+            cursorLastHealthyAt = Date.now();
+            return [];
+        }
+        // Soft fail this attempt — try again before publishing.
+        const kind = last.timedOut || last.output.trim() === "timeout" ? "timed out" : "failed";
+        console.warn(`[agent-health] cursor-agent status probe ${kind} (attempt ${i + 1}/${attempts})`);
+    }
+    // Retries exhausted with only soft failures.
+    cursorSoftFailStreak += 1;
+    const softIssue = softCursorProbeIssue(last);
+    const kind = last.timedOut || last.output.trim() === "timeout" ? "timed out" : "failed";
+    console.warn(`[agent-health] cursor-agent status probe ${kind} after retries (streak=${cursorSoftFailStreak})`);
+    const withinGrace = cursorLastHealthyAt != null && Date.now() - cursorLastHealthyAt < HEALTHY_GRACE_MS;
+    if (withinGrace && cursorSoftFailStreak < SOFT_FAIL_STREAK_TO_UNHEALTHY) {
+        // Hold the recent healthy result — one post-sleep timeout must not park the queue.
+        return [];
+    }
+    return [softIssue];
+}
 /** Exported for direct testing — bypasses the 60s cache in runtimeIssues(). */
 export async function runtimeIssuesUncached(runtime) {
     const issues = [];
@@ -107,34 +234,10 @@ export async function runtimeIssuesUncached(runtime) {
         }
         return issues;
     }
-    const status = await runCommand(resolveCursorBin(), cursorInvokeArgs(["status"]));
-    // A failed *spawn* resolves with the error message as its output (`spawn cursor-agent
-    // ENOENT`), not with empty output — so an absent binary must be recognised here or it
-    // falls through to the unconfirmed-auth branch below and names the wrong remedy.
-    if (!status.ok && (/\bENOENT\b/.test(status.output) || (!status.output.trim() && !cursorBinExists()))) {
-        issues.push({ code: "cli_missing", message: "cursor-agent not found — run: curl https://cursor.com/install -fsS | bash" });
-        return issues;
-    }
-    const authIssue = cursorAuthIssueFromOutput(status.output);
-    if (authIssue) {
-        issues.push(authIssue);
-        return issues;
-    }
-    // NOT-133: an unclassified *failure* of the probe itself (non-zero exit, timeout) used to
-    // be read as "healthy" and admitted the agent. Silence is not evidence of auth, so this
-    // fails closed: the agent stays unhealthy — and its issues stay queued — until the probe
-    // succeeds. That is a deliberate trade against the incident, where admitting on a guess
-    // cost 12 dead sessions and parked three issues on a human. Reported as runtime_auth so
-    // the existing agents-page CLI status renders it, with a message that says plainly the
-    // state is unconfirmed rather than asserting the agent is logged out.
-    if (!status.ok) {
-        const detail = status.output.trim().split("\n").slice(-1)[0] ?? "no output";
-        issues.push({
-            code: "runtime_auth",
-            message: `Could not confirm Cursor auth — \`cursor-agent status\` failed (${detail})`,
-        });
-    }
-    return issues;
+    // NOT-157: Cursor auth probe distinguishes hard (classified logged-out / keychain) from
+    // soft (timeout / unclassified probe flake). Soft path retries with backoff and holds a
+    // recent healthy result across a single post-sleep streak.
+    return cursorRuntimeIssues();
 }
 /**
  * Bedrock/Vertex installs authenticate through AWS/GCP credentials instead of a Claude
@@ -229,15 +332,28 @@ async function githubIssues() {
 async function runtimeIssues(runtime) {
     const capIssues = capHealthIssues(runtime);
     const cached = runtimeIssueCache.get(runtime);
-    if (cached && Date.now() - cached.at < RUNTIME_CACHE_MS) {
+    const ttl = cached?.softProbeFailure ? SOFT_PROBE_CACHE_MS : RUNTIME_CACHE_MS;
+    if (cached && Date.now() - cached.at < ttl) {
         return [...capIssues, ...cached.issues];
     }
     const issues = await runtimeIssuesUncached(runtime);
     const nonCap = issues.filter((i) => i.code !== "usage_capped");
-    runtimeIssueCache.set(runtime, { at: Date.now(), issues: nonCap });
+    // Soft fail (published or grace-held) uses a short TTL so a wake retry can clear quickly;
+    // a sticky 60s cache of "Could not confirm" is what parked the queue after sleep (NOT-157).
+    const softProbeFailure = nonCap.some(isSoftCursorProbeIssue) ||
+        (runtime === "cursor_local" && cursorSoftFailStreak > 0);
+    runtimeIssueCache.set(runtime, { at: Date.now(), issues: nonCap, softProbeFailure });
     return [...capIssues, ...nonCap];
 }
-function agentSpecificIssues(agent, agentDeckOnline, mcpRegistered, deckAccessResult) {
+function resolveMcpRegistration(mcpRegistered) {
+    if (mcpRegistered === undefined)
+        return checkAgentDeckMcpRegistration();
+    if (typeof mcpRegistered === "boolean") {
+        return mcpRegistered ? { status: "registered" } : { status: "missing" };
+    }
+    return mcpRegistered;
+}
+function agentSpecificIssues(agent, agentDeckOnline, mcpRegistration, deckAccessResult) {
     const issues = [];
     if (!agent.deckId) {
         issues.push({
@@ -264,11 +380,19 @@ function agentSpecificIssues(agent, agentDeckOnline, mcpRegistered, deckAccessRe
             });
         }
     }
-    if (agent.runtime === "claude_code" && agentDeckOnline && !mcpRegistered) {
-        issues.push({
-            code: "mcp_not_registered",
-            message: "Run agent-deck setup --client claude --start (Claude MCP not registered)",
-        });
+    if (agent.runtime === "claude_code" && agentDeckOnline) {
+        if (mcpRegistration.status === "endpoint_mismatch") {
+            issues.push({
+                code: "mcp_not_registered",
+                message: `Claude MCP points at ${mcpRegistration.foundHost}:${mcpRegistration.foundPort}, expected ${mcpRegistration.expectedHost}:${mcpRegistration.expectedPort} — update AGENT_DECK_HOST/AGENT_DECK_MCP_PORT (or the HTTP url) in Claude MCP config`,
+            });
+        }
+        else if (mcpRegistration.status === "missing") {
+            issues.push({
+                code: "mcp_not_registered",
+                message: "Run agent-deck setup --client claude --start (Claude MCP not registered)",
+            });
+        }
     }
     return issues;
 }
@@ -276,12 +400,12 @@ export async function healthForAgent(agent, agentDeckOnline, runtimeIssuesByRunt
     const runtime = runtimeIssuesByRuntime !== undefined
         ? (runtimeIssuesByRuntime.get(agent.runtime) ?? [])
         : await runtimeIssues(agent.runtime);
-    const deckMcpOk = mcpRegistered ?? isAgentDeckMcpRegistered();
+    const mcpRegistration = resolveMcpRegistration(mcpRegistered);
     const github = githubIssuesList ?? (await githubIssues());
     const issues = [
         ...runtime,
         ...github,
-        ...agentSpecificIssues(agent, agentDeckOnline, deckMcpOk, deckAccessResult),
+        ...agentSpecificIssues(agent, agentDeckOnline, mcpRegistration, deckAccessResult),
     ];
     return {
         ...agent,
@@ -291,7 +415,7 @@ export async function healthForAgent(agent, agentDeckOnline, runtimeIssuesByRunt
 }
 export async function listAgentsWithHealth(agents) {
     const agentDeckOnline = await checkAgentDeckHealth();
-    const mcpRegistered = isAgentDeckMcpRegistered();
+    const mcpRegistration = checkAgentDeckMcpRegistration();
     const needsDeckAccess = agents.some((a) => a.deckId);
     const deckAccessResult = agentDeckOnline && needsDeckAccess ? await fetchDecks() : null;
     const runtimes = [...new Set(agents.map((a) => a.runtime))];
@@ -302,5 +426,5 @@ export async function listAgentsWithHealth(agents) {
         })),
         githubIssues(),
     ]);
-    return Promise.all(agents.map((a) => healthForAgent(a, agentDeckOnline, runtimeIssuesByRuntime, mcpRegistered, deckAccessResult, githubIssuesList)));
+    return Promise.all(agents.map((a) => healthForAgent(a, agentDeckOnline, runtimeIssuesByRuntime, mcpRegistration, deckAccessResult, githubIssuesList)));
 }