@stigmer/runner 3.40.1 → 3.41.0

package/src/activities/__tests__/discover-mcp-server.test.ts

@@ -4,6 +4,10 @@ import type {
   DiscoveredToolResult,
   DiscoverMcpServerOutput,
 } from "../discover-mcp-server.js";
+import { testConfig } from "../../__test-utils__/config-fixture.js";
+
+/** The runner endpoints discovery fills STIGMER_SERVER_ADDRESS from. */
+const PLATFORM_ENDPOINTS = testConfig();
 
 vi.mock("../../idle-watchdog.js", () => ({
   activityStarted: vi.fn(),
@@ -221,47 +225,83 @@ describe("DiscoverMcpServer activity", () => {
   });
 
   // ─────────────────────────────────────────────────────────────────────────
-  // injectPlatformEnv
+  // STIGMER_SERVER_ADDRESS — the platform fill (shared/platform-server-address.ts)
   // ─────────────────────────────────────────────────────────────────────────
 
-  describe("injectPlatformEnv", () => {
-    const savedEnv = process.env;
+  describe("the platform STIGMER_SERVER_ADDRESS fill", () => {
+    async function connectionConfigFor(
+      spec: any,
+      executionContext: any,
+      platformEndpoints = PLATFORM_ENDPOINTS,
+    ): Promise<any> {
+      const { discoverMcpServer } = await import("../discover-mcp-server.js");
+      const { MultiServerMCPClient } = await import("@langchain/mcp-adapters");
+      const mockClient = makeMockStigmerClient({
+        mcpServer: makeMcpServer({ metadata: { slug: "stigmer" }, spec }),
+        executionContext,
+      });
+      mockInitializeConnections.mockResolvedValue({});
+      mockGetClient.mockResolvedValue(makeMockMcpClient({ tools: [] }));
+      await discoverMcpServer(
+        { mcpServerId: "mcp-stigmer", executionContextId: "ctx-addr" },
+        { stigmerClient: mockClient as any, transportPosture: "stdio-allowed", platformEndpoints },
+      );
+      return (vi.mocked(MultiServerMCPClient).mock.calls[0][0] as any).stigmer;
+    }
+
+    it("fills a stdio server's required address from the backend endpoint instead of failing closed", async () => {
+      const spec = makeStdioSpec("stigmer", ["mcp-server"]);
+      spec.env = { STIGMER_SERVER_ADDRESS: { description: "gRPC host:port" } };
 
-    afterEach(() => {
-      process.env = savedEnv;
-    });
+      const config = await connectionConfigFor(spec, { spec: { data: {} } });
 
-    it("returns envVars unchanged when no declared keys match", async () => {
-      const { injectPlatformEnv } = await import("../discover-mcp-server.js");
-      const env = { SOME_KEY: "value" };
-      const result = injectPlatformEnv(new Set(["SOME_KEY"]), env);
-      expect(result).toBe(env);
+      // testConfig's backend endpoint is http://127.0.0.1:1.
+      expect(config.env.STIGMER_SERVER_ADDRESS).toBe("127.0.0.1:1");
     });
 
-    it("injects STIGMER_SERVER_ADDRESS from STIGMER_MCP_PUBLIC_ENDPOINT", async () => {
-      const { injectPlatformEnv } = await import("../discover-mcp-server.js");
-      process.env = { ...savedEnv, STIGMER_MCP_PUBLIC_ENDPOINT: "https://mcp.stigmer.ai" };
-      const result = injectPlatformEnv(
-        new Set(["STIGMER_SERVER_ADDRESS"]),
-        { STIGMER_SERVER_ADDRESS: "stale-value" },
+    it("keeps an address the execution context delivered", async () => {
+      const spec = makeStdioSpec("stigmer", ["mcp-server"]);
+      spec.env = { STIGMER_SERVER_ADDRESS: { description: "gRPC host:port" } };
+
+      const config = await connectionConfigFor(
+        spec,
+        { spec: { data: { STIGMER_SERVER_ADDRESS: { value: "other.example:7234" } } } },
+        testConfig({ mcpPublicEndpoint: "https://api.example.com" }),
       );
-      expect(result.STIGMER_SERVER_ADDRESS).toBe("https://mcp.stigmer.ai");
+
+      expect(config.env.STIGMER_SERVER_ADDRESS).toBe("other.example:7234");
     });
 
-    it("does not inject when source env var is not set", async () => {
-      const { injectPlatformEnv } = await import("../discover-mcp-server.js");
-      process.env = { ...savedEnv };
-      delete process.env.STIGMER_MCP_PUBLIC_ENDPOINT;
-      const env = { STIGMER_SERVER_ADDRESS: "original" };
-      const result = injectPlatformEnv(new Set(["STIGMER_SERVER_ADDRESS"]), env);
-      expect(result).toBe(env);
+    it("templates an http server's header from the operator's public endpoint", async () => {
+      const spec = makeHttpSpec("https://mcp.example.com");
+      spec.serverType.value.headers = { "X-Stigmer-Server": "${STIGMER_SERVER_ADDRESS}" };
+      spec.env = { STIGMER_SERVER_ADDRESS: {} };
+
+      const config = await connectionConfigFor(
+        spec,
+        { spec: { data: {} } },
+        testConfig({ mcpPublicEndpoint: "https://api.example.com" }),
+      );
+
+      expect(config.headers["X-Stigmer-Server"]).toBe("api.example.com:443");
     });
 
-    it("returns envVars unchanged when declaredEnvKeys is empty", async () => {
-      const { injectPlatformEnv } = await import("../discover-mcp-server.js");
-      const env = { SOME_KEY: "value" };
-      const result = injectPlatformEnv(new Set(), env);
-      expect(result).toBe(env);
+    it("never hands an http server the backend endpoint: without a public one its required address is a credential the connect flow owes", async () => {
+      const { discoverMcpServer, CredentialResolutionError } = await import("../discover-mcp-server.js");
+      const spec = makeHttpSpec("https://mcp.example.com");
+      spec.env = { STIGMER_SERVER_ADDRESS: {} };
+      const mockClient = makeMockStigmerClient({
+        mcpServer: makeMcpServer({ metadata: { slug: "stigmer" }, spec }),
+        executionContext: { spec: { data: {} } },
+      });
+
+      const promise = discoverMcpServer(
+        { mcpServerId: "mcp-stigmer", executionContextId: "ctx-addr" },
+        { stigmerClient: mockClient as any, transportPosture: "stdio-allowed", platformEndpoints: PLATFORM_ENDPOINTS },
+      );
+
+      await expect(promise).rejects.toThrow(CredentialResolutionError);
+      await expect(promise).rejects.toThrow(/STIGMER_SERVER_ADDRESS/);
     });
   });
 
@@ -291,7 +331,7 @@ describe("DiscoverMcpServer activity", () => {
 
       const result = await discoverMcpServer(
         { mcpServerId: "mcp-123" },
-        { stigmerClient: mockClient as any, transportPosture: "stdio-allowed" },
+        { stigmerClient: mockClient as any, transportPosture: "stdio-allowed", platformEndpoints: PLATFORM_ENDPOINTS },
       );
 
       expect(result.tools).toHaveLength(2);
@@ -320,7 +360,7 @@ describe("DiscoverMcpServer activity", () => {
       await expect(
         discoverMcpServer(
           { mcpServerId: "mcp-123" },
-          { stigmerClient: mockClient as any, transportPosture: "stdio-forbidden" },
+          { stigmerClient: mockClient as any, transportPosture: "stdio-forbidden", platformEndpoints: PLATFORM_ENDPOINTS },
         ),
       ).rejects.toThrow(McpTransportError);
       expect(mockInitializeConnections).not.toHaveBeenCalled();
@@ -348,7 +388,7 @@ describe("DiscoverMcpServer activity", () => {
 
       const result = await discoverMcpServer(
         { mcpServerId: "mcp-456" },
-        { stigmerClient: mockClient as any, transportPosture: "stdio-allowed" },
+        { stigmerClient: mockClient as any, transportPosture: "stdio-allowed", platformEndpoints: PLATFORM_ENDPOINTS },
       );
 
       expect(result.tools).toHaveLength(1);
@@ -369,7 +409,7 @@ describe("DiscoverMcpServer activity", () => {
       });
 
       await expect(
-        discoverMcpServer({ mcpServerId: "mcp-bad" }, { stigmerClient: mockClient as any, transportPosture: "stdio-allowed" }),
+        discoverMcpServer({ mcpServerId: "mcp-bad" }, { stigmerClient: mockClient as any, transportPosture: "stdio-allowed", platformEndpoints: PLATFORM_ENDPOINTS }),
       ).rejects.toThrow("not found or has no spec");
     });
 
@@ -384,7 +424,7 @@ describe("DiscoverMcpServer activity", () => {
       });
 
       await expect(
-        discoverMcpServer({ mcpServerId: "mcp-noconfig" }, { stigmerClient: mockClient as any, transportPosture: "stdio-allowed" }),
+        discoverMcpServer({ mcpServerId: "mcp-noconfig" }, { stigmerClient: mockClient as any, transportPosture: "stdio-allowed", platformEndpoints: PLATFORM_ENDPOINTS }),
       ).rejects.toThrow("no valid server type configured");
     });
 
@@ -412,7 +452,7 @@ describe("DiscoverMcpServer activity", () => {
 
       const result = await discoverMcpServer(
         { mcpServerId: "mcp-env", executionContextId: "ctx-abc" },
-        { stigmerClient: mockClient as any, transportPosture: "stdio-allowed" },
+        { stigmerClient: mockClient as any, transportPosture: "stdio-allowed", platformEndpoints: PLATFORM_ENDPOINTS },
       );
 
       expect(result.tools).toEqual([]);
@@ -448,7 +488,7 @@ describe("DiscoverMcpServer activity", () => {
           executionContextId: "ctx-abc",
           executionContextToken: "scoped-ec-token",
         },
-        { stigmerClient: mockClient as any, transportPosture: "stdio-allowed" },
+        { stigmerClient: mockClient as any, transportPosture: "stdio-allowed", platformEndpoints: PLATFORM_ENDPOINTS },
       );
 
       expect(mockClient.getExecutionContextByExecutionId).toHaveBeenCalledWith(
@@ -494,7 +534,7 @@ describe("DiscoverMcpServer activity", () => {
 
       const result = await discoverMcpServer(
         { mcpServerId: "mcp-isc", executionContextId: "ctx-isc" },
-        { stigmerClient: mockClient as any, transportPosture: "stdio-forbidden" },
+        { stigmerClient: mockClient as any, transportPosture: "stdio-forbidden", platformEndpoints: PLATFORM_ENDPOINTS },
       );
 
       expect(result.tools).toHaveLength(1);
@@ -522,7 +562,7 @@ describe("DiscoverMcpServer activity", () => {
 
       await discoverMcpServer(
         { mcpServerId: "mcp-no-env" },
-        { stigmerClient: mockClient as any, transportPosture: "stdio-allowed" },
+        { stigmerClient: mockClient as any, transportPosture: "stdio-allowed", platformEndpoints: PLATFORM_ENDPOINTS },
       );
 
       expect(mockClient.getExecutionContextByExecutionId).not.toHaveBeenCalled();
@@ -548,7 +588,7 @@ describe("DiscoverMcpServer activity", () => {
 
       const result = await discoverMcpServer(
         { mcpServerId: "mcp-no-res" },
-        { stigmerClient: mockClient as any, transportPosture: "stdio-allowed" },
+        { stigmerClient: mockClient as any, transportPosture: "stdio-allowed", platformEndpoints: PLATFORM_ENDPOINTS },
       );
 
       expect(result.tools).toHaveLength(1);
@@ -582,7 +622,7 @@ describe("DiscoverMcpServer activity", () => {
 
       const result = await discoverMcpServer(
         { mcpServerId: "mcp-existing" },
-        { stigmerClient: mockClient as any, transportPosture: "stdio-allowed" },
+        { stigmerClient: mockClient as any, transportPosture: "stdio-allowed", platformEndpoints: PLATFORM_ENDPOINTS },
       );
 
       expect(result.previousToolsFingerprint).not.toBe("");
@@ -617,7 +657,7 @@ describe("DiscoverMcpServer activity", () => {
 
       const result = await discoverMcpServer(
         { mcpServerId: "mcp-fp" },
-        { stigmerClient: mockClient as any, transportPosture: "stdio-allowed" },
+        { stigmerClient: mockClient as any, transportPosture: "stdio-allowed", platformEndpoints: PLATFORM_ENDPOINTS },
       );
 
       const expected = toolsFingerprint(result.tools);
@@ -640,7 +680,7 @@ describe("DiscoverMcpServer activity", () => {
 
       const result = await discoverMcpServer(
         { mcpServerId: "mcp-empty" },
-        { stigmerClient: mockClient as any, transportPosture: "stdio-allowed" },
+        { stigmerClient: mockClient as any, transportPosture: "stdio-allowed", platformEndpoints: PLATFORM_ENDPOINTS },
       );
 
       expect(result.newToolsFingerprint).toBe("");
@@ -665,7 +705,7 @@ describe("DiscoverMcpServer activity", () => {
       await expect(
         discoverMcpServer(
           { mcpServerId: "mcp-monday", executionContextId: "ctx-1" },
-          { stigmerClient: mockClient as any, transportPosture: "stdio-forbidden" },
+          { stigmerClient: mockClient as any, transportPosture: "stdio-forbidden", platformEndpoints: PLATFORM_ENDPOINTS },
         ),
       ).rejects.toThrow(CredentialResolutionError);
       expect(mockInitializeConnections).not.toHaveBeenCalled();
@@ -689,7 +729,7 @@ describe("DiscoverMcpServer activity", () => {
 
       const result = await discoverMcpServer(
         { mcpServerId: "mcp-lenient", executionContextId: "ctx-2" },
-        { stigmerClient: mockClient as any, transportPosture: "stdio-forbidden" },
+        { stigmerClient: mockClient as any, transportPosture: "stdio-forbidden", platformEndpoints: PLATFORM_ENDPOINTS },
       );
       expect(result.tools).toEqual([]);
     });
@@ -714,7 +754,7 @@ describe("DiscoverMcpServer activity", () => {
 
       const result = await discoverMcpServer(
         { mcpServerId: "mcp-optional", executionContextId: "ctx-3" },
-        { stigmerClient: mockClient as any, transportPosture: "stdio-forbidden" },
+        { stigmerClient: mockClient as any, transportPosture: "stdio-forbidden", platformEndpoints: PLATFORM_ENDPOINTS },
       );
       expect(result.tools).toEqual([]);
     });
@@ -731,7 +771,7 @@ describe("DiscoverMcpServer activity", () => {
 
       const promise = discoverMcpServer(
         { mcpServerId: "mcp-monday", executionContextId: "ctx-4" },
-        { stigmerClient: mockClient as any, transportPosture: "stdio-forbidden" },
+        { stigmerClient: mockClient as any, transportPosture: "stdio-forbidden", platformEndpoints: PLATFORM_ENDPOINTS },
       );
       await expect(promise).rejects.toThrow(CredentialResolutionError);
       await expect(promise).rejects.toThrow(/delivered no credentials/);
@@ -755,7 +795,7 @@ describe("DiscoverMcpServer activity", () => {
 
       const promise = discoverMcpServer(
         { mcpServerId: "mcp-monday", executionContextId: "ctx-5" },
-        { stigmerClient: mockClient as any, transportPosture: "stdio-forbidden" },
+        { stigmerClient: mockClient as any, transportPosture: "stdio-forbidden", platformEndpoints: PLATFORM_ENDPOINTS },
       );
       await expect(promise).rejects.toThrow(CredentialResolutionError);
       await expect(promise).rejects.toThrow(/MONDAY_ACCESS_TOKEN.*delivered redacted|delivered redacted.*MONDAY_ACCESS_TOKEN/s);
@@ -775,7 +815,7 @@ describe("DiscoverMcpServer activity", () => {
       mockInitializeConnections.mockRejectedValue(new Error("Connection refused"));
 
       await expect(
-        discoverMcpServer({ mcpServerId: "mcp-fail" }, { stigmerClient: mockClient as any, transportPosture: "stdio-allowed" }),
+        discoverMcpServer({ mcpServerId: "mcp-fail" }, { stigmerClient: mockClient as any, transportPosture: "stdio-allowed", platformEndpoints: PLATFORM_ENDPOINTS }),
       ).rejects.toThrow("Connection refused");
 
       expect(mockClose).toHaveBeenCalled();
@@ -903,6 +943,7 @@ function makeConfig() {
     temporalConnection: {},
     stigmerBackendEndpoint: "http://localhost:7234",
   mcpBridgeEndpoint: null,
+    mcpPublicEndpoint: null,
     stigmerTokenRef: { current: "test-token" },
     cursorApiKey: "",
     workspaceRootDir: "/tmp/test",

package/src/activities/__tests__/workflow-event-activities.test.ts

@@ -4,6 +4,7 @@ import { StigmerClient } from "../../client/stigmer-client.js";
 import { WorkflowEventType } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/event_pb";
 import { WorkflowTaskKind } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/enum_pb";
 import { WorkflowTaskStatus } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/enum_pb";
+import { ApprovalAction } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import type { WorkflowEventDescriptor } from "../../workflow-engine/types.js";
 
 const mockGetEventLogHighWaterMark = vi.fn<(executionId: string) => Promise<bigint>>();
@@ -648,7 +649,7 @@ describe("toProtoEvent", () => {
       expect(actor!.avatar).toBe("https://example.com/ada.png");
     });
 
-    it("does not map outcome or autoResolved (proto limitation)", () => {
+    it("maps the chosen outcome and a human decision's autoResolved=false", () => {
       const evt = toProtoEvent({
         type: "approval_resolved",
         taskName: "gate",
@@ -657,16 +658,36 @@ describe("toProtoEvent", () => {
         resolvedBy: "bob",
         comment: "",
         waitDurationMs: 1000,
+        autoResolved: false,
+      });
+
+      if (evt.payload.case !== "approvalResolved") throw new Error("unexpected");
+      const p = evt.payload.value;
+      expect(p.outcome).toBe("needs_revision");
+      expect(p.autoResolved).toBe(false);
+      // A human_input gate's outcome is a declared string, never mapped onto
+      // the agent ApprovalAction enum: action stays unset.
+      expect(p.action).toBe(ApprovalAction.UNSPECIFIED);
+    });
+
+    it("maps a timeout auto-resolution: the policy's outcome, autoResolved, no reviewer", () => {
+      const evt = toProtoEvent({
+        type: "approval_resolved",
+        taskName: "gate",
+        occurredAt: NOW,
+        outcome: "escalate",
+        resolvedBy: "",
+        comment: "",
+        waitDurationMs: 5000,
         autoResolved: true,
       });
 
       if (evt.payload.case !== "approvalResolved") throw new Error("unexpected");
-      // action field stays at default (UNSPECIFIED) because toProtoEvent
-      // does not map the string outcome to ApprovalAction enum.
-      // autoResolved has no corresponding proto field.
-      // This documents the current limitation per Finding #2.
-      expect(evt.payload.value.resolvedBy).toBe("bob");
-      expect(evt.payload.value.waitDurationMs).toBe(BigInt(1000));
+      const p = evt.payload.value;
+      expect(p.outcome).toBe("escalate");
+      expect(p.autoResolved).toBe(true);
+      expect(p.resolvedBy).toBe("");
+      expect(p.resolvedByActor).toBeUndefined();
     });
   });
 

package/src/activities/call-agent.ts

@@ -228,7 +228,7 @@ export async function callAgentAction(
   // the author may set is forwarded to a field the runner enforces.
   // model_name replaces the agent's default outright; max_cost_usd feeds
   // the turn runtime's cost guard (shared/cost-guard.ts, both harnesses);
-  // max_tool_rounds feeds resolveRecursionLimit (native
+  // max_tool_rounds feeds resolveToolRoundLimit (native
   // harness only); service_tier and thinking_mode feed the cursor
   // harness's explicit variant selection (issues #357/#772). Zero/unset
   // means "no override" and is omitted.

package/src/activities/discover-mcp-server.ts

@@ -31,6 +31,12 @@ import {
 } from "../shared/mcp-transport-guard.js";
 import { detectOAuthChallenge } from "../shared/mcp-oauth-detect.js";
 import { injectAnonymousCallerIdentityForDiscovery } from "../shared/caller-identity.js";
+import {
+  fillPlatformServerAddress,
+  platformServerAddress,
+  SERVER_ADDRESS_ENV_KEY,
+  type PlatformEndpoints,
+} from "../shared/platform-server-address.js";
 import { startHeartbeat } from "../shared/heartbeat.js";
 import { withTimeout } from "../shared/with-timeout.js";
 import type { McpServer } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
@@ -70,10 +76,6 @@ const STDIO_INIT_TIMEOUT_MS = 270_000;
  */
 const REDACTED_MARKER = "***REDACTED***";
 
-const PLATFORM_INJECTABLE_MAP: Record<string, string> = {
-  STIGMER_SERVER_ADDRESS: "STIGMER_MCP_PUBLIC_ENDPOINT",
-};
-
 // ─────────────────────────────────────────────────────────────────────────────
 // Types
 // ─────────────────────────────────────────────────────────────────────────────
@@ -237,36 +239,6 @@ function structToPlainObject(struct: unknown): Record<string, unknown> | null {
   }
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Platform Env Injection
-// ─────────────────────────────────────────────────────────────────────────────
-
-export function injectPlatformEnv(
-  declaredEnvKeys: Set<string>,
-  envVars: Record<string, string>,
-): Record<string, string> {
-  if (declaredEnvKeys.size === 0) return envVars;
-
-  let result: Record<string, string> | undefined;
-
-  for (const [targetKey, sourceKey] of Object.entries(PLATFORM_INJECTABLE_MAP)) {
-    if (!declaredEnvKeys.has(targetKey)) continue;
-    const value = process.env[sourceKey];
-    if (!value) continue;
-
-    if (!result) result = { ...envVars };
-    if (targetKey in result && result[targetKey] !== value) {
-      console.info(
-        `Platform env var '${targetKey}' overrides value from ExecutionContext ` +
-        `(platform infra vars are authoritative)`,
-      );
-    }
-    result[targetKey] = value;
-  }
-
-  return result ?? envVars;
-}
-
 // ─────────────────────────────────────────────────────────────────────────────
 // Core Discovery Logic (no Temporal coupling)
 // ─────────────────────────────────────────────────────────────────────────────
@@ -281,6 +253,12 @@ export interface DiscoverDeps {
    * tool enumeration.
    */
   transportPosture: McpTransportPosture;
+  /**
+   * The runner's endpoints a missing STIGMER_SERVER_ADDRESS is filled from
+   * (the runner Config satisfies it) — the same fill execution applies, so
+   * discovery dials what the run will dial.
+   */
+  platformEndpoints: PlatformEndpoints;
 }
 
 export async function discoverMcpServer(
@@ -305,16 +283,25 @@ export async function discoverMcpServer(
   const previousState = extractPreviousState(mcpServer);
 
   const declaredEnv = mcpServer.spec.env ?? {};
+  // A key the platform fills for this transport is not a credential the
+  // connect flow must deliver, so it never makes an empty EC a failure.
+  const platformFillsAddress =
+    platformServerAddress(mcpServer.spec.serverType.case, deps.platformEndpoints) !== null;
+  const credentialDeclarations = platformFillsAddress
+    ? Object.fromEntries(
+        Object.entries(declaredEnv).filter(([key]) => key !== SERVER_ADDRESS_ENV_KEY),
+      )
+    : declaredEnv;
   const envVars = await resolveEnvVarsForDiscovery(
     stigmerClient,
     executionContextId ?? null,
     executionContextToken ?? null,
     slug,
-    declaredEnv,
+    credentialDeclarations,
   );
 
   const declaredEnvKeys = new Set(Object.keys(declaredEnv));
-  const platformEnv = injectPlatformEnv(declaredEnvKeys, envVars);
+  const platformEnv = fillPlatformServerAddress(mcpServer, envVars, deps.platformEndpoints);
 
   // Discovery runs with no session, so every declared caller-identity key
   // resolves to the anonymous sentinel — without it, a server templating
@@ -385,7 +372,9 @@ export async function discoverMcpServer(
  *   sentinel can only produce a misleading 401.
  * - No non-optional declarations → the old lenient path (warn and continue):
  *   servers declaring nothing (or only optional/injected keys like the
- *   caller-identity family) legitimately discover without an EC.
+ *   caller-identity family) legitimately discover without an EC. A
+ *   STIGMER_SERVER_ADDRESS the platform fills for the server's transport is
+ *   left out of the count by the caller (platform-server-address.ts).
  */
 async function resolveEnvVarsForDiscovery(
   client: StigmerClient,
@@ -635,6 +624,7 @@ export function createDiscoverMcpServerActivities(config: Config) {
         return await discoverMcpServer(input, {
           stigmerClient,
           transportPosture: resolveMcpTransportPosture(config.mode),
+          platformEndpoints: config,
         });
       } finally {
         hb.stop();

package/src/activities/execute-cursor/__test-utils__/fold.ts

@@ -21,7 +21,7 @@ import { create } from "@bufbuild/protobuf";
 import type { InteractionUpdate, SDKMessage } from "@cursor/sdk";
 import { AgentExecutionStatusSchema, type AgentExecutionStatus } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
 import type { AgentMessage, ToolCall } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
-import { TranscriptBuilder } from "../../../harness/transcript/builder.js";
+import { TranscriptBuilder, type TranscriptObserver } from "../../../harness/transcript/builder.js";
 import { CursorTranslator, type CursorTranslatorOptions } from "../translator.js";
 
 export interface CursorFoldOptions {
@@ -35,6 +35,8 @@ export interface CursorFoldOptions {
   readonly messages?: AgentMessage[];
   readonly policies?: CursorTranslatorOptions["policies"];
   readonly leases?: CursorTranslatorOptions["leases"];
+  /** The builder's observer, as the runtime passes its turn timeline; a test that moves a fake clock between folds passes one. */
+  readonly observer?: TranscriptObserver;
 }
 
 export class CursorFold {
@@ -50,12 +52,12 @@ export class CursorFold {
       leases: options.leases ?? { global: false, categories: new Set() },
       seeded: this.status.messages,
     });
-    this.builder = new TranscriptBuilder("exec-fold", this.status);
+    this.builder = new TranscriptBuilder("exec-fold", this.status, options.observer);
   }
 
-  /** One stream event, translated and folded, then the deltas queued so far — the loop's order. */
+  /** One stream event, translated and folded as one observation, then the deltas queued so far — the loop's order. */
   event(event: SDKMessage): this {
-    for (const e of this.translator.translate(event)) this.builder.apply(e);
+    this.builder.applyObservation(this.translator.translate(event));
     this.drain();
     return this;
   }

package/src/activities/execute-cursor/__test-utils__/hermetic-cursor.ts

@@ -148,6 +148,7 @@ export function hermeticCursorConfig(env: HermeticEnvironment): Config {
     temporalConnection: {},
     stigmerBackendEndpoint: "http://localhost:7234",
     mcpBridgeEndpoint: null,
+    mcpPublicEndpoint: null,
     stigmerTokenRef: { current: null },
     cursorApiKey: FIXTURE.cursorApiKey,
     workspaceRootDir: env.workspaceRootDir,

package/src/activities/execute-cursor/__tests__/approval-gate.test.ts

@@ -23,8 +23,6 @@ import { ApprovalAction } from "@stigmer/protos/ai/stigmer/agentic/agentexecutio
 
 import {
   approvalCategory,
-  builtInRequiresApproval,
-  getBuiltInApprovalMessage,
   getBuiltInGatedList,
   getBuiltInGatedCategories,
   extractArgKey,
@@ -81,22 +79,10 @@ describe("approvalCategory (cross-taxonomy drift-guard)", () => {
   });
 });
 
-describe("builtInRequiresApproval", () => {
-  it("gates mutating/destructive tools in BOTH taxonomies", () => {
-    for (const t of ["Write", "StrReplace", "EditNotebook", "Shell", "Delete", "edit", "shell", "delete", "execute", "write"]) {
-      expect(builtInRequiresApproval(t)).toBe(true);
-    }
-  });
-
-  it("allows read-only built-in tools", () => {
-    for (const t of ["Read", "read", "Grep", "grep", "Glob", "glob", "ls", "think", "task"]) {
-      expect(builtInRequiresApproval(t)).toBe(false);
-    }
-  });
-
-  it("fails open for unknown tools (parity with native, avoids denying auto-approved MCP)", () => {
-    expect(builtInRequiresApproval("SomeFutureTool")).toBe(false);
-    expect(builtInRequiresApproval("search_services")).toBe(false);
+describe("the hook's gated set", () => {
+  it("fails open for unknown tools: no category, so the hook allows them (parity with native, avoids denying auto-approved MCP)", () => {
+    expect(approvalCategory("SomeFutureTool")).toBeUndefined();
+    expect(approvalCategory("search_services")).toBeUndefined();
   });
 
   it("exposes the gated set in the HOOK taxonomy (what the hook matches)", () => {
@@ -114,17 +100,6 @@ describe("builtInRequiresApproval", () => {
   });
 });
 
-describe("getBuiltInApprovalMessage", () => {
-  it("returns a category template for gated tools in EITHER taxonomy", () => {
-    expect(getBuiltInApprovalMessage("Write")).toContain("{{args.path}}");
-    expect(getBuiltInApprovalMessage("edit")).toContain("{{args.path}}");
-    expect(getBuiltInApprovalMessage("Shell")).toContain("{{args.command}}");
-    expect(getBuiltInApprovalMessage("shell")).toContain("{{args.command}}");
-    expect(getBuiltInApprovalMessage("Read")).toBeUndefined();
-    expect(getBuiltInApprovalMessage("read")).toBeUndefined();
-  });
-});
-
 describe("extractArgKey (spans both taxonomies' field names)", () => {
   it("extracts the salient value regardless of field name (file_path or path)", () => {
     expect(extractArgKey({ file_path: "a.txt" })).toBe("a.txt"); // hook shape