@stigmer/runner 3.14.1 → 3.15.0

package/src/runner-manager.ts

@@ -234,9 +234,9 @@ export async function createStigmerRunnerManager(
   // `tokenRef` holds the control-plane token (the host's durable credential,
   // e.g. the desktop's Auth0 token) and is shared with activity clients via
   // config.stigmerTokenRef. The proxy credential (x-stigmer-auth) is managed
-  // separately by a RunnerTokenCoordinator (created after the interceptors are
-  // installed) — see that module for the two-writer rationale and the staleness
-  // history it guards.
+  // separately by a RunnerTokenCoordinator (created after the harnesses boot)
+  // — see that module for the two-writer rationale and the staleness history
+  // it guards.
   const tokenRef = { current: options.stigmerToken ?? null };
   // `runnerTokenRef` mirrors the coordinator's proxy credential for gRPC use:
   // the minted runner token (token_type=embedded_runner) once adopted, tracking
@@ -251,48 +251,33 @@ export async function createStigmerRunnerManager(
 
   assertLlmBackendsPreflight(baseConfig.proxyEndpoint);
 
-  // Install the Cursor SDK interceptors BEFORE resolving Temporal coordinates.
-  // Coordinate discovery dials the control plane via StigmerClient, which loads
-  // @connectrpc/connect-node and snapshots the node:http2 ESM facade on first
-  // import. The HTTP/2 interceptor patches http2.connect and only propagates to
-  // that facade if it runs first, so install MUST precede any connect-node load
-  // (discovery here, and the SDK later). The interceptors depend only on
-  // proxyEndpoint/stigmerToken (already in baseConfig), not resolved coordinates.
-
-  // Install fetch interceptor before any @cursor/sdk imports
-  const { installFetchInterceptor, updateInterceptorToken, getExecutionContext } = await import(
-    "./activities/execute-cursor/fetch-interceptor.js"
-  );
-  installFetchInterceptor({
-    proxyEndpoint: baseConfig.proxyEndpoint ?? undefined,
-    stigmerToken: baseConfig.stigmerToken ?? undefined,
-  });
-
-  // HTTP/2 interceptor for Connect RPC auth + execution ID injection (BiDi billing)
-  const { installHttp2Interceptor, updateHttp2InterceptorToken, assertHttp2ConnectPatched } = await import(
-    "./activities/execute-cursor/http2-interceptor.js"
-  );
-  installHttp2Interceptor({
-    proxyEndpoint: baseConfig.proxyEndpoint ?? undefined,
-    stigmerToken: baseConfig.stigmerToken ?? undefined,
-  });
-  // Fail loudly at boot if a load-order regression left the node:http2 ESM
-  // facade unpatched (otherwise BiDi streams would silently 401). No-op when
-  // the interceptor is unconfigured (no proxy/token).
-  await assertHttp2ConnectPatched();
-  markBoot("interceptors_installed");
+  // Boot the harnesses BEFORE resolving Temporal coordinates. Coordinate
+  // discovery dials the control plane through connect-node, which snapshots
+  // the node:http2 ESM facade on first import; the Cursor adapter's boot
+  // installs the proxy interceptors (the HTTP/2 one patches http2.connect,
+  // which only reaches that facade if it runs first), proves the patch landed,
+  // and only then loads its SDK. The interceptors read the proxy credential
+  // per request from `runnerTokenRef` (Config.proxyTokenRef, bound by
+  // mapManagerOptionsToConfig): the control-plane token until a runner token
+  // is minted, the minted token after, exactly the lockstep the coordinator
+  // below maintains in that ref. Nothing a boot reads depends on the
+  // coordinates, so `baseConfig` carries none yet. The two modules imported
+  // here are connect-free by construction (`harness-adapters.ts`,
+  // `harness/registry.ts`; `__tests__/harness-boot-order.test.ts`).
+  const [{ HARNESS_ADAPTERS }, { adaptersOf, bootHarnesses, releaseHarnessSession, shutdownHarnesses }] =
+    await Promise.all([import("./harness-adapters.js"), import("./harness/registry.js")]);
+  await bootHarnesses(adaptersOf(HARNESS_ADAPTERS), baseConfig);
+  markBoot("harnesses_booted");
 
   // The token coordinator owns the proxy credential (x-stigmer-auth) and its
-  // refresh lifecycle. It writes ONLY its sinks (the interceptors plus the gRPC
-  // runner-credential ref) and re-mints using the always-fresh control-plane
+  // refresh lifecycle. It writes ONE sink, `runnerTokenRef`, which is read per
+  // request by both the interceptors (as Config.proxyTokenRef) and the gRPC
+  // client (as Config.stigmerRunnerTokenRef), so mint and refresh reach every
+  // reader in one write. It re-mints using the always-fresh control-plane
   // token in `tokenRef` — never the (possibly expired) minted token itself, so
   // a slept-past-TTL runner recovers without a restart.
   const tokenCoordinator = createRunnerTokenCoordinator({
     applyProxyToken: (token) => {
-      updateInterceptorToken(token);
-      updateHttp2InterceptorToken(token);
-      // Third sink: keeps the ExecutionContext-read credential in lockstep with
-      // the proxy credential across mint and refresh (see runnerTokenRef above).
       runnerTokenRef.current = token;
     },
     reMint: () =>
@@ -302,7 +287,7 @@ export async function createStigmerRunnerManager(
       }),
   });
 
-  // Resolve the runner bootstrap after the http2 patch is in place (discovery
+  // Resolve the runner bootstrap after the harnesses have booted (discovery
   // dials the control plane through connect-node). An explicit address wins;
   // otherwise a token triggers control-plane discovery; otherwise localhost.
   // Must happen before createAllActivities so the activities' Config carries
@@ -341,11 +326,6 @@ export async function createStigmerRunnerManager(
     );
   }
 
-  const { setExecutionContextRef } = await import(
-    "./activities/execute-cursor/rejection-capture.js"
-  );
-  setExecutionContextRef(getExecutionContext());
-
   const activities = await createAllActivities(config);
   markBoot("activities_imported");
   // Surface the resolved artifact store at boot (see runner.ts for rationale):
@@ -538,13 +518,19 @@ export async function createStigmerRunnerManager(
       await removeManaged(
         sessions, sessionId, SESSION_QUEUE_PREFIX + sessionId, "session",
       );
-      // The session is done on this host — release its parked agent (and
-      // the executor + MCP subprocesses the lease pins) immediately rather
-      // than waiting out the idle TTL (#215).
-      const { evictSessionAgent } = await import(
-        "./activities/execute-cursor/agent-session-cache.js"
-      );
-      evictSessionAgent(sessionId);
+      // The session is done on this host — every harness releases what it
+      // parked for it (the Cursor harness: the agent, and the executor + MCP
+      // subprocesses its lease pins) now rather than after the idle TTL
+      // (#215). Logged, never thrown: the session's worker is already gone,
+      // and failing this IPC command would tell the desktop a removal that
+      // did happen did not.
+      try {
+        await releaseHarnessSession(adaptersOf(HARNESS_ADAPTERS), sessionId);
+      } catch (err) {
+        console.error(
+          `[runner-manager] Harness release for session ${sessionId} failed (continuing): ${err instanceof Error ? err.message : String(err)}`,
+        );
+      }
     },
 
     activeSessions(): string[] {
@@ -659,12 +645,18 @@ export async function createStigmerRunnerManager(
       }
 
       await Promise.all(shutdownPromises);
-      // Workers are drained — release every parked session agent so their
-      // executor leases dispose (stdio MCP subprocesses die with them) (#215).
-      const { closeAllCachedAgents } = await import(
-        "./activities/execute-cursor/agent-session-cache.js"
-      );
-      closeAllCachedAgents();
+      // Workers are drained — every harness releases what it still holds
+      // (the Cursor harness: its parked session agents, whose executor leases
+      // dispose and whose stdio MCP subprocesses die with them, #215). Logged,
+      // never thrown: the drain has already happened, and a teardown failure
+      // must not mask a clean stop.
+      try {
+        await shutdownHarnesses(adaptersOf(HARNESS_ADAPTERS));
+      } catch (err) {
+        console.error(
+          `[runner-manager] Harness shutdown failed after the workers drained (continuing): ${err instanceof Error ? err.message : String(err)}`,
+        );
+      }
       sessions.clear();
       workflowExecutions.clear();
       poolControl = null;
@@ -711,6 +703,11 @@ export function mapManagerOptionsToConfig(
     mcpBridgeEndpoint: process.env.STIGMER_MCP_BRIDGE_ENDPOINT ?? null,
     stigmerTokenRef: tokenRef,
     stigmerRunnerTokenRef: runnerTokenRef,
+    // The manager's proxy credential is the minted runner token once adopted
+    // (the control-plane token in lockstep before that), so it is this ref and
+    // not `tokenRef`: binding `tokenRef` would keep sending the desktop's own
+    // Auth0 token as x-stigmer-auth after the mint (Q-S2-7).
+    proxyTokenRef: runnerTokenRef,
     cursorApiKey: proxyActive
       ? (options.cursorApiKey ?? "proxy-managed")
       : (options.cursorApiKey ?? ""),
@@ -736,9 +733,18 @@ export function mapManagerOptionsToConfig(
   };
 }
 
+/**
+ * Dynamically import all activity factories and merge into a single map,
+ * after the harnesses have booted: several of these modules transitively load
+ * `@connectrpc/connect-node` and LangChain, and the Cursor adapter's boot must
+ * have patched `node:http2` before connect-node is first imported (see
+ * createStigmerRunnerManager). The harness rows and the registry were imported
+ * by the factory for the boot; the imports here hit the module cache.
+ */
 async function createAllActivities(config: Config): Promise<WorkerActivities> {
   const [
-    { createCursorActivities },
+    { HARNESS_ADAPTERS },
+    { createHarnessActivities },
     { createDeepAgentActivities },
     { createEnsureThreadActivities },
     { createGenerateSessionSubjectActivities },
@@ -757,7 +763,8 @@ async function createAllActivities(config: Config): Promise<WorkerActivities> {
     { createPromoteTaskOutputActivities },
     { createAttachSessionActivities },
   ] = await Promise.all([
-    import("./activities/execute-cursor/index.js"),
+    import("./harness-adapters.js"),
+    import("./harness/registry.js"),
     import("./activities/execute-deep-agent/index.js"),
     import("./activities/ensure-thread.js"),
     import("./activities/generate-session-subject.js"),
@@ -778,7 +785,7 @@ async function createAllActivities(config: Config): Promise<WorkerActivities> {
   ]);
 
   return {
-    ...createCursorActivities(config),
+    ...(await createHarnessActivities(HARNESS_ADAPTERS, config)),
     ...createDeepAgentActivities(config),
     ...createEnsureThreadActivities(),
     ...createGenerateSessionSubjectActivities(config),

package/src/runner.ts

@@ -1,8 +1,9 @@
 /**
  * Public factory for the unified Stigmer runner.
  *
- * Encapsulates the full boot sequence: fetch interceptor installation,
- * dynamic activity imports, Temporal worker creation. Consumers call
+ * Encapsulates the full boot sequence: harness boot (the Cursor adapter
+ * installs its proxy interceptors there), bootstrap resolution, dynamic
+ * activity imports, Temporal worker creation. Consumers call
  * {@link createStigmerRunner} with typed options and get back a handle
  * to start/shutdown the worker.
  *
@@ -125,13 +126,14 @@ export interface StigmerRunner {
 /**
  * Wire up self-renewal for a static cloud sandbox's control-plane credential
  * (see sandbox-token-renewal.ts for the model). The applied token reaches
- * every consumer: activity gRPC clients read {@code tokenRef} per request,
- * per-call sites (call-llm, registry-endpoint headers) resolve it through
- * the runner credential store (which replaced the process.env.STIGMER_TOKEN
- * channel, #508), artifact storage resolves the ref per call, and the two
- * Cursor SDK interceptors are updated directly — a static runner has no
+ * every consumer through the ONE ref: activity gRPC clients read
+ * {@code tokenRef} per request, per-call sites (call-llm, registry-endpoint
+ * headers) resolve it through the runner credential store (which replaced
+ * the process.env.STIGMER_TOKEN channel, #508), artifact storage resolves
+ * the ref per call, and the two Cursor SDK interceptors read the same ref per
+ * request as {@code Config.proxyTokenRef} — a static runner has no
  * {@code RunnerTokenCoordinator} minting a separate proxy credential, so its
- * x-stigmer-auth IS this token.
+ * x-stigmer-auth IS this token and one write here rotates it everywhere.
  */
 async function startStaticSandboxTokenRenewal(
   config: Config,
@@ -148,12 +150,6 @@ async function startStaticSandboxTokenRenewal(
   }
 
   const { StigmerClient } = await import("./client/stigmer-client.js");
-  const { updateInterceptorToken } = await import(
-    "./activities/execute-cursor/fetch-interceptor.js"
-  );
-  const { updateHttp2InterceptorToken } = await import(
-    "./activities/execute-cursor/http2-interceptor.js"
-  );
   const client = new StigmerClient({
     endpoint: config.stigmerBackendEndpoint,
     token: null,
@@ -169,8 +165,6 @@ async function startStaticSandboxTokenRenewal(
       // Store write replaced the process.env.STIGMER_TOKEN write (#508) —
       // same per-call readers (call-llm, registry headers), no env exposure.
       setRunnerSecret("STIGMER_TOKEN", token);
-      updateInterceptorToken(token);
-      updateHttp2InterceptorToken(token);
     },
   });
 }
@@ -178,8 +172,8 @@ async function startStaticSandboxTokenRenewal(
 /**
  * Create a Stigmer runner ready to poll a Temporal task queue.
  *
- * Handles all internal setup: Cursor SDK fetch interceptor, activity
- * registration, and Temporal worker creation. Returns a handle with
+ * Handles all internal setup: harness boot, activity registration, and
+ * Temporal worker creation. Returns a handle with
  * `start()` and `shutdown()` methods.
  *
  * @example
@@ -216,42 +210,40 @@ export async function createStigmerRunner(
 
   assertLlmBackendsPreflight(baseConfig.proxyEndpoint);
 
-  // Install the Cursor SDK interceptors BEFORE resolving Temporal coordinates.
-  // Coordinate discovery dials the control plane via StigmerClient, which loads
-  // @connectrpc/connect-node and snapshots the node:http2 ESM facade on first
-  // import. The HTTP/2 interceptor patches http2.connect and only propagates to
-  // that facade if it runs first, so install MUST precede any connect-node load
-  // (discovery here, and the SDK later). The interceptors depend only on
-  // proxyEndpoint/stigmerToken (already in baseConfig), not resolved coordinates.
-
-  // The Cursor SDK captures a reference to global.fetch at import time.
-  // The fetch interceptor MUST be installed before any @cursor/sdk import.
-  const { installFetchInterceptor, getExecutionContext } = await import(
-    "./activities/execute-cursor/fetch-interceptor.js"
-  );
-  installFetchInterceptor({
-    proxyEndpoint: baseConfig.proxyEndpoint ?? undefined,
-    stigmerToken: baseConfig.stigmerToken ?? undefined,
-  });
+  // The control-plane credential lives in a shared mutable ref (as in manager
+  // mode) so the sandbox-token renewal below can rotate it in-process:
+  // activity clients read the ref per request instead of pinning the boot
+  // token for the pod's whole life. It is ALSO this root's proxy credential
+  // (Config.proxyTokenRef): a static host provides the proxy token itself and
+  // mints no separate one, so the interceptors read this same ref per request.
+  const tokenRef = { current: baseConfig.stigmerToken };
+  // The runner-class credential the bootstrap below may mint (see there); the
+  // ref exists from here so the boot config can carry it.
+  const runnerTokenRef: { current: string | null } = { current: null };
 
-  // The Cursor SDK's Connect RPC transport uses native HTTP/2, bypassing
-  // globalThis.fetch. This interceptor injects x-stigmer-execution-id and
-  // the Stigmer auth token on HTTP/2 streams so the BiDi proxy can
-  // authenticate and meter billing.
-  const { installHttp2Interceptor, assertHttp2ConnectPatched } = await import(
-    "./activities/execute-cursor/http2-interceptor.js"
-  );
-  installHttp2Interceptor({
-    proxyEndpoint: baseConfig.proxyEndpoint ?? undefined,
-    stigmerToken: baseConfig.stigmerToken ?? undefined,
-  });
-  // Fail loudly at boot if a load-order regression left the node:http2 ESM
-  // facade unpatched (otherwise BiDi streams would silently 401). No-op when
-  // the interceptor is unconfigured (no proxy/token).
-  await assertHttp2ConnectPatched();
-  markBoot("interceptors_installed");
+  // Boot the harnesses BEFORE resolving Temporal coordinates. Coordinate
+  // discovery dials the control plane through connect-node, which snapshots
+  // the node:http2 ESM facade on first import; the Cursor adapter's boot
+  // installs the proxy interceptors (the HTTP/2 one patches http2.connect,
+  // which only reaches that facade if it runs first), proves the patch landed,
+  // and only then loads its SDK. Nothing a boot reads depends on the
+  // coordinates, so `bootConfig` carries none yet. The two modules imported
+  // here are connect-free by construction (`harness-adapters.ts`,
+  // `harness/registry.ts`; `__tests__/harness-boot-order.test.ts`).
+  const bootConfig: Config = {
+    ...baseConfig,
+    stigmerTokenRef: tokenRef,
+    stigmerRunnerTokenRef: runnerTokenRef,
+    proxyTokenRef: tokenRef,
+  };
+  const [{ HARNESS_ADAPTERS }, { adaptersOf, bootHarnesses, shutdownHarnesses }] = await Promise.all([
+    import("./harness-adapters.js"),
+    import("./harness/registry.js"),
+  ]);
+  await bootHarnesses(adaptersOf(HARNESS_ADAPTERS), bootConfig);
+  markBoot("harnesses_booted");
 
-  // Resolve Temporal coordinates after the http2 patch is in place (discovery
+  // Resolve Temporal coordinates after the harnesses have booted (discovery
   // dials the control plane through connect-node). Explicit address wins;
   // otherwise a token triggers control-plane discovery; otherwise localhost.
   // Only the worker connection consumes these coordinates — no activity dials
@@ -263,11 +255,6 @@ export async function createStigmerRunner(
     token: options.stigmerToken,
     stigmerEndpoint: baseConfig.stigmerBackendEndpoint,
   });
-  // The control-plane credential lives in a shared mutable ref (as in manager
-  // mode) so the sandbox-token renewal below can rotate it in-process:
-  // activity clients read the ref per request instead of pinning the boot
-  // token for the pod's whole life.
-  const tokenRef = { current: baseConfig.stigmerToken };
 
   // Adopt the bootstrap-minted embedded_runner credential for gRPC runner-class
   // calls (stigmer-cloud#507). The static path historically discarded it ("the
@@ -282,7 +269,6 @@ export async function createStigmerRunner(
   // Servers that mint nothing (explicit-address boots, tokenless OSS, cloud
   // sandboxes with baked credentials) leave the ref null — byte-identical
   // behavior to before.
-  const runnerTokenRef: { current: string | null } = { current: null };
   const runnerTokenCoordinator = createRunnerTokenCoordinator({
     applyProxyToken: (token) => {
       runnerTokenRef.current = token;
@@ -301,11 +287,9 @@ export async function createStigmerRunner(
   }
 
   const config: Config = {
-    ...baseConfig,
+    ...bootConfig,
     temporalAddress: coordinates.temporalAddress,
     temporalNamespace: coordinates.temporalNamespace,
-    stigmerTokenRef: tokenRef,
-    stigmerRunnerTokenRef: runnerTokenRef,
   };
   markBoot("bootstrap_resolved");
 
@@ -314,11 +298,6 @@ export async function createStigmerRunner(
   // renewal point is scheduled even if the pod boots with a part-used token.
   const tokenRenewal = await startStaticSandboxTokenRenewal(config, tokenRef);
 
-  const { setExecutionContextRef } = await import(
-    "./activities/execute-cursor/rejection-capture.js"
-  );
-  setExecutionContextRef(getExecutionContext());
-
   const activities = await createAllActivities(config);
   markBoot("activities_imported");
 
@@ -382,12 +361,18 @@ export async function createStigmerRunner(
       emitRunnerBootTiming({ task_queue: config.taskQueue, mode: config.mode });
       await worker.run();
       console.log("Worker stopped");
-      // The worker has drained — release any parked session agent so its
-      // executor lease disposes with the process (#215).
-      const { closeAllCachedAgents } = await import(
-        "./activities/execute-cursor/agent-session-cache.js"
-      );
-      closeAllCachedAgents();
+      // The worker has drained — every harness releases what it still holds
+      // (the Cursor harness: its parked session agents, whose executor leases
+      // dispose with the process, #215). Logged, never thrown: the drain has
+      // already happened and the process is exiting, so a teardown failure
+      // must not mask a clean stop.
+      try {
+        await shutdownHarnesses(adaptersOf(HARNESS_ADAPTERS));
+      } catch (err) {
+        console.error(
+          `[runner] Harness shutdown failed after the worker drained (continuing): ${err instanceof Error ? err.message : String(err)}`,
+        );
+      }
     },
     shutdown() {
       tokenRenewal?.stop();
@@ -467,13 +452,16 @@ export function mapOptionsToConfig(options: StigmerRunnerOptions): Config {
 /**
  * Dynamically import all activity factories and merge into a single map.
  *
- * Dynamic imports are required because several modules transitively import
- * @cursor/sdk, which captures global.fetch at import time. The fetch
- * interceptor must be installed before these imports.
+ * Dynamic imports, after the harnesses have booted: several of these modules
+ * transitively load `@connectrpc/connect-node` and LangChain, and the Cursor
+ * adapter's boot must have patched `node:http2` before connect-node is first
+ * imported (see createStigmerRunner). The harness rows and the registry were
+ * imported by the factory for the boot; the imports here hit the module cache.
  */
 async function createAllActivities(config: Config): Promise<WorkerActivities> {
   const [
-    { createCursorActivities },
+    { HARNESS_ADAPTERS },
+    { createHarnessActivities },
     { createDeepAgentActivities },
     { createEnsureThreadActivities },
     { createGenerateSessionSubjectActivities },
@@ -492,7 +480,8 @@ async function createAllActivities(config: Config): Promise<WorkerActivities> {
     { createPromoteTaskOutputActivities },
     { createAttachSessionActivities },
   ] = await Promise.all([
-    import("./activities/execute-cursor/index.js"),
+    import("./harness-adapters.js"),
+    import("./harness/registry.js"),
     import("./activities/execute-deep-agent/index.js"),
     import("./activities/ensure-thread.js"),
     import("./activities/generate-session-subject.js"),
@@ -513,7 +502,7 @@ async function createAllActivities(config: Config): Promise<WorkerActivities> {
   ]);
 
   return {
-    ...createCursorActivities(config),
+    ...(await createHarnessActivities(HARNESS_ADAPTERS, config)),
     ...createDeepAgentActivities(config),
     ...createEnsureThreadActivities(),
     ...createGenerateSessionSubjectActivities(config),

package/src/shared/__tests__/attachment-naming.test.ts

@@ -4,7 +4,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { uniquifyFilename, allocateUniqueName } from "../attachment-naming.js";
 import { injectAttachments } from "../../activities/execute-deep-agent/attachment-injector.js";
-import { resolveAttachments } from "../../activities/execute-cursor/attachment-resolver.js";
+import { resolveAttachments } from "../attachment-resolver.js";
 import { getPlatformDir } from "../workspace/platform-dir.js";
 import { makeInMemoryArtifactStorage } from "../../__test-utils__/fake-artifact-storage.js";
 import type { WorkspaceBackend } from "../workspace/types.js";

package/src/{activities/execute-cursor → shared}/__tests__/attachment-resolver.test.ts

@@ -1,5 +1,7 @@
 /**
- * Tests for the Cursor harness's attachment resolver.
+ * Tests for the attachment resolver, which the Cursor activity calls today
+ * and the turn runtime takes over in S2 M3 (S3 retires the native twin,
+ * execute-deep-agent/attachment-injector.ts).
  *
  * The load-bearing behaviors: storage-key attachments materialize under the
  * platform inputs dir (the universal path — every server-created attachment
@@ -14,9 +16,9 @@ import { mkdtempSync, writeFileSync, readFileSync, rmSync, lstatSync, readlinkSy
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { resolveAttachments, AttachmentResolutionError } from "../attachment-resolver.js";
-import { getPlatformDir } from "../../../shared/workspace/platform-dir.js";
-import { makeInMemoryArtifactStorage } from "../../../__test-utils__/fake-artifact-storage.js";
-import { CURSOR_VISION_PROFILE, VisionBudget } from "../../../shared/attachment-vision.js";
+import { getPlatformDir } from "../workspace/platform-dir.js";
+import { makeInMemoryArtifactStorage } from "../../__test-utils__/fake-artifact-storage.js";
+import { CURSOR_VISION_PROFILE, VisionBudget } from "../attachment-vision.js";
 
 function makeAttachment(overrides: Partial<{
   filename: string;

package/src/{activities/execute-cursor → shared}/__tests__/cost-guard.test.ts

@@ -1,5 +1,6 @@
 /**
- * Unit tests for the Cursor harness's max_cost_usd guard (cost-guard.ts).
+ * Unit tests for the max_cost_usd hard-stop guard (cost-guard.ts), which the
+ * Cursor activity calls today and the turn runtime takes over in S2 M3.
  *
  * The guard is the cursor-side analog of the native cost-cap middleware
  * (middleware/cost-cap.ts): same proto semantics (0/unset = no cap), same

package/src/{activities/execute-cursor → shared}/__tests__/exact-apply.test.ts

@@ -45,9 +45,9 @@ import {
   excludeAppliedFromGrants,
   resolveApprovedWholeFileContent,
 } from "../exact-apply.js";
-import { ELISION_MARKER } from "../../../shared/status-offload.js";
-import { mockWorkspaceBackend } from "../../../__test-utils__/mock-workspace.js";
-import type { WorkspaceBackend } from "../../../shared/workspace/types.js";
+import { ELISION_MARKER } from "../status-offload.js";
+import { mockWorkspaceBackend } from "../../__test-utils__/mock-workspace.js";
+import type { WorkspaceBackend } from "../workspace/types.js";
 
 const ROOT = "/root";
 

package/src/{activities/execute-cursor → shared}/__tests__/extract-structured-output.test.ts

@@ -1,14 +1,14 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import type { Config } from "../../../config.js";
+import type { Config } from "../../config.js";
 
-vi.mock("../../../shared/model-registry.js", () => ({
+vi.mock("../model-registry.js", () => ({
   getEconomyModel: vi.fn().mockResolvedValue("gpt-4o-mini"),
 }));
 
 const mockInvoke = vi.fn();
 const mockWithStructuredOutput = vi.fn().mockReturnValue({ invoke: mockInvoke });
 
-vi.mock("../../../shared/model-client.js", () => ({
+vi.mock("../model-client.js", () => ({
   buildChatModel: vi.fn().mockResolvedValue({
     model: { withStructuredOutput: (...args: unknown[]) => mockWithStructuredOutput(...args) },
     provider: "openai",
@@ -46,7 +46,7 @@ describe("extractStructuredOutput", () => {
 
   it("direct mode with a key builds a direct-mode model (no endpoint threaded)", async () => {
     vi.stubEnv("OPENAI_API_KEY", "sk-direct");
-    const { buildChatModel } = await import("../../../shared/model-client.js");
+    const { buildChatModel } = await import("../model-client.js");
     const { extractStructuredOutput } = await import("../extract-structured-output.js");
     mockInvoke.mockResolvedValueOnce({ answer: "42" });
 
@@ -61,7 +61,7 @@ describe("extractStructuredOutput", () => {
   });
 
   it("throws the credential message before any construction when no path exists", async () => {
-    const { buildChatModel } = await import("../../../shared/model-client.js");
+    const { buildChatModel } = await import("../model-client.js");
     const { extractStructuredOutput } = await import("../extract-structured-output.js");
 
     await expect(
@@ -72,7 +72,7 @@ describe("extractStructuredOutput", () => {
   });
 
   it("proxy mode threads the proxy endpoint and token, consulting no keys", async () => {
-    const { buildChatModel } = await import("../../../shared/model-client.js");
+    const { buildChatModel } = await import("../model-client.js");
     const { extractStructuredOutput } = await import("../extract-structured-output.js");
     mockInvoke.mockResolvedValueOnce({ answer: "ok" });
 
@@ -95,9 +95,9 @@ describe("extractStructuredOutput", () => {
     // The registry-empty fallback returns the primary model verbatim; when
     // its provider can't be inferred the pre-check must not guess — the
     // construction path owns the precise message.
-    const { getEconomyModel } = await import("../../../shared/model-registry.js");
+    const { getEconomyModel } = await import("../model-registry.js");
     vi.mocked(getEconomyModel).mockResolvedValueOnce("mystery-model");
-    const { buildChatModel } = await import("../../../shared/model-client.js");
+    const { buildChatModel } = await import("../model-client.js");
     const { extractStructuredOutput } = await import("../extract-structured-output.js");
     mockInvoke.mockResolvedValueOnce({ answer: "ok" });
 

package/src/{activities/execute-cursor → shared}/__tests__/persist-decision.test.ts

@@ -1,5 +1,7 @@
 /**
- * Unit tests for the Cursor streaming persist decision (issue #179).
+ * Unit tests for the streaming persist decision (issue #179), the shared
+ * cadence rule the Cursor stream loop calls today and the turn runtime
+ * takes over in S2 M3.
  *
  * Validates the converged cadence: discrete force-flush signals persist
  * immediately, while high-frequency token deltas ride the shared
@@ -11,7 +13,7 @@ import { describe, it, expect } from "vitest";
 import {
   StreamingUpdateScheduler,
   type StreamingConfig,
-} from "../../../shared/streaming-scheduler.js";
+} from "../streaming-scheduler.js";
 import { shouldPersistStreamingStatus } from "../persist-decision.js";
 
 const CONFIG: StreamingConfig = {

package/src/{activities/execute-cursor → shared}/__tests__/skill-resolver.test.ts

@@ -75,7 +75,7 @@ describe("resolveSkills — artifact extraction", () => {
 
     // We need to clean up the platform dir after the test; capture it
     // via the getPlatformDir import so we know the actual path.
-    const { getPlatformDir } = await import("../../../shared/workspace/platform-dir.js");
+    const { getPlatformDir } = await import("../workspace/platform-dir.js");
     const platformDir = getPlatformDir(sessionId);
 
     const client = {

package/src/shared/__tests__/subagent-rows.test.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect } from "vitest";
+import { create } from "@bufbuild/protobuf";
+import { SubAgentExecutionSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/subagent_pb";
+import { SubAgentStatus } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+
+import { cancelInProgressSubAgentProtos } from "../subagent-rows.js";
+
+describe("cancelInProgressSubAgentProtos", () => {
+  it("cancels IN_PROGRESS/PENDING protos in place and reports whether anything changed", () => {
+    const running = create(SubAgentExecutionSchema, { id: "a", status: SubAgentStatus.SUB_AGENT_IN_PROGRESS });
+    const pending = create(SubAgentExecutionSchema, { id: "b", status: SubAgentStatus.SUB_AGENT_PENDING });
+    const completed = create(SubAgentExecutionSchema, {
+      id: "c",
+      status: SubAgentStatus.SUB_AGENT_COMPLETED,
+      completedAt: "2026-01-01T00:00:00Z",
+    });
+
+    const changed = cancelInProgressSubAgentProtos([running, pending, completed]);
+
+    expect(changed).toBe(true);
+    expect(running.status).toBe(SubAgentStatus.SUB_AGENT_CANCELLED);
+    expect(running.completedAt).not.toBe("");
+    expect(pending.status).toBe(SubAgentStatus.SUB_AGENT_CANCELLED);
+    // Terminal sub-agents are untouched.
+    expect(completed.status).toBe(SubAgentStatus.SUB_AGENT_COMPLETED);
+    expect(completed.completedAt).toBe("2026-01-01T00:00:00Z");
+  });
+
+  it("returns false when there is nothing to cancel", () => {
+    const completed = create(SubAgentExecutionSchema, { id: "c", status: SubAgentStatus.SUB_AGENT_COMPLETED });
+    expect(cancelInProgressSubAgentProtos([completed])).toBe(false);
+    expect(cancelInProgressSubAgentProtos([])).toBe(false);
+  });
+});