@stigmer/runner 3.4.0 → 3.5.0

package/src/runner-manager.ts

@@ -25,6 +25,10 @@ import {
 import type { PayloadCodec } from "@temporalio/common";
 import type { Config } from "./config.js";
 import { DEFAULT_CURSOR_AGENT_RESOLVE_TIMEOUT_MS, DEFAULT_CURSOR_STREAM_STALL_TIMEOUT_MS, DEFAULT_WORKSPACE_LOCK_TIMEOUT_MS } from "./config.js";
+// Boot marks mirror the static runner's segment names where the work is the
+// same. Inert unless a mode emits the boot timeline (pool mode does; the
+// desktop manager never calls emitRunnerBootTiming, so marks cost nothing).
+import { markBoot } from "./shared/cold-start-timing.js";
 import type { WorkerActivities } from "./worker.js";
 import { resolveWorkflowSource, OTEL_WORKFLOW_INTERCEPTOR_MODULE } from "./workflow-source.js";
 import { resolveRunnerBootstrap, refreshRunnerAccessToken } from "./bootstrap.js";
@@ -43,6 +47,10 @@ import {
 
 const SESSION_QUEUE_PREFIX = "session:";
 const WFEXEC_QUEUE_PREFIX = "wfexec:";
+// Warm-pool control queue — polled by exactly one pool member, carrying only
+// the ProbePoolMember/AttachSession claim activities (never session work).
+// Mirrors SessionDispatchService's convention: lowercase kind, colon, id.
+const POOL_CONTROL_QUEUE_PREFIX = "sandbox:";
 
 /**
  * Module-level registry of shutdown signals per task queue.
@@ -142,6 +150,14 @@ export interface StigmerRunnerManager {
   /** List currently active workflow execution IDs. */
   activeWorkflowExecutions(): string[];
 
+  /**
+   * Start the warm-pool control worker — a Worker polling sandbox:{memberId}
+   * for the claim activities (ProbePoolMember, AttachSession). Called once by
+   * the pool boot path; the attach flow then adds the claimed session via
+   * {@link addSession} like any other host.
+   */
+  addPoolControl(memberId: string): Promise<void>;
+
   /**
    * Push a refreshed *control-plane* auth token (the host's durable credential,
    * e.g. the desktop's Auth0 token) to all activity clients.
@@ -250,6 +266,7 @@ export async function createStigmerRunnerManager(
   // facade unpatched (otherwise BiDi streams would silently 401). No-op when
   // the interceptor is unconfigured (no proxy/token).
   await assertHttp2ConnectPatched();
+  markBoot("interceptors_installed");
 
   // The token coordinator owns the proxy credential (x-stigmer-auth) and its
   // refresh lifecycle. It writes ONLY its sinks (the interceptors plus the gRPC
@@ -287,6 +304,7 @@ export async function createStigmerRunnerManager(
     temporalAddress: bootstrap.temporalAddress,
     temporalNamespace: bootstrap.temporalNamespace,
   };
+  markBoot("bootstrap_resolved");
 
   // Adopt the minted proxy token (cloud): it diverges from the control-plane
   // token from here on, and the coordinator refreshes it before expiry.
@@ -313,11 +331,13 @@ export async function createStigmerRunnerManager(
   setExecutionContextRef(getExecutionContext());
 
   const activities = await createAllActivities(config);
+  markBoot("activities_imported");
   const payloadCodec = await createPayloadCodec(config);
 
   const connection = await NativeConnection.connect({
     address: config.temporalAddress,
   });
+  markBoot("connection_opened");
 
   const interceptorConfig = await buildInterceptorConfig();
 
@@ -336,10 +356,13 @@ export async function createStigmerRunnerManager(
     });
     console.log("[runner-manager] Workflow code bundled successfully");
   }
+  markBoot("workflow_bundle_ready");
 
   const sessions = new Map<string, ManagedSession>();
   const workflowExecutions = new Map<string, ManagedSession>();
   const shutdownSignals = new Map<string, AbortController>();
+  // At most one per process: a pool member IS its control worker's identity.
+  let poolControl: { taskQueue: string; managed: ManagedSession } | null = null;
   let shuttingDown = false;
 
   async function createWorkerOnQueue(taskQueue: string): Promise<ManagedSession> {
@@ -502,6 +525,23 @@ export async function createStigmerRunnerManager(
       return Array.from(workflowExecutions.keys());
     },
 
+    async addPoolControl(memberId: string): Promise<void> {
+      if (shuttingDown) {
+        throw new Error("RunnerManager is shutting down");
+      }
+      if (poolControl) {
+        throw new Error(
+          `Pool control worker already polling ${poolControl.taskQueue} — ` +
+          "a process is exactly one pool member",
+        );
+      }
+      const taskQueue = POOL_CONTROL_QUEUE_PREFIX + memberId;
+      poolControl = { taskQueue, managed: await createWorkerOnQueue(taskQueue) };
+      console.log(
+        `[runner-manager] Added pool control worker (queue=${taskQueue})`,
+      );
+    },
+
     updateToken(token: string | null): void {
       // Writes the control-plane credential. The coordinator decides whether the
       // proxy credential follows it: only when no token has been minted (so the
@@ -541,10 +581,19 @@ export async function createStigmerRunnerManager(
           },
         ),
       ];
+      if (poolControl) {
+        const control = poolControl;
+        shutdownPromises.push((async () => {
+          control.managed.worker.shutdown();
+          await control.managed.runPromise;
+          console.log(`[runner-manager] Pool control worker (${control.taskQueue}) stopped`);
+        })());
+      }
 
       await Promise.all(shutdownPromises);
       sessions.clear();
       workflowExecutions.clear();
+      poolControl = null;
       connection.close();
       console.log("[runner-manager] All workers stopped, connection closed");
     },
@@ -629,6 +678,7 @@ async function createAllActivities(config: Config): Promise<WorkerActivities> {
     { createHydrateWorkflowActivities },
     { createWorkflowEventActivities },
     { createPromoteTaskOutputActivities },
+    { createAttachSessionActivities },
   ] = await Promise.all([
     import("./activities/execute-cursor/index.js"),
     import("./activities/execute-deep-agent/index.js"),
@@ -646,6 +696,7 @@ async function createAllActivities(config: Config): Promise<WorkerActivities> {
     import("./activities/hydrate-workflow-execution.js"),
     import("./activities/workflow-event-activities.js"),
     import("./activities/promote-task-output.js"),
+    import("./activities/attach-session.js"),
   ]);
 
   return {
@@ -665,6 +716,7 @@ async function createAllActivities(config: Config): Promise<WorkerActivities> {
     ...createHydrateWorkflowActivities(config),
     ...createWorkflowEventActivities(),
     ...createPromoteTaskOutputActivities(),
+    ...createAttachSessionActivities(config),
   };
 }
 

package/src/runner.ts

@@ -20,6 +20,7 @@ import type { Config } from "./config.js";
 import { DEFAULT_CURSOR_AGENT_RESOLVE_TIMEOUT_MS, DEFAULT_CURSOR_STREAM_STALL_TIMEOUT_MS, DEFAULT_WORKSPACE_LOCK_TIMEOUT_MS } from "./config.js";
 import type { WorkerActivities } from "./worker.js";
 import { resolveRunnerBootstrap } from "./bootstrap.js";
+import { markBoot, emitRunnerBootTiming } from "./shared/cold-start-timing.js";
 
 /**
  * Configuration for creating a Stigmer runner.
@@ -179,6 +180,7 @@ export async function createStigmerRunner(
   // facade unpatched (otherwise BiDi streams would silently 401). No-op when
   // the interceptor is unconfigured (no proxy/token).
   await assertHttp2ConnectPatched();
+  markBoot("interceptors_installed");
 
   // Resolve Temporal coordinates after the http2 patch is in place (discovery
   // dials the control plane through connect-node). Explicit address wins;
@@ -201,6 +203,7 @@ export async function createStigmerRunner(
     temporalAddress: coordinates.temporalAddress,
     temporalNamespace: coordinates.temporalNamespace,
   };
+  markBoot("bootstrap_resolved");
 
   const { setExecutionContextRef } = await import(
     "./activities/execute-cursor/rejection-capture.js"
@@ -208,6 +211,7 @@ export async function createStigmerRunner(
   setExecutionContextRef(getExecutionContext());
 
   const activities = await createAllActivities(config);
+  markBoot("activities_imported");
 
   console.log(
     `[runner] Registered activities: ${Object.keys(activities).join(", ")}`,
@@ -222,10 +226,18 @@ export async function createStigmerRunner(
 
   const { startWorker } = await import("./worker.js");
   const worker = await startWorker({ config, activities, payloadCodec });
+  markBoot("worker_created");
 
   return {
     async start() {
       console.log("Worker ready, polling for tasks...");
+      // The boot timeline ends here: the worker is about to poll, so the
+      // sandbox can now receive its first activity. The final mark closes the
+      // worker_created → about-to-poll span — without it, total_ms would stop
+      // at worker_created and understate the boot time the warm-pool go/no-go
+      // decision reads.
+      markBoot("worker_polling");
+      emitRunnerBootTiming({ task_queue: config.taskQueue, mode: config.mode });
       await worker.run();
       console.log("Worker stopped");
     },
@@ -320,6 +332,7 @@ async function createAllActivities(config: Config): Promise<WorkerActivities> {
     { createHydrateWorkflowActivities },
     { createWorkflowEventActivities },
     { createPromoteTaskOutputActivities },
+    { createAttachSessionActivities },
   ] = await Promise.all([
     import("./activities/execute-cursor/index.js"),
     import("./activities/execute-deep-agent/index.js"),
@@ -337,6 +350,7 @@ async function createAllActivities(config: Config): Promise<WorkerActivities> {
     import("./activities/hydrate-workflow-execution.js"),
     import("./activities/workflow-event-activities.js"),
     import("./activities/promote-task-output.js"),
+    import("./activities/attach-session.js"),
   ]);
 
   return {
@@ -356,6 +370,7 @@ async function createAllActivities(config: Config): Promise<WorkerActivities> {
     ...createHydrateWorkflowActivities(config),
     ...createWorkflowEventActivities(),
     ...createPromoteTaskOutputActivities(),
+    ...createAttachSessionActivities(config),
   };
 }
 

package/src/shared/__tests__/cold-start-timing.test.ts

@@ -0,0 +1,271 @@
+/**
+ * Unit tests for the cold-start timing instrumentation.
+ *
+ * The warm-agent-surfaces baseline report derives its waterfall from these
+ * emissions, so the invariants pinned here are load-bearing for a spend
+ * decision: segments must partition the timeline (total == sum, no gaps),
+ * the emitted line must keep its stable shape (`stigmer_timing` selector,
+ * context spread, `segments` with per-segment `start_ms`/`duration_ms`),
+ * and the process-boot timeline must emit exactly once — a worker restart
+ * inside one process must never produce a bogus second timeline.
+ *
+ * The boot singleton is module-level state, so those tests re-import the
+ * module fresh via `vi.resetModules()` to get an unlatched instance.
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { TimingRecorder, emitTimingLog, recordTimingMetric } from "../cold-start-timing.js";
+
+/**
+ * Captures histogram records made through the instrument registry, so the
+ * metric-mirror tests can assert on instrument choice and attribute
+ * whitelisting. `failGetInstruments` simulates a broken registry to pin the
+ * "telemetry never breaks the runner" posture.
+ */
+const metricsMock = vi.hoisted(() => ({
+  recorded: [] as Array<{ instrument: string; value: number; attrs?: Record<string, string> }>,
+  failGetInstruments: false,
+}));
+
+vi.mock("../../otel-metrics.js", () => ({
+  getInstruments: async () => {
+    if (metricsMock.failGetInstruments) {
+      throw new Error("registry unavailable");
+    }
+    const capture = (instrument: string) => ({
+      record: (value: number, attrs?: Record<string, string>) => {
+        metricsMock.recorded.push({ instrument, value, attrs });
+      },
+    });
+    return {
+      runnerBootDuration: capture("runner_boot"),
+      executionSetupDuration: capture("execution_setup"),
+      poolAttachDuration: capture("pool_attach"),
+    };
+  },
+}));
+
+/** Parse the single JSON line the mocked console.log captured. */
+function loggedJson(spy: ReturnType<typeof vi.spyOn>): Record<string, unknown> {
+  expect(spy).toHaveBeenCalledTimes(1);
+  return JSON.parse(spy.mock.calls[0]![0] as string);
+}
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("TimingRecorder", () => {
+  it("partitions the timeline: total equals the sum of segment durations", () => {
+    const recorder = new TimingRecorder();
+    recorder.mark("first");
+    recorder.mark("second");
+    recorder.mark("third");
+
+    const segments = recorder.snapshot();
+    expect(segments.map((s) => s.name)).toEqual(["first", "second", "third"]);
+
+    const sum = segments.reduce((acc, s) => acc + s.durationMs, 0);
+    // Each value is independently rounded to 0.1ms, so allow rounding drift.
+    expect(Math.abs(recorder.totalMs() - sum)).toBeLessThanOrEqual(
+      0.05 * (segments.length + 1),
+    );
+  });
+
+  it("leaves no gaps: each segment starts where the previous one ended", () => {
+    const recorder = new TimingRecorder();
+    recorder.mark("a");
+    recorder.mark("b");
+    recorder.mark("c");
+
+    const segments = recorder.snapshot();
+    for (let i = 1; i < segments.length; i++) {
+      const previousEnd = segments[i - 1]!.startMs + segments[i - 1]!.durationMs;
+      expect(Math.abs(segments[i]!.startMs - previousEnd)).toBeLessThanOrEqual(0.11);
+    }
+    expect(segments[0]!.startMs).toBe(0);
+  });
+
+  it("measures offsets from an explicit origin (the process-boot case)", () => {
+    const recorder = new TimingRecorder(0);
+    recorder.mark("node_start");
+    // Origin 0 means the first segment's duration covers everything since
+    // process start — it must be a real, positive elapsed time.
+    expect(recorder.snapshot()[0]!.durationMs).toBeGreaterThan(0);
+    expect(recorder.totalMs()).toBeGreaterThan(0);
+  });
+
+  it("reports zero total before any mark", () => {
+    expect(new TimingRecorder().totalMs()).toBe(0);
+    expect(new TimingRecorder().snapshot()).toHaveLength(0);
+  });
+});
+
+describe("emitTimingLog", () => {
+  it("emits one line with the stable shape the baseline report parses", () => {
+    const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+    const recorder = new TimingRecorder();
+    recorder.mark("only_segment");
+
+    emitTimingLog("execution_setup", {
+      execution_id: "exe_123",
+      session_id: "ses_456",
+      harness: "cursor",
+      skipped: undefined,
+      nullable: null,
+    }, recorder);
+
+    const line = loggedJson(spy);
+    expect(line.stigmer_timing).toBe("execution_setup");
+    expect(line.execution_id).toBe("exe_123");
+    expect(line.session_id).toBe("ses_456");
+    // undefined context values are dropped by JSON.stringify; null survives.
+    expect("skipped" in line).toBe(false);
+    expect(line.nullable).toBeNull();
+    expect(line.total_ms).toBeTypeOf("number");
+
+    const segments = line.segments as Array<Record<string, unknown>>;
+    expect(segments).toHaveLength(1);
+    expect(segments[0]!.name).toBe("only_segment");
+    expect(segments[0]!.start_ms).toBeTypeOf("number");
+    expect(segments[0]!.duration_ms).toBeTypeOf("number");
+  });
+
+  it("never throws, even when the payload cannot be serialized", () => {
+    const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+    const cyclic: Record<string, unknown> = {};
+    cyclic.self = cyclic;
+
+    expect(() =>
+      // The context type forbids objects, but telemetry must survive a caller
+      // getting it wrong at runtime — that is the module's stated posture.
+      emitTimingLog("evt", cyclic as never, new TimingRecorder()),
+    ).not.toThrow();
+    expect(spy).not.toHaveBeenCalled();
+  });
+});
+
+describe("timing metrics mirror", () => {
+  beforeEach(() => {
+    metricsMock.recorded.length = 0;
+    metricsMock.failGetInstruments = false;
+  });
+
+  it("mirrors each mapped timeline onto its histogram with whitelisted attrs only", async () => {
+    recordTimingMetric("runner_boot", {
+      mode: "cloud",
+      pool_member_id: "pm_secret",
+      task_queue: "sandbox:pm_secret",
+    }, 6200);
+    recordTimingMetric("execution_setup", {
+      harness: "cursor",
+      execution_id: "exe_123",
+      session_id: "ses_456",
+    }, 3000);
+    recordTimingMetric("pool_attach", {
+      pool_member_id: "pm_secret",
+      session_id: "ses_456",
+    }, 400);
+
+    await vi.waitFor(() => expect(metricsMock.recorded).toHaveLength(3));
+
+    const byInstrument = Object.fromEntries(
+      metricsMock.recorded.map((r) => [r.instrument, r]),
+    );
+    expect(byInstrument.runner_boot!.value).toBe(6200);
+    // The whitelist is the cardinality guard: ids must never become attrs.
+    expect(byInstrument.runner_boot!.attrs).toEqual({ mode: "cloud" });
+    expect(byInstrument.execution_setup!.value).toBe(3000);
+    expect(byInstrument.execution_setup!.attrs).toEqual({ harness: "cursor" });
+    expect(byInstrument.pool_attach!.value).toBe(400);
+    expect(byInstrument.pool_attach!.attrs).toBeUndefined();
+  });
+
+  it("emitTimingLog drives the mirror, so call sites need no metric code", async () => {
+    vi.spyOn(console, "log").mockImplementation(() => {});
+    const recorder = new TimingRecorder();
+    recorder.mark("only_segment");
+
+    emitTimingLog("execution_setup", { harness: "native", execution_id: "exe_1" }, recorder);
+
+    await vi.waitFor(() => expect(metricsMock.recorded).toHaveLength(1));
+    expect(metricsMock.recorded[0]!.instrument).toBe("execution_setup");
+    expect(metricsMock.recorded[0]!.attrs).toEqual({ harness: "native" });
+  });
+
+  it("records nothing for unmapped events (control-plane timelines)", async () => {
+    recordTimingMetric("execution_create", { org: "acme" }, 500);
+    recordTimingMetric("pool_attach", {}, 1);
+
+    // The mapped event landing proves the unmapped one was skipped, without
+    // relying on an arbitrary sleep.
+    await vi.waitFor(() => expect(metricsMock.recorded).toHaveLength(1));
+    expect(metricsMock.recorded[0]!.instrument).toBe("pool_attach");
+  });
+
+  it("survives a broken instrument registry without throwing or logging", async () => {
+    metricsMock.failGetInstruments = true;
+
+    expect(() => recordTimingMetric("runner_boot", { mode: "cloud" }, 100)).not.toThrow();
+    // Give the floating promise a tick to reject and be swallowed.
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    expect(metricsMock.recorded).toHaveLength(0);
+  });
+});
+
+describe("boot timeline singleton", () => {
+  // Each test re-imports the module for a fresh, unlatched singleton.
+  async function freshModule() {
+    vi.resetModules();
+    return import("../cold-start-timing.js");
+  }
+
+  it("emits runner_boot exactly once; later emits are no-ops", async () => {
+    const mod = await freshModule();
+    const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+    mod.markBoot("config_loaded");
+    mod.emitRunnerBootTiming({ task_queue: "session:ses_1", mode: "cloud" });
+    mod.emitRunnerBootTiming({ task_queue: "session:ses_1", mode: "cloud" });
+
+    const line = loggedJson(spy);
+    expect(line.stigmer_timing).toBe("runner_boot");
+    expect(line.task_queue).toBe("session:ses_1");
+  });
+
+  it("ignores marks after the boot timeline has emitted", async () => {
+    const mod = await freshModule();
+    const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+    mod.markBoot("config_loaded");
+    mod.markBoot("worker_polling");
+    mod.emitRunnerBootTiming({ mode: "cloud" });
+    mod.markBoot("late_mark_must_not_appear");
+
+    const line = loggedJson(spy);
+    const names = (line.segments as Array<{ name: string }>).map((s) => s.name);
+    expect(names).toEqual(["config_loaded", "worker_polling"]);
+  });
+
+  it("closes the timeline at the final mark: total covers every named span", async () => {
+    const mod = await freshModule();
+    const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+    mod.markBoot("worker_created");
+    await new Promise((resolve) => setTimeout(resolve, 5));
+    mod.markBoot("worker_polling");
+    mod.emitRunnerBootTiming({ mode: "cloud" });
+
+    const line = loggedJson(spy);
+    const segments = line.segments as Array<{ name: string; duration_ms: number }>;
+    const last = segments[segments.length - 1]!;
+    // The regression this pins: without a final mark before emit, the
+    // worker_created → polling span would vanish from total_ms entirely.
+    expect(last.name).toBe("worker_polling");
+    expect(last.duration_ms).toBeGreaterThan(0);
+    const sum = segments.reduce((acc, s) => acc + s.duration_ms, 0);
+    expect(Math.abs((line.total_ms as number) - sum)).toBeLessThanOrEqual(
+      0.05 * (segments.length + 1),
+    );
+  });
+});

package/src/shared/__tests__/connect-backfill.test.ts

@@ -124,7 +124,7 @@ describe("backfillMcpServersIfNeeded", () => {
     const client = makeMockClient();
 
     const result = await backfillMcpServersIfNeeded(
-      client, servers, [], {}, "org",
+      client, servers, [], {}, "org", "stdio-allowed",
     );
 
     expect(result).toBe(servers);
@@ -137,7 +137,7 @@ describe("backfillMcpServersIfNeeded", () => {
     const client = makeMockClient();
 
     const result = await backfillMcpServersIfNeeded(
-      client, servers, [], {}, "org",
+      client, servers, [], {}, "org", "stdio-allowed",
     );
 
     expect(result).toBe(servers);
@@ -155,7 +155,7 @@ describe("backfillMcpServersIfNeeded", () => {
     });
 
     const result = await backfillMcpServersIfNeeded(
-      client, servers, usages, {}, "org",
+      client, servers, usages, {}, "org", "stdio-allowed",
     );
 
     expect(client.getMcpServerByReference).toHaveBeenCalledOnce();
@@ -181,7 +181,7 @@ describe("backfillMcpServersIfNeeded", () => {
     });
 
     const result = await backfillMcpServersIfNeeded(
-      client, servers, usages, {}, "org",
+      client, servers, usages, {}, "org", "stdio-allowed",
     );
 
     expect(client.connectMcpServer).toHaveBeenCalledOnce();
@@ -206,7 +206,7 @@ describe("backfillMcpServersIfNeeded", () => {
     });
 
     await backfillMcpServersIfNeeded(
-      client, servers, usages, mergedEnv, "org",
+      client, servers, usages, mergedEnv, "org", "stdio-allowed",
     );
 
     expect(client.connectMcpServer).toHaveBeenCalledWith(
@@ -224,7 +224,7 @@ describe("backfillMcpServersIfNeeded", () => {
     });
 
     const result = await backfillMcpServersIfNeeded(
-      client, servers, usages, {}, "org",
+      client, servers, usages, {}, "org", "stdio-allowed",
     );
 
     expect(result).toBe(servers);
@@ -242,7 +242,7 @@ describe("backfillMcpServersIfNeeded", () => {
     });
 
     const result = await backfillMcpServersIfNeeded(
-      client, servers, usages, {}, "org",
+      client, servers, usages, {}, "org", "stdio-allowed",
     );
 
     expect(result).toBe(servers);
@@ -261,7 +261,7 @@ describe("backfillMcpServersIfNeeded", () => {
     });
 
     await backfillMcpServersIfNeeded(
-      client, servers, usages, {}, "org", onHeartbeat,
+      client, servers, usages, {}, "org", "stdio-allowed", onHeartbeat,
     );
 
     expect(onHeartbeat).toHaveBeenCalledTimes(2);
@@ -274,7 +274,7 @@ describe("backfillMcpServersIfNeeded", () => {
     const client = makeMockClient();
 
     const result = await backfillMcpServersIfNeeded(
-      client, servers, [], {}, "org",
+      client, servers, [], {}, "org", "stdio-allowed",
     );
 
     expect(client.getMcpServerByReference).not.toHaveBeenCalled();
@@ -294,7 +294,7 @@ describe("backfillMcpServersIfNeeded", () => {
     });
 
     const result = await backfillMcpServersIfNeeded(
-      client, servers, usages, {}, "org",
+      client, servers, usages, {}, "org", "stdio-allowed",
     );
 
     expect(client.connectMcpServer).not.toHaveBeenCalled();
@@ -337,7 +337,7 @@ describe("backfillMcpServersIfNeeded", () => {
     });
 
     const result = await backfillMcpServersIfNeeded(
-      client, servers, usages, {}, "org",
+      client, servers, usages, {}, "org", "stdio-allowed",
     );
 
     expect(callCount).toBe(2);

package/src/shared/__tests__/mcp-manager.test.ts

@@ -1,9 +1,5 @@
-import { describe, it, expect, vi } from "vitest";
-import {
-  isCloudCompatibleCommand,
-  warnCloudIncompatibleServers,
-  toMcpClientConfig,
-} from "../mcp-manager.js";
+import { describe, it, expect } from "vitest";
+import { toMcpClientConfig } from "../mcp-manager.js";
 import type { ResolvedMcpServer } from "../mcp-resolver.js";
 
 function makeServer(overrides: Partial<ResolvedMcpServer>): ResolvedMcpServer {
@@ -17,73 +13,6 @@ function makeServer(overrides: Partial<ResolvedMcpServer>): ResolvedMcpServer {
   };
 }
 
-describe("isCloudCompatibleCommand", () => {
-  it.each(["npx", "node", "uvx", "python", "python3"])(
-    "returns true for '%s'",
-    (cmd) => {
-      expect(isCloudCompatibleCommand(cmd)).toBe(true);
-    },
-  );
-
-  it.each(["/usr/local/bin/npx", "/home/user/.local/bin/uvx"])(
-    "returns true for full paths to known commands: '%s'",
-    (cmd) => {
-      expect(isCloudCompatibleCommand(cmd)).toBe(true);
-    },
-  );
-
-  it.each(["go", "my-custom-binary", "/usr/bin/mcp-server", "docker"])(
-    "returns false for '%s'",
-    (cmd) => {
-      expect(isCloudCompatibleCommand(cmd)).toBe(false);
-    },
-  );
-});
-
-describe("warnCloudIncompatibleServers", () => {
-  it("does nothing when not in cloud mode", () => {
-    const spy = vi.spyOn(console, "warn").mockImplementation(() => {});
-    warnCloudIncompatibleServers(
-      [makeServer({ command: "go", connectionType: "stdio" })],
-      false,
-    );
-    expect(spy).not.toHaveBeenCalled();
-    spy.mockRestore();
-  });
-
-  it("warns for non-installable stdio commands in cloud mode", () => {
-    const spy = vi.spyOn(console, "warn").mockImplementation(() => {});
-    warnCloudIncompatibleServers(
-      [makeServer({ slug: "custom", command: "my-binary", connectionType: "stdio" })],
-      true,
-    );
-    expect(spy).toHaveBeenCalledOnce();
-    expect(spy.mock.calls[0][0]).toContain("my-binary");
-    expect(spy.mock.calls[0][0]).toContain("custom");
-    spy.mockRestore();
-  });
-
-  it("does not warn for npx commands in cloud mode", () => {
-    const spy = vi.spyOn(console, "warn").mockImplementation(() => {});
-    warnCloudIncompatibleServers(
-      [makeServer({ command: "npx", connectionType: "stdio" })],
-      true,
-    );
-    expect(spy).not.toHaveBeenCalled();
-    spy.mockRestore();
-  });
-
-  it("does not warn for HTTP servers in cloud mode", () => {
-    const spy = vi.spyOn(console, "warn").mockImplementation(() => {});
-    warnCloudIncompatibleServers(
-      [makeServer({ connectionType: "http", url: "https://mcp.example.com" })],
-      true,
-    );
-    expect(spy).not.toHaveBeenCalled();
-    spy.mockRestore();
-  });
-});
-
 describe("toMcpClientConfig", () => {
   it("maps stdio servers to the client config format", () => {
     const servers = [