@stigmer/runner 3.0.8-dev.20260613074252 → 3.0.8

package/src/activities/execute-deep-agent/index.ts

@@ -16,6 +16,7 @@ import { AgentMessageSchema, ToolCallSchema } from "@stigmer/protos/ai/stigmer/a
 import { ExecutionPhase, InteractionMode, MessageType, ToolCallStatus } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { activityStarted, activityFinished } from "../../idle-watchdog.js";
 import { persistStatus, slimStatus, utcTimestamp } from "../../shared/status.js";
+import type { ToolOutputOffloadContext } from "../../shared/status-offload.js";
 import { publishPlanArtifact } from "../../shared/plan-artifact.js";
 import { classifyTool } from "../../shared/tool-kind.js";
 import type { Config } from "../../config.js";
@@ -48,6 +49,16 @@ export function createDeepAgentActivities(config: Config) {
 
         setup = await performSetup({ config, client, executionId, threadId });
 
+        // Single offload context for every persist in this execution: spill
+        // oversized tool outputs (e.g. computer-use screenshots) to artifact
+        // storage so the UI can render them, and keep the status under the
+        // gRPC cap. Threaded into the streaming loop and reused for the
+        // terminal persists below so the guard is never skipped.
+        const statusOffload: ToolOutputOffloadContext = {
+          artifactStorage: setup.artifactStorage,
+          executionId,
+        };
+
         const initialStatus = create(AgentExecutionStatusSchema, {});
         const statusBuilder = new StatusBuilder(executionId, initialStatus);
 
@@ -77,7 +88,7 @@ export function createDeepAgentActivities(config: Config) {
               }),
             ],
           });
-          await persistStatus(client, executionId, failedStatus);
+          await persistStatus(client, executionId, failedStatus, { offload: statusOffload });
           return slimStatus(failedStatus);
         }
 
@@ -113,6 +124,7 @@ export function createDeepAgentActivities(config: Config) {
           client,
           initialStatus,
           streamingConfig,
+          offload: statusOffload,
           gracefulStop: setup.gracefulStop,
           inlinePublisher,
           writebackCoordinator: writebackCoordinator ?? undefined,
@@ -137,7 +149,7 @@ export function createDeepAgentActivities(config: Config) {
 
         if (result.terminalStatus) {
           if (initialStatus.phase === ExecutionPhase.EXECUTION_PAUSED) {
-            await persistStatus(client, executionId, initialStatus);
+            await persistStatus(client, executionId, initialStatus, { offload: statusOffload });
             console.log(`[ExecuteDeepAgent] Paused for execution ${executionId}: events=${result.eventsProcessed}`);
             throw new CancelledFailure("Activity paused by orchestrator");
           }
@@ -189,7 +201,7 @@ export function createDeepAgentActivities(config: Config) {
             }
             initialStatus.messages.push(aiMsg);
 
-            await persistStatus(client, executionId, initialStatus);
+            await persistStatus(client, executionId, initialStatus, { offload: statusOffload });
             return slimStatus(initialStatus);
           }
         }
@@ -257,7 +269,7 @@ export function createDeepAgentActivities(config: Config) {
           });
         }
 
-        await persistStatus(client, executionId, initialStatus);
+        await persistStatus(client, executionId, initialStatus, { offload: statusOffload });
 
         console.log(
           `[ExecuteDeepAgent] Completed for execution ${executionId}: ` +

package/src/activities/execute-deep-agent/status-builder-shared.ts

@@ -69,14 +69,34 @@ export function toBigInt(value: unknown): bigint {
 
 // ── Tool Result Extraction ─────────────────────────────────────────
 
-export const MAX_TOOL_RESULT_CHARS = 50_000;
+/**
+ * Serialize a LangChain message `content` field into the canonical tool-result
+ * string.
+ *
+ * Text-only content is a plain string and passes through unchanged. Multimodal
+ * content (image, or mixed text+image — e.g. a computer-use screenshot) is an
+ * array of content blocks; we serialize the blocks array ITSELF, not the
+ * surrounding message envelope, so the result lands in the exact top-level-array
+ * shape the persist-time offload (`detectImagePayload`/`contentBlocks` in
+ * status-offload.ts) consumes to lift the image out into a renderable
+ * `ToolCallOutputRef`. Serializing the envelope instead would bury the base64
+ * one level deeper and defeat that detection.
+ *
+ * Returns undefined when `content` is neither a string nor an array, letting the
+ * caller fall back to serializing whatever else it holds.
+ */
+function serializeToolContent(content: unknown): string | undefined {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) return JSON.stringify(content);
+  return undefined;
+}
 
 export function extractToolResult(data: Record<string, unknown>): string {
   const output = data.output;
   if (typeof output === "string") return output;
   if (typeof output === "object" && output !== null) {
-    const content = (output as Record<string, unknown>).content;
-    if (typeof content === "string") return content;
+    const fromContent = serializeToolContent((output as Record<string, unknown>).content);
+    if (fromContent !== undefined) return fromContent;
   }
   try {
     return JSON.stringify(output ?? data);
@@ -96,9 +116,11 @@ export function extractToolResultV3(output: unknown): string {
     const obj = output as Record<string, unknown>;
     const kwargs = obj.kwargs as Record<string, unknown> | undefined;
     if (kwargs) {
-      if (typeof kwargs.content === "string") return kwargs.content;
+      const fromKwargs = serializeToolContent(kwargs.content);
+      if (fromKwargs !== undefined) return fromKwargs;
     }
-    if (typeof obj.content === "string") return obj.content;
+    const fromContent = serializeToolContent(obj.content);
+    if (fromContent !== undefined) return fromContent;
   }
   try {
     return JSON.stringify(output);

package/src/activities/execute-deep-agent/status-builder.ts

@@ -34,7 +34,6 @@ import {
   UsageAccumulator,
   extractToolResult,
   sanitizeArgsPreview,
-  MAX_TOOL_RESULT_CHARS,
 } from "./status-builder-shared.js";
 
 /** Minimal LangGraph streamEvents v2 event shape. */
@@ -290,11 +289,10 @@ export class StatusBuilder {
       tc.status = ToolCallStatus.TOOL_CALL_FAILED;
       tc.error = errorMsg;
     } else {
+      // Faithful result only; payload size is bounded at the persist chokepoint
+      // (see v3 builder note). Truncating here would corrupt image base64.
       tc.status = ToolCallStatus.TOOL_CALL_COMPLETED;
-      const result = extractToolResult(event.data);
-      tc.result = result.length > MAX_TOOL_RESULT_CHARS
-        ? result.slice(0, MAX_TOOL_RESULT_CHARS) + `\n[truncated: ${result.length} chars total]`
-        : result;
+      tc.result = extractToolResult(event.data);
     }
 
     tc.completedAt = utcTimestamp();

package/src/activities/execute-deep-agent/streaming-v3.ts

@@ -17,8 +17,7 @@ import { createV3EventRecorder, type V3ProtocolEvent } from "./v3-event-recorder
 import { normalize } from "./v3-protocol-normalizer.js";
 import { V3StatusBuilder } from "./v3-status-builder.js";
 import { StreamingUpdateScheduler } from "./streaming-scheduler.js";
-import { persistWithRetry } from "../../shared/grpc-retry.js";
-import { slimStatus } from "../../shared/status.js";
+import { persistStatus, slimStatus } from "../../shared/status.js";
 import { StreamingSideEffects } from "./streaming-side-effects.js";
 import {
   handlePause,
@@ -49,6 +48,7 @@ export async function streamExecutionV3(
     initialStatus,
     streamingConfig,
     retryOptions,
+    offload,
     stallTimeoutMs = DEFAULT_STALL_TIMEOUT_MS,
     heartbeatFn,
     isCancelledFn,
@@ -118,11 +118,11 @@ export async function streamExecutionV3(
         }
 
         statusBuilder.syncSubAgentExecutions();
-        const signal = await persistWithRetry(
+        const signal = await persistStatus(
           client,
           executionId,
           statusBuilder.currentStatus,
-          retryOptions,
+          { offload, retry: retryOptions },
         );
         scheduler.markUpdateSent(eventsProcessed);
 

package/src/activities/execute-deep-agent/streaming.ts

@@ -33,8 +33,9 @@ import {
   StreamingUpdateScheduler,
   type StreamingConfig,
 } from "./streaming-scheduler.js";
-import { persistWithRetry, type RetryOptions } from "../../shared/grpc-retry.js";
-import { slimStatus, utcTimestamp } from "../../shared/status.js";
+import { type RetryOptions } from "../../shared/grpc-retry.js";
+import { persistStatus, slimStatus, utcTimestamp } from "../../shared/status.js";
+import type { ToolOutputOffloadContext } from "../../shared/status-offload.js";
 import type { StigmerClient } from "../../client/stigmer-client.js";
 import type { GracefulStopMiddleware } from "../../middleware/index.js";
 import type { InlinePublisher } from "./inline-publisher.js";
@@ -59,6 +60,13 @@ export interface StreamDependencies {
   readonly initialStatus: AgentExecutionStatus;
   readonly streamingConfig?: StreamingConfig;
   readonly retryOptions?: RetryOptions;
+  /**
+   * Offload context for the persist chokepoint. When set, oversized tool
+   * outputs (e.g. computer-use screenshots) are spilled to artifact storage so
+   * the UI can render them; when omitted, the aggregate size backstop still
+   * keeps the payload under the gRPC cap.
+   */
+  readonly offload?: ToolOutputOffloadContext;
   readonly stallTimeoutMs?: number;
   /** Temporal heartbeat. Injected so the loop is testable without Temporal. */
   readonly heartbeatFn?: (details: Record<string, unknown>) => void;
@@ -112,6 +120,7 @@ async function streamExecutionV2(
     initialStatus,
     streamingConfig,
     retryOptions,
+    offload,
     stallTimeoutMs = DEFAULT_STALL_TIMEOUT_MS,
     heartbeatFn,
     isCancelledFn,
@@ -179,11 +188,11 @@ async function streamExecutionV2(
           statusBuilder.clearForceFlag();
         }
 
-        const signal = await persistWithRetry(
+        const signal = await persistStatus(
           client,
           executionId,
           statusBuilder.currentStatus,
-          retryOptions,
+          { offload, retry: retryOptions },
         );
         scheduler.markUpdateSent(eventsProcessed);
 

package/src/activities/execute-deep-agent/subagent-tracker.ts

@@ -29,7 +29,7 @@ import {
 } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { utcTimestamp } from "../../shared/status.js";
 import { classifyTool } from "../../shared/tool-kind.js";
-import { extractToolResultV3, MAX_TOOL_RESULT_CHARS } from "./status-builder-shared.js";
+import { extractToolResultV3 } from "./status-builder-shared.js";
 import type { StigmerRunEvent, V3UsagePayload } from "./v3-events.js";
 
 // ── Per-SubAgent State ───────────────────────────────────────────────────────
@@ -299,11 +299,10 @@ export class SubAgentTracker {
     const tc = state.toolCalls.get(callId);
     if (!tc) return;
 
-    const result = extractToolResultV3(output);
+    // Faithful result only; payload size is bounded at the persist chokepoint
+    // (see v3 builder note). Truncating here would corrupt image base64.
     tc.status = ToolCallStatus.TOOL_CALL_COMPLETED;
-    tc.result = result.length > MAX_TOOL_RESULT_CHARS
-      ? result.slice(0, MAX_TOOL_RESULT_CHARS) + `\n[truncated: ${result.length} chars total]`
-      : result;
+    tc.result = extractToolResultV3(output);
     tc.completedAt = utcTimestamp();
     tc.isStreaming = false;
     state.toolArgBuffers.delete(callId);

package/src/activities/execute-deep-agent/v3-status-builder.ts

@@ -36,7 +36,6 @@ import {
   UsageAccumulator,
   extractToolResultV3,
   sanitizeArgsPreview,
-  MAX_TOOL_RESULT_CHARS,
 } from "./status-builder-shared.js";
 import { SubAgentTracker } from "./subagent-tracker.js";
 
@@ -296,11 +295,12 @@ export class V3StatusBuilder implements ExecutionStatusWriter {
     const tc = this.state.toolCalls.get(callId);
     if (!tc) return;
 
-    const result = extractToolResultV3(output);
+    // Store the faithful result; bounding the gRPC payload is owned solely by
+    // the persist chokepoint (offload + enforce in status.ts/status-offload.ts).
+    // Truncating here would corrupt binary content (e.g. a screenshot's base64)
+    // before offload can lift it into a renderable ToolCallOutputRef.
     tc.status = ToolCallStatus.TOOL_CALL_COMPLETED;
-    tc.result = result.length > MAX_TOOL_RESULT_CHARS
-      ? result.slice(0, MAX_TOOL_RESULT_CHARS) + `\n[truncated: ${result.length} chars total]`
-      : result;
+    tc.result = extractToolResultV3(output);
     tc.completedAt = utcTimestamp();
     tc.isStreaming = false;
     this.state.toolStartTimes.delete(callId);

package/src/config.ts

@@ -28,6 +28,15 @@ import { mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { homedir, tmpdir } from "node:os";
 
+/**
+ * Default no-progress bound for the Cursor harness stream (ms). Larger than the
+ * shared DEFAULT_STALL_TIMEOUT_MS (120s) because opaque MCP / GUI tool calls
+ * can run for minutes while emitting no stream activity. Single source of truth
+ * for env-loaded ({@link loadConfig}) and options-mapped (runner / manager)
+ * config so the three construction sites never drift.
+ */
+export const DEFAULT_CURSOR_STREAM_STALL_TIMEOUT_MS = 180_000;
+
 export interface Config {
   readonly taskQueue: string;
   readonly temporalAddress: string;
@@ -61,6 +70,19 @@ export interface Config {
   readonly checkpointerType: "memory" | "http";
   readonly checkpointerProxyEndpoint: string | null;
   readonly primaryModel: string;
+  /**
+   * No-progress bound for the Cursor harness stream (milliseconds). If no
+   * stream event or token delta arrives for this long, the stall watchdog
+   * (see activities/execute-cursor + shared/stall-watchdog.ts) cancels the run
+   * and fails the execution with a StallTimeoutError rather than hanging at
+   * EXECUTION_IN_PROGRESS forever.
+   *
+   * Larger than the shared DEFAULT_STALL_TIMEOUT_MS (120s) because opaque MCP /
+   * GUI tool calls can legitimately run for minutes while emitting no stream
+   * activity. This bounds no-progress time only; it is orthogonal to Temporal's
+   * heartbeatTimeout (process liveness) and the 30s keep-alive heartbeat.
+   */
+  readonly cursorStreamStallTimeoutMs: number;
   /** Shared mutable token reference for dynamic token updates (manager mode). */
   readonly stigmerTokenRef?: { current: string | null };
 }
@@ -119,6 +141,10 @@ export function loadConfig(): Config {
 
   const primaryModel = process.env.STIGMER_PRIMARY_MODEL ?? "gpt-4.1";
 
+  const cursorStreamStallTimeoutMs = process.env.CURSOR_STREAM_STALL_TIMEOUT_MS
+    ? parseInt(process.env.CURSOR_STREAM_STALL_TIMEOUT_MS, 10)
+    : DEFAULT_CURSOR_STREAM_STALL_TIMEOUT_MS;
+
   return {
     taskQueue,
     temporalAddress,
@@ -135,6 +161,7 @@ export function loadConfig(): Config {
     checkpointerType,
     checkpointerProxyEndpoint,
     primaryModel,
+    cursorStreamStallTimeoutMs,
   };
 }
 

package/src/in-flight.ts

@@ -0,0 +1,71 @@
+/**
+ * Per-task-queue in-flight activity tracking.
+ *
+ * A session/wfexec worker must NOT be torn down while one of its activities
+ * (notably the long-running ExecuteCursor) is still running: doing so abandons
+ * the activity and removes the only poller on its queue, turning a harmless UI
+ * navigation into an "Activity task timed out" dead-end. The activity inbound
+ * interceptor increments on every activity start and decrements on finish;
+ * runner-manager's removeSession/removeWorkflowExecution consult the count and
+ * defer teardown until it drains.
+ *
+ * This lives in its own module (rather than inside the runner-manager closure)
+ * so the interceptor — which has no handle to that closure — and unit tests can
+ * both reach it. Keyed by task queue (`session:{id}` / `wfexec:{id}`), it is
+ * process-global, mirroring the shutdown-signal registry.
+ */
+
+interface InFlightEntry {
+  count: number;
+  /** Invoked once when count returns to 0; used to run a deferred teardown. */
+  onDrained?: () => void;
+}
+
+const registry = new Map<string, InFlightEntry>();
+
+/** Record that an activity started on the given task queue. */
+export function activityStartedOnQueue(taskQueue: string): void {
+  const entry = registry.get(taskQueue) ?? { count: 0 };
+  entry.count++;
+  registry.set(taskQueue, entry);
+}
+
+/**
+ * Record that an activity finished on the given task queue. When the count
+ * returns to zero, any registered drain callback fires exactly once.
+ */
+export function activityFinishedOnQueue(taskQueue: string): void {
+  const entry = registry.get(taskQueue);
+  if (!entry) return;
+  entry.count = Math.max(0, entry.count - 1);
+  if (entry.count === 0 && entry.onDrained) {
+    const onDrained = entry.onDrained;
+    entry.onDrained = undefined;
+    onDrained();
+  }
+}
+
+/** Current number of in-flight activities on the task queue (0 if unknown). */
+export function inFlightCountForQueue(taskQueue: string): number {
+  return registry.get(taskQueue)?.count ?? 0;
+}
+
+/**
+ * Register (or clear) a callback to run when the queue next drains to zero
+ * in-flight activities. No-op if the queue has no entry (count already 0); the
+ * caller handles the already-idle case by tearing down immediately.
+ */
+export function setQueueDrainCallback(taskQueue: string, cb: (() => void) | undefined): void {
+  const entry = registry.get(taskQueue);
+  if (entry) entry.onDrained = cb;
+}
+
+/** Forget all tracking for a queue (called after its worker is torn down). */
+export function forgetQueue(taskQueue: string): void {
+  registry.delete(taskQueue);
+}
+
+/** Test-only: clear the entire registry between cases. */
+export function __resetInFlightRegistryForTests(): void {
+  registry.clear();
+}

package/src/main.ts

@@ -319,9 +319,14 @@ async function main(): Promise<void> {
 
   if (runnerMode === "manager") {
     await runManagerMode(config);
-  } else {
-    await runStaticMode(config);
+    // Manager mode is driven by the host over stdin. Once it returns — via the IPC `shutdown`
+    // command or stdin EOF when the host process dies — exit deterministically so a stray open
+    // handle can't keep a shut-down runner alive as an orphan (issue #177). Static mode is left
+    // to exit naturally so its OTel flush completes.
+    process.exit(0);
   }
+
+  await runStaticMode(config);
 }
 
 main().catch((err) => {

package/src/runner-manager.ts

@@ -24,10 +24,22 @@ import {
 } from "@temporalio/worker";
 import type { PayloadCodec } from "@temporalio/common";
 import type { Config } from "./config.js";
+import { DEFAULT_CURSOR_STREAM_STALL_TIMEOUT_MS } from "./config.js";
 import type { WorkerActivities } from "./worker.js";
 import { resolveWorkflowSource, OTEL_WORKFLOW_INTERCEPTOR_MODULE } from "./workflow-source.js";
 import { resolveRunnerBootstrap, refreshRunnerAccessToken } from "./bootstrap.js";
 import { createRunnerTokenCoordinator } from "./runner-token-coordinator.js";
+// Per-task-queue in-flight activity tracking lives in ./in-flight.ts so the
+// activity interceptor (no manager-closure handle) and unit tests can reach it.
+// This is what keeps a session worker alive while ExecuteCursor is running, so a
+// view close can no longer reap the worker mid-run.
+import {
+  activityStartedOnQueue,
+  activityFinishedOnQueue,
+  inFlightCountForQueue,
+  setQueueDrainCallback,
+  forgetQueue,
+} from "./in-flight.js";
 
 const SESSION_QUEUE_PREFIX = "session:";
 const WFEXEC_QUEUE_PREFIX = "wfexec:";
@@ -76,6 +88,9 @@ export interface RunnerManagerOptions {
   /** Default LLM model identifier. @default "gpt-4.1" */
   readonly primaryModel?: string;
 
+  /** No-progress bound for the Cursor harness stream (ms). @default 180000 */
+  readonly cursorStreamStallTimeoutMs?: number;
+
   /** Checkpointer type for LangGraph agent state. @default "memory" (or "http" if proxyEndpoint is set) */
   readonly checkpointerType?: "memory" | "http";
 
@@ -141,6 +156,12 @@ interface ManagedSession {
   worker: Worker;
   runPromise: Promise<void>;
   shutdownController: AbortController;
+  /**
+   * Set when a remove was requested while an activity was still in flight, so
+   * the worker is kept alive in the background and torn down only once the last
+   * activity finishes. Cleared if the session is re-opened before it drains.
+   */
+  pendingClose: boolean;
 }
 
 /**
@@ -324,7 +345,84 @@ export async function createStigmerRunnerManager(
       );
     });
 
-    return { worker, runPromise, shutdownController };
+    return { worker, runPromise, shutdownController, pendingClose: false };
+  }
+
+  /**
+   * Re-opening a session/execution whose teardown was deferred: cancel the
+   * pending close so the worker keeps serving the reused queue. Returns true
+   * when an existing managed worker was found (caller should not recreate one).
+   */
+  function reuseExistingWorker(
+    registry: Map<string, ManagedSession>,
+    id: string,
+    taskQueue: string,
+    kind: string,
+  ): boolean {
+    const existing = registry.get(id);
+    if (!existing) return false;
+    if (existing.pendingClose) {
+      existing.pendingClose = false;
+      setQueueDrainCallback(taskQueue, undefined);
+      console.log(`[runner-manager] Re-opened ${kind} ${id}; cancelled deferred teardown`);
+    }
+    return true;
+  }
+
+  /**
+   * Graceful teardown of a managed worker. Never aborts: callers only reach the
+   * actual teardown once no activity is in flight, so a plain worker.shutdown()
+   * drains the (idle) queue cleanly. The abort-before-shutdown that used to live
+   * here is what killed running activities on a view close.
+   */
+  async function teardownManaged(
+    registry: Map<string, ManagedSession>,
+    id: string,
+    taskQueue: string,
+    kind: string,
+  ): Promise<void> {
+    const managed = registry.get(id);
+    if (!managed) return;
+    managed.worker.shutdown();
+    await managed.runPromise;
+    registry.delete(id);
+    shutdownSignals.delete(taskQueue);
+    _shutdownSignalRegistry.delete(taskQueue);
+    forgetQueue(taskQueue);
+    console.log(`[runner-manager] Removed ${kind} ${id} (active=${registry.size})`);
+  }
+
+  /**
+   * Remove a managed worker, deferring teardown while activities are in flight.
+   * This is the server-side safety invariant that lets a run continue in the
+   * background after its session view closes: the worker is reaped only when the
+   * last activity finishes (or immediately if the queue is already idle).
+   */
+  async function removeManaged(
+    registry: Map<string, ManagedSession>,
+    id: string,
+    taskQueue: string,
+    kind: string,
+  ): Promise<void> {
+    const managed = registry.get(id);
+    if (!managed) return;
+
+    if (inFlightCountForQueue(taskQueue) > 0) {
+      managed.pendingClose = true;
+      setQueueDrainCallback(taskQueue, () => {
+        // Skip if a full shutdown() is already reaping every worker, so we
+        // never call worker.shutdown() twice on the same worker.
+        if (shuttingDown) return;
+        void teardownManaged(registry, id, taskQueue, kind);
+      });
+      console.log(
+        `[runner-manager] Deferring teardown of ${kind} ${id} — ` +
+        `${inFlightCountForQueue(taskQueue)} activity(ies) still in flight (runs in background)`,
+      );
+      return;
+    }
+
+    await teardownManaged(registry, id, taskQueue, kind);
   }
 
   return {
@@ -332,11 +430,11 @@ export async function createStigmerRunnerManager(
       if (shuttingDown) {
         throw new Error("RunnerManager is shutting down");
       }
-      if (sessions.has(sessionId)) {
+      const taskQueue = SESSION_QUEUE_PREFIX + sessionId;
+      if (reuseExistingWorker(sessions, sessionId, taskQueue, "session")) {
         return;
       }
 
-      const taskQueue = SESSION_QUEUE_PREFIX + sessionId;
       const managed = await createWorkerOnQueue(taskQueue);
       sessions.set(sessionId, managed);
       console.log(
@@ -345,20 +443,8 @@ export async function createStigmerRunnerManager(
     },
 
     async removeSession(sessionId: string): Promise<void> {
-      const session = sessions.get(sessionId);
-      if (!session) {
-        return;
-      }
-
-      const taskQueue = SESSION_QUEUE_PREFIX + sessionId;
-      session.shutdownController.abort();
-      session.worker.shutdown();
-      await session.runPromise;
-      sessions.delete(sessionId);
-      shutdownSignals.delete(taskQueue);
-      _shutdownSignalRegistry.delete(taskQueue);
-      console.log(
-        `[runner-manager] Removed session ${sessionId} (active=${sessions.size})`,
+      await removeManaged(
+        sessions, sessionId, SESSION_QUEUE_PREFIX + sessionId, "session",
       );
     },
 
@@ -370,11 +456,11 @@ export async function createStigmerRunnerManager(
       if (shuttingDown) {
         throw new Error("RunnerManager is shutting down");
       }
-      if (workflowExecutions.has(executionId)) {
+      const taskQueue = WFEXEC_QUEUE_PREFIX + executionId;
+      if (reuseExistingWorker(workflowExecutions, executionId, taskQueue, "workflow execution")) {
         return;
       }
 
-      const taskQueue = WFEXEC_QUEUE_PREFIX + executionId;
       const managed = await createWorkerOnQueue(taskQueue);
       workflowExecutions.set(executionId, managed);
       console.log(
@@ -383,20 +469,9 @@ export async function createStigmerRunnerManager(
     },
 
     async removeWorkflowExecution(executionId: string): Promise<void> {
-      const execution = workflowExecutions.get(executionId);
-      if (!execution) {
-        return;
-      }
-
-      const taskQueue = WFEXEC_QUEUE_PREFIX + executionId;
-      execution.shutdownController.abort();
-      execution.worker.shutdown();
-      await execution.runPromise;
-      workflowExecutions.delete(executionId);
-      shutdownSignals.delete(taskQueue);
-      _shutdownSignalRegistry.delete(taskQueue);
-      console.log(
-        `[runner-manager] Removed workflow execution ${executionId} (active=${workflowExecutions.size})`,
+      await removeManaged(
+        workflowExecutions, executionId, WFEXEC_QUEUE_PREFIX + executionId,
+        "workflow execution",
       );
     },
 
@@ -499,6 +574,8 @@ export function mapManagerOptionsToConfig(
     checkpointerProxyEndpoint:
       options.checkpointerProxyEndpoint ?? options.proxyEndpoint ?? null,
     primaryModel: options.primaryModel ?? "gpt-4.1",
+    cursorStreamStallTimeoutMs:
+      options.cursorStreamStallTimeoutMs ?? DEFAULT_CURSOR_STREAM_STALL_TIMEOUT_MS,
   };
 }
 
@@ -600,6 +677,23 @@ async function buildInterceptorConfig(): Promise<InterceptorConfig> {
   let sinks: InjectedSinks<any> = { ...createWorkflowMetricsSinks() };
   const workflowInterceptorModules: string[] = [];
 
+  // In-flight activity counter: keeps a session/wfexec worker alive while one of
+  // its activities (notably the long ExecuteCursor) is running, so a view close
+  // can no longer reap the worker mid-run. Always installed; cheap and global.
+  activityInterceptors.push((ctx) => ({
+    inbound: {
+      async execute(input, next) {
+        const taskQueue = ctx.info.taskQueue;
+        activityStartedOnQueue(taskQueue);
+        try {
+          return await next(input);
+        } finally {
+          activityFinishedOnQueue(taskQueue);
+        }
+      },
+    },
+  }));
+
   if (process.env.OTEL_EXPORTER_OTLP_ENDPOINT) {
     const { OpenTelemetryActivityInboundInterceptor, makeWorkflowExporter } =
       await import("@temporalio/interceptors-opentelemetry");