@chibitek/chibi 0.1.154 → 0.1.155

package/dist-server/server/connector-proxy.js

@@ -0,0 +1,249 @@
+// Harness-owned Composio MCP bridge.
+//
+// Provider CLIs only see this stdio server. Ordinary MCP traffic is relayed
+// to the configured Composio Session, but connection requests are converted
+// into first-class OpenMausBot chat cards. The agent never authors an auth
+// URL and credentials never pass through its transcript.
+//
+// stdout is the MCP transport. Never log there.
+import readline from "node:readline";
+import { randomUUID } from "node:crypto";
+const UPSTREAM = process.env.OMB_CONNECTOR_UPSTREAM_URL ?? "";
+const HARNESS = process.env.OMB_HARNESS_URL ?? "http://127.0.0.1:8799";
+const BOT_ID = process.env.OMB_BOT_ID ?? "";
+const THREAD_ID = process.env.OMB_THREAD_ID ?? "";
+const TOKEN = process.env.OMB_CONNECTOR_TOKEN ?? process.env.OMB_COMMS_TOKEN ?? "";
+const MAX_RESPONSE_BYTES = 20 * 1024 * 1024;
+const INITIALIZE_RELAY_TIMEOUT_MS = 1_000;
+const RELAY_TIMEOUT_MS = 10 * 60_000;
+function parsedHeaders() {
+    try {
+        const value = JSON.parse(process.env.OMB_CONNECTOR_UPSTREAM_HEADERS ?? "{}");
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return {};
+        return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string"));
+    }
+    catch {
+        return {};
+    }
+}
+const upstreamHeaders = parsedHeaders();
+let upstreamSessionId = "";
+const send = (message) => process.stdout.write(`${JSON.stringify(message)}\n`);
+function textResult(id, text, isError = false) {
+    return { jsonrpc: "2.0", id, result: { content: [{ type: "text", text }], ...(isError ? { isError: true } : {}) } };
+}
+function jsonRpcError(id, message) {
+    return { jsonrpc: "2.0", id, error: { code: -32000, message } };
+}
+function initializeResult(id, protocolVersion) {
+    return {
+        jsonrpc: "2.0",
+        id,
+        result: {
+            protocolVersion: typeof protocolVersion === "string" && protocolVersion ? protocolVersion : "2024-11-05",
+            capabilities: { tools: {} },
+            serverInfo: { name: "openmausbot-connectors", version: "1" },
+        },
+    };
+}
+async function readBounded(response) {
+    const declared = Number(response.headers.get("content-length") ?? "0");
+    if (declared > MAX_RESPONSE_BYTES)
+        throw new Error("connector response exceeded 20 MB");
+    if (!response.body)
+        return "";
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let size = 0;
+    let text = "";
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        size += value.byteLength;
+        if (size > MAX_RESPONSE_BYTES) {
+            await reader.cancel();
+            throw new Error("connector response exceeded 20 MB");
+        }
+        text += decoder.decode(value, { stream: true });
+    }
+    return text + decoder.decode();
+}
+function parseUpstream(text, id) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.startsWith("{"))
+        return JSON.parse(trimmed);
+    const frames = trimmed
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice(5).trim())
+        .filter((line) => line && line !== "[DONE]")
+        .flatMap((line) => {
+        try {
+            return [JSON.parse(line)];
+        }
+        catch {
+            return [];
+        }
+    });
+    return frames.findLast((frame) => frame.id === id) ?? frames.at(-1) ?? null;
+}
+async function relay(message, timeoutMs = RELAY_TIMEOUT_MS) {
+    if (!UPSTREAM)
+        throw new Error("connected apps are unavailable");
+    const response = await fetch(UPSTREAM, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            accept: "application/json, text/event-stream",
+            ...upstreamHeaders,
+            ...(upstreamSessionId ? { "mcp-session-id": upstreamSessionId } : {}),
+        },
+        body: JSON.stringify(message),
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    const nextSession = response.headers.get("mcp-session-id");
+    if (nextSession)
+        upstreamSessionId = nextSession;
+    if (!response.ok)
+        throw new Error(`connector service returned HTTP ${response.status}`);
+    return parseUpstream(await readBounded(response), message.id);
+}
+function connectorAdds(args) {
+    if (!args || typeof args !== "object" || Array.isArray(args))
+        return [];
+    const toolkits = args.toolkits;
+    if (!Array.isArray(toolkits))
+        return [];
+    const seen = new Set();
+    const requests = [];
+    for (const item of toolkits) {
+        if (typeof item === "string") {
+            const slug = item.trim().toLowerCase();
+            const key = JSON.stringify([slug, ""]);
+            if (!seen.has(key)) {
+                seen.add(key);
+                requests.push({ slug });
+            }
+            continue;
+        }
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            continue;
+        const row = item;
+        const action = String(row.action ?? "add").toLowerCase();
+        if (!["add", "connect", "initiate"].includes(action))
+            continue;
+        const slug = typeof row.toolkit === "string" ? row.toolkit : row.name;
+        if (typeof slug !== "string")
+            continue;
+        const normalized = slug.trim().toLowerCase();
+        const alias = (typeof row.alias === "string" ? row.alias : typeof row.account === "string" ? row.account : "").trim();
+        const key = JSON.stringify([normalized, alias.toLowerCase()]);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        requests.push({ slug: normalized, ...(alias ? { alias } : {}) });
+    }
+    return requests;
+}
+async function showConnectorCards(items) {
+    const response = await fetch(`${HARNESS}/api/internal/connectors/request`, {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: `Bearer ${TOKEN}` },
+        body: JSON.stringify({ botId: BOT_ID, threadId: THREAD_ID, items, resumeKey: randomUUID() }),
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (!response.ok) {
+        const body = (await response.json().catch(() => ({})));
+        throw new Error(String(body.error ?? `could not show connection card (HTTP ${response.status})`));
+    }
+}
+async function handle(message) {
+    const id = message.id;
+    const method = String(message.method ?? "");
+    // OpenCode (and other MCP clients) mark a stdio server failed unless
+    // initialize returns capabilities/serverInfo. Relaying that handshake to
+    // Composio can time out, return a newer protocolVersion, or throw when the
+    // upstream URL never reached the child env — all of which previously
+    // surfaced as a tools/call-shaped {content,isError} payload.
+    if (method === "notifications/initialized" || method === "initialized") {
+        if (UPSTREAM)
+            void relay(message).catch(() => { });
+        return;
+    }
+    if (method === "initialize") {
+        if (UPSTREAM) {
+            try {
+                // Capture the upstream session id when the service is healthy, but
+                // never let a stalled provider prevent the local MCP client from
+                // mounting the connector tools. The client sends initialized only
+                // after this bounded attempt and the local initialize response.
+                await relay(message, INITIALIZE_RELAY_TIMEOUT_MS);
+            }
+            catch {
+                // Best-effort session setup. The client still needs a valid result.
+            }
+        }
+        if (id !== undefined) {
+            const params = (message.params ?? {});
+            send(initializeResult(id, params.protocolVersion));
+        }
+        return;
+    }
+    if (method === "tools/call") {
+        const params = (message.params ?? {});
+        const name = String(params.name ?? "");
+        const requests = /MANAGE_CONNECTIONS$/i.test(name) ? connectorAdds(params.arguments) : [];
+        if (requests.length) {
+            await showConnectorCards(requests);
+            const labels = requests.map((r) => (r.alias ? `${r.slug} (${r.alias})` : r.slug)).join(", ");
+            send(textResult(id, `Atomic showed the user a secure connection card for ${labels}. End this turn now. The app will continue the task automatically after the connection finishes.`));
+            return;
+        }
+        if (/WAIT_FOR_CONNECTIONS$/i.test(name)) {
+            send(textResult(id, "Atomic is handling connection completion and will continue the task automatically."));
+            return;
+        }
+    }
+    try {
+        const response = await relay(message);
+        if (response && id !== undefined)
+            send(response);
+    }
+    catch (error) {
+        if (id === undefined)
+            return;
+        const messageText = error instanceof Error ? error.message : String(error);
+        if (method === "tools/call")
+            send(textResult(id, messageText, true));
+        else
+            send(jsonRpcError(id, messageText));
+    }
+}
+const input = readline.createInterface({ input: process.stdin, terminal: false });
+input.on("line", (line) => {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return;
+    let message;
+    try {
+        message = JSON.parse(trimmed);
+    }
+    catch {
+        return;
+    }
+    void handle(message).catch((error) => {
+        if (message.id === undefined)
+            return;
+        const method = String(message.method ?? "");
+        const messageText = error instanceof Error ? error.message : String(error);
+        if (method === "tools/call")
+            send(textResult(message.id, messageText, true));
+        else
+            send(jsonRpcError(message.id, messageText));
+    });
+});
+input.on("close", () => process.exit(0));

package/dist-server/server/drivers/codex.js

@@ -156,20 +156,13 @@ export function managedCodexArgs(config) {
 }
 const QUESTION_TIMEOUT_NOTE = "No answer was given — use your best judgment.";
 const DENY_TIMEOUT_NOTE = "Atomic: nobody answered this permission request in time. Skip this action and finish what you can without it.";
-const skippedSseServers = new Set();
-const renamedMcpServers = new Set();
-/** Logged once per name: the rename is deliberate, not a lost server. */
-function noteRenamedMcpServer(name, mountName) {
-    if (renamedMcpServers.has(name))
+const notedMcpServers = new Set();
+/** Logged once per server and reason: a rename or a left-out server is deliberate, not a lost one. */
+function noteMcpServerOnce(key, line) {
+    if (notedMcpServers.has(key))
         return;
-    renamedMcpServers.add(name);
-    console.error(`codex: MCP server ${JSON.stringify(name)} is also declared in Codex's own config.toml — mounted as ${JSON.stringify(mountName)} for this bot so the two do not merge`);
-}
-function noteSkippedSseServer(name) {
-    if (skippedSseServers.has(name))
-        return;
-    skippedSseServers.add(name);
-    console.error(`codex: MCP server ${JSON.stringify(name)} uses the SSE transport, which codex does not speak — it is available to Claude bots only`);
+    notedMcpServers.add(key);
+    console.error(`codex: MCP server ${line}`);
 }
 /** A TOML inline table for a `-c key=value` override; JSON string quoting
  * is valid TOML basic-string quoting. */
@@ -645,16 +638,18 @@ export const CodexDriver = {
             // instance's legacy fullAuto setting. Harness turns always send an
             // explicit mode, which takes precedence.
             const approvalMode = turn.approvalMode ?? (config.fullAuto ? "full" : "ask");
+            // The person's servers this turn mounts. One that would clobber a
+            // harness-owned variable is left out, not fatal: the rest still mount.
+            const customServers = {};
             for (const [name, server] of Object.entries(turn.integrations?.custom ?? {})) {
-                if ("url" in server)
-                    continue;
                 // The mcp-remote bridge runs on Atomic's own Electron-as-Node and sets
                 // ELECTRON_RUN_AS_NODE=1, the value the harness mounts already share.
-                const reserved = Object.entries(server.env)
+                const reserved = "url" in server ? undefined : Object.entries(server.env)
                     .find(([key, value]) => isHarnessOwnedMcpEnvName(key) && !(key === "ELECTRON_RUN_AS_NODE" && value === "1"))?.[0];
-                if (reserved) {
-                    throw new Error(`Custom MCP server “${name}” cannot set reserved environment variable “${reserved}”`);
-                }
+                if (reserved)
+                    noteMcpServerOnce(`reserved:${name}`, `${JSON.stringify(name)} sets reserved environment variable ${JSON.stringify(reserved)} — left out of this bot's turns until its settings change`);
+                else
+                    customServers[name] = server;
             }
             let autoAcceptPermissions = approvalMode === "full";
             if (active.has(threadId))
@@ -692,7 +687,7 @@ export const CodexDriver = {
                 // this child actually loads. The mounts assign the same values again,
                 // in the same order, so the final environment is unchanged.
                 const childCwd = turn.cwd ?? homedir();
-                for (const server of Object.values(turn.integrations?.custom ?? {})) {
+                for (const server of Object.values(customServers)) {
                     if (!("url" in server))
                         Object.assign(env, server.env);
                 }
@@ -720,17 +715,17 @@ export const CodexDriver = {
                 // mount name → configured name, so an approval request naming the
                 // mounted server can be traced back to the person's own entry
                 const customByMountName = new Map();
-                for (const [name, server] of Object.entries(turn.integrations?.custom ?? {})) {
+                for (const [name, server] of Object.entries(customServers)) {
                     // codex speaks streamable HTTP to a remote server, not the older
                     // SSE transport: such an entry still reaches Claude bots, and is
                     // left out here rather than mounted as something it is not
                     if ("url" in server && server.type === "sse") {
-                        noteSkippedSseServer(name);
+                        noteMcpServerOnce(`sse:${name}`, `${JSON.stringify(name)} uses the SSE transport, which codex does not speak — it is available to Claude bots only`);
                         continue;
                     }
                     const mountName = mountedMcpServerName(name, declaredInCodexConfig);
                     if (mountName !== name)
-                        noteRenamedMcpServer(name, mountName);
+                        noteMcpServerOnce(`renamed:${name}`, `${JSON.stringify(name)} is also declared in Codex's own config.toml — mounted as ${JSON.stringify(mountName)} for this bot so the two do not merge`);
                     customByMountName.set(mountName, name);
                     mountMcpServer(appServerArgs, env, mountName, server, false);
                 }

package/dist-server/server/incidents.js

@@ -78,6 +78,8 @@ function whatHappened(incident) {
             return `${incident.bot.name}'s run ${where} continued on another model because its engine refused the one it was set to${detail}`;
         case "engine-fallback":
             return `${incident.bot.name}'s run ${where} continued on another engine after its selected engine failed${detail}`;
+        case "mcp-unavailable":
+            return `${incident.bot.name}'s run ${where} continued without one of its tool servers${detail}`;
         default:
             return `${incident.bot.name}'s run ${where} failed${detail}`;
     }
@@ -99,13 +101,15 @@ export function incidentText(incident, count) {
         lines.push(`${incident.bot.name} last said: "${fold(incident.lastReply, 300)}"`);
     if (count.count > 1)
         lines.push(`This is the ${ordinal(count.count)} incident on that thread within the hour.`);
-    if (incident.kind === "model-fallback" || incident.kind === "engine-fallback") {
-        // Nothing broke: the turn ran. The failed selection or engine still
-        // needs attention, but the completed work must never be retried.
+    if (incident.kind === "model-fallback" || incident.kind === "engine-fallback" || incident.kind === "mcp-unavailable") {
+        // Nothing broke: the turn ran. The failed selection, engine or tool
+        // server still needs attention, but the completed work must never be retried.
         lines.push("The run was not interrupted and needs no retry; do not call retry_thread.");
         lines.push(incident.kind === "model-fallback"
             ? "Tell the person in one or two plain sentences that this engine no longer offers that model and that the bot's or the conversation's model setting should be changed, then stop."
-            : "Use the incident detail to correct the failed engine if action is needed, then report what happened in one or two plain sentences and stop.");
+            : incident.kind === "mcp-unavailable"
+                ? "Tell the person in one or two plain sentences which tool server is not working, that bots carry on without it until it answers again, and that its command and settings in Settings may need a look, then stop."
+                : "Use the incident detail to correct the failed engine if action is needed, then report what happened in one or two plain sentences and stop.");
         return lines.join("\n");
     }
     lines.push(count.mayRetry

package/dist-server/server/index.js

@@ -92,7 +92,7 @@ import { probeMcpServer } from "./mcp-probe.js";
 import { McpToolHintStore, readOnlyToolAllowed } from "./mcp-tool-hints.js";
 import { McpAuthStateStore } from "./mcp-auth-state.js";
 import { McpHealthStore } from "./mcp-health.js";
-import { drainMcpAuthSignals } from "./mcp-auth-signal.js";
+import { mcpTurnPolicy } from "./mcp-turn.js";
 import { mcpAuthSignalDir } from "./mcp-gate-config.js";
 import { bridgeMcpRemote } from "./mcp-remote-bridge.js";
 import { mcpToolRefFromLabel } from "../shared/mcp-tool-ref.js";
@@ -8258,6 +8258,8 @@ bus.subscribe((event) => {
             lastReply.delete(event.threadId);
             const turnError = lastTurnError.get(event.threadId);
             lastTurnError.delete(event.threadId);
+            // A tool server that broke under this turn is reported with the turn (mcp-turn.ts), not at whatever turn next starts.
+            syncMcpAuthState();
             // A run that broke — not one the person stopped, and not a routine's,
             // which reports through its own failure path — is the Chief's to see.
             // A lazy computer-claim rejection already reported its failure and
@@ -8625,11 +8627,11 @@ function incidentContext(threadId) {
 }
 function reportIncident(input) {
     const { bot, threadId } = input;
-    // A fallback is a run that went on, not a broken one.
-    const quiet = input.kind === "model-fallback" || input.kind === "engine-fallback";
+    // A fallback, or a turn that ran on without a broken tool server, is a run that went on, not a broken one.
+    const quiet = input.kind === "model-fallback" || input.kind === "engine-fallback" || input.kind === "mcp-unavailable";
     // The Primary Bot's pre-check reads broken runs from here (a failed
     // routine has its own run record, so it is not noted twice).
-    if (input.kind !== "routine-failed" && input.kind !== "model-fallback" && input.kind !== "engine-fallback") {
+    if (input.kind !== "routine-failed" && input.kind !== "model-fallback" && input.kind !== "engine-fallback" && input.kind !== "mcp-unavailable") {
         primaryBotStore.noteFailure({ botId: bot.id, threadId, kind: input.kind, detail: redactSecretsInText(input.detail).slice(0, 300), at: Date.now() });
     }
     const task = store.taskByThread(bot.id, threadId);
@@ -10775,7 +10777,7 @@ async function startTurn(botId, text, opts) {
                 { id: "team-computer", label: "Team computer", text: teamComputerPrompt(teamComputer) },
                 { id: "plan", label: "Surface", text: surfacePrompt({ computer: mountedComputer, browser: Boolean(integrations.browser) }, { pinned: plan.pinned, note: plan.note, canSelect: computerSelectionTurns.has(threadId) }) },
                 { id: "accounts", label: "Google and Microsoft accounts", text: integrations.accounts ? accountsPrompt(botAccountEmails(bot)) : "" },
-                { id: "mcp", label: "MCP servers", text: customMcpPrompt(Object.keys(integrations.custom ?? {})) },
+                { id: "mcp", label: "MCP servers", text: customMcpPrompt(Object.keys(integrations.custom ?? {}), instance.adapter.capabilities.customMcp === true ? mcpTurn.unavailable(engineMcpServers(bot)) : []) },
                 { id: "browser", label: "Browser", text: integrations.browser ? BUILT_IN_BROWSER_SYSTEM_PROMPT : "" },
                 { id: "coordination", label: "Team", text: coordinationPrompt ? ` ${coordinationPrompt}` : "" },
                 { id: "assignment", label: "Teammate task", text: coordinationNode ? `\n${coordinationSystemInstructions()}` : "" },
@@ -12623,7 +12625,7 @@ failover) {
             { id: "private-bot", label: "Private Bot", text: isPersonalBot(bot) ? privateBotPrompt(false) : "" },
             { id: "files", label: "File locations", text: workspace ? workspaceLocationsPrompt(bot.id, cwd, readyBot.cwd) : "" },
             { id: "repos", label: "Linked repos", text: repoPlan ? repoPromptSection(repoPlan, repoPlace(undefined, roomTeamComputer || roomComputerKind === "box" ? "box" : roomVmMounted ? "vm" : roomComputerKind), cwd) : "" },
-            { id: "mcp", label: "MCP servers", text: customMcpPrompt(Object.keys(integrations.custom ?? {})) },
+            { id: "mcp", label: "MCP servers", text: customMcpPrompt(Object.keys(integrations.custom ?? {}), instance.adapter.capabilities.customMcp === true ? mcpTurn.unavailable(engineMcpServers(bot)) : []) },
             { id: "computer", label: "Computer", text: computerPrompt(roomTeamComputer || roomComputerKind === "box" ? instance.driverKind === "boxAgent" ? "box-agent" : instance.adapter.capabilities.cloudComputerMcp ? "box-chat" : "box" : roomVmMounted ? localVmMode(cfg) === "per-bot" ? "vm-private" : "vm-shared" : roomComputerKind) },
             { id: "team-computer", label: "Team computer", text: teamComputerPrompt(roomTeamComputer) },
             { id: "plan", label: "Surface", text: surfacePrompt({ computer: roomTeamComputer ? "cloud" : roomVmMounted ? "vm" : surfaceOfComputerKind(roomComputerKind), browser: Boolean(integrations.browser) }, { note: roomPlan.note }) },
@@ -14781,23 +14783,19 @@ function warmMcpToolHints(custom) {
 /** Each configured server's sign-in state, and whether it is otherwise broken. */
 const mcpAuthState = new McpAuthStateStore(join(DATA_DIR, "mcp-auth-state.json"));
 const mcpHealth = new McpHealthStore();
-/** Fold in what gates and the chat runtime reported since the last look. */
-function syncMcpAuthState() {
-    const signals = drainMcpAuthSignals(mcpAuthSignalDir());
-    if (signals.length)
-        for (const state of [mcpAuthState, mcpHealth])
-            state.ingest(signals, customMcpServers(cfg));
-}
+const mcpTurn = mcpTurnPolicy({ auth: mcpAuthState, health: mcpHealth, signalDir: mcpAuthSignalDir, specs: () => customMcpServers(cfg),
+    reportUnavailable: (threadId, detail) => { const bot = store.botByThread(threadId); if (bot)
+        reportIncident({ kind: "mcp-unavailable", bot, threadId, detail }); } });
+function syncMcpAuthState() { mcpTurn.sync(); }
 /** How a start runs an mcp-remote bridge: background starts never open a
  * browser; only a person's click in Settings may (server/mcp-remote-bridge.ts). */
 function bridgedMcpServer(spec, allowBrowser) {
     return bridgeMcpRemote(spec, { bridge: resolveMcpRemoteBridge(), execPath: process.execPath, allowBrowser });
 }
-/** The servers one turn starts: the bot's servers, minus any whose sign-in
- * is backing off or stopped, or that lately would not start or crashed. */
+/** The servers one turn starts (mcp-turn.ts), after folding in what the gates reported. */
 function turnMcpServers(bot) {
     syncMcpAuthState();
-    return Object.fromEntries(Object.entries(engineMcpServers(bot)).filter(([name, spec]) => mcpAuthState.mountable(name, spec) && mcpHealth.mountable(name, spec)));
+    return mcpTurn.mountable(engineMcpServers(bot));
 }
 function engineMcpServers(bot) {
     // Rule 4 (server/personal-bot.ts): a bot with no list of its own gets every

package/dist-server/server/mcp-auth-signal.js

@@ -45,7 +45,8 @@ export function drainMcpAuthSignals(dir) {
             const parsed = JSON.parse(readFileSync(file, "utf8"));
             if (typeof parsed.name === "string" && MCP_SIGNAL_KINDS.includes(parsed.kind)
                 && typeof parsed.at === "number" && Number.isFinite(parsed.at)) {
-                signals.push({ name: parsed.name, kind: parsed.kind, at: parsed.at });
+                signals.push({ name: parsed.name, kind: parsed.kind, at: parsed.at,
+                    ...(typeof parsed.threadId === "string" && parsed.threadId ? { threadId: parsed.threadId } : {}) });
             }
         }
         catch {

package/dist-server/server/mcp-gate-config.js

@@ -57,6 +57,7 @@ export function gateServer(input) {
             OMB_GATE_SPILL_DIR: spillDir(input.threadId),
             OMB_GATE_BUDGET: String(budget),
             OMB_GATE_AUTH_DIR: mcpAuthSignalDir(),
+            OMB_GATE_THREAD: input.threadId,
         },
     };
 }

package/dist-server/server/mcp-gate.js

@@ -40,9 +40,12 @@ const SPILL_MAX_AGE_MS = 24 * 60 * 60_000;
 const SPILL_HINT = process.env.OMB_GATE_SPILL_HINT === "1";
 /** The gate's own settings never reach the upstream server's environment. */
 const GATE_ENV_KEYS = ["OMB_GATE_NAME", "OMB_GATE_SPILL_DIR", "OMB_GATE_BUDGET", "OMB_GATE_UPSTREAM", "OMB_GATE_SPILL_HINT", "OMB_GATE_AUTH_DIR",
-    "OMB_GATE_START_TIMEOUT_MS"];
+    "OMB_GATE_START_TIMEOUT_MS", "OMB_GATE_THREAD"];
 /** Where this gate reports whether its server's sign-in worked. */
 const AUTH_DIR = process.env.OMB_GATE_AUTH_DIR || "";
+/** The turn this gate serves, so a failure can be reported for its bot. */
+const THREAD = process.env.OMB_GATE_THREAD || "";
+const signalHarness = (kind) => writeMcpAuthSignal(AUTH_DIR, { name: NAME, kind, at: Date.now(), ...(THREAD ? { threadId: THREAD } : {}) });
 function fail(message) {
     process.stderr.write(`mcp-gate(${NAME}): ${message}\n`);
     process.exit(1);
@@ -196,7 +199,7 @@ function goDown(reason, why, signal = true) {
         clearTimeout(startTimer);
     process.stderr.write(`mcp-gate(${NAME}): ${why}; answering as an empty server so the turn carries on without it\n`);
     if (signal)
-        writeMcpAuthSignal(AUTH_DIR, { name: NAME, kind: reason, at: Date.now() });
+        signalHarness(reason);
     for (const message of inFlight.values())
         answer(strandedResponse(NAME, message));
     inFlight.clear();
@@ -290,7 +293,7 @@ createInterface({ input: child.stdout }).on("line", (line) => {
         reportedOk = true;
         if (startTimer)
             clearTimeout(startTimer);
-        writeMcpAuthSignal(AUTH_DIR, { name: NAME, kind: "ok", at: Date.now() });
+        signalHarness("ok");
     }
     const tool = id === undefined ? undefined : pending.get(id);
     if (id !== undefined)
@@ -317,7 +320,7 @@ child.on("exit", (code, signal) => {
         return;
     if (!reportedOk && exitMeansSignInRequired(code, stderrTail)) {
         process.stderr.write(`mcp-gate(${NAME}): sign-in required; not opening a browser from a background start\n`);
-        writeMcpAuthSignal(AUTH_DIR, { name: NAME, kind: "sign-in-required", at: Date.now() });
+        signalHarness("sign-in-required");
         if (!clientGone)
             return goDown("start-failed", "needs a sign-in", false);
     }

package/dist-server/server/mcp-health.js

@@ -29,12 +29,13 @@ export class McpHealthStore {
     noteFailed(name, spec, kind, at = this.now()) {
         const entry = this.entry(name, spec);
         if (entry && at < entry.retryAt)
-            return;
+            return false;
         const failures = (entry?.failures ?? 0) + 1;
         const wait = MCP_FAILURE_BACKOFF_MS[Math.min(failures, MCP_FAILURE_BACKOFF_MS.length) - 1];
         const retryAt = at + wait;
         this.servers.set(name, { fingerprint: mcpServerFingerprint(spec), kind, failures, lastFailureAt: at, retryAt });
         this.log(`[mcp] "${name}" ${kind === "crashed" ? "stopped during a turn" : "would not start"}; turns run without it until ${formatTime(retryAt)}`);
+        return true;
     }
     /** The server answered: whatever was wrong is over. An answer from a start
      * that began before a later failure does not clear that failure. */
@@ -54,17 +55,26 @@ export class McpHealthStore {
         const when = this.now() >= entry.retryAt ? "Atomic tries it again on the next turn." : `Atomic tries it again at ${formatTime(entry.retryAt)}.`;
         return `This server ${what}, so bots are working without it for now. ${when} Check its command and settings if this keeps happening.`;
     }
+    /** Why a server is left out of turns right now, or undefined when it mounts. */
+    unavailableKind(name, spec) {
+        const entry = this.entry(name, spec);
+        return entry && this.now() < entry.retryAt ? entry.kind : undefined;
+    }
     /** Apply what gates and the chat runtime reported, in order. `specs` are
-     * the servers as configured now; a signal for a removed server is dropped. */
+     * the servers as configured now; a signal for a removed server is dropped.
+     * Returns the signals that recorded a new failure (a repeat inside the
+     * backoff window is not one), so the harness can raise one incident each. */
     ingest(signals, specs) {
+        const fresh = [];
         for (const signal of signals) {
             const spec = specs[signal.name];
             if (!spec)
                 continue;
             if (signal.kind === "ok")
                 this.noteOk(signal.name, signal.at);
-            else if (signal.kind === "start-failed" || signal.kind === "crashed")
-                this.noteFailed(signal.name, spec, signal.kind, signal.at);
+            else if ((signal.kind === "start-failed" || signal.kind === "crashed") && this.noteFailed(signal.name, spec, signal.kind, signal.at))
+                fresh.push(signal);
         }
+        return fresh;
     }
 }