@stigmer/runner 3.2.0 → 3.2.2

package/src/activities/execute-cursor/cost-guard.ts

@@ -0,0 +1,56 @@
+/**
+ * ExecutionConfig.max_cost_usd enforcement for the Cursor harness.
+ *
+ * The native harness enforces the cap in middleware (cost-cap.ts): tools are
+ * blocked at the threshold and the model gets one final tool-free round to
+ * summarize. Cursor's only control point is cancelling the in-flight run, so
+ * here the cap is a HARD stop — the shared onDelta flags the overrun when a
+ * turn-ended usage delta lands, and the stream loop ends the run through the
+ * same clean-cancel pattern the stall watchdog and first-denial stop use.
+ * Slightly harsher than native by construction; both harnesses terminate with
+ * the same honesty semantics (EXECUTION_TERMINATED, work checkpointed, the
+ * conversation continues on the next message — the recursion-limit precedent
+ * in execute-deep-agent/streaming-terminal.ts).
+ *
+ * The running figure is the usage accumulator's local pricing-table estimate
+ * (authoritative billing is the BiDi proxy). That is the same estimation
+ * basis the native cost-cap middleware uses — acceptable for a safety net.
+ */
+
+/**
+ * Whether the per-execution cost budget has been exhausted.
+ *
+ * `maxCostUsd <= 0` means "no cap" (the proto contract: 0/unset disables the
+ * ceiling). The boundary is inclusive: reaching the cap exactly stops the run,
+ * matching the native middleware's `runningCost >= maxCostUsd` check.
+ */
+export function costCapExceeded(maxCostUsd: number, estimatedCostUsd: number): boolean {
+  return maxCostUsd > 0 && estimatedCostUsd >= maxCostUsd;
+}
+
+/**
+ * Stable prefix of the cost-limit terminal error. Mirrors the cross-repo
+ * pattern of TOOL_CALL_LIMIT_ERROR_PREFIX (streaming-terminal.ts): consumers
+ * that need to distinguish "ran out of cost budget" from other TERMINATED
+ * causes can match on this prefix, because AgentExecutionStatus carries no
+ * structured termination reason. Do not reword without checking consumers.
+ */
+export const COST_LIMIT_ERROR_PREFIX = "Agent reached the cost limit";
+
+/** The terminal `status.error` for a cost-cap stop. */
+export function formatCostLimitError(maxCostUsd: number, estimatedCostUsd: number): string {
+  return (
+    `${COST_LIMIT_ERROR_PREFIX} for this message ` +
+    `(~$${estimatedCostUsd.toFixed(4)} of the $${maxCostUsd.toFixed(2)} budget). ` +
+    `Send another message to continue.`
+  );
+}
+
+/**
+ * User-facing system message for a cost-cap stop. Parallel to the
+ * recursion-limit copy: honest about the limit, clear that nothing is lost.
+ */
+export const COST_LIMIT_USER_COPY =
+  "The agent reached the cost limit for this message. " +
+  "Work completed so far has been saved. " +
+  "Send another message to continue where the agent left off.";

package/src/activities/execute-cursor/index.ts

@@ -45,6 +45,8 @@ import { CursorMode } from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_p
 import { determineCursorMode, isCloudMode } from "./cursor-mode.js";
 import { MessageAccumulator, cancelInProgressSubAgentProtos, collapseRedundantToolCallTwins } from "./message-translator.js";
 import { utcTimestamp, persistStatus, reportSetupProgress, slimStatus } from "../../shared/status.js";
+import { readContextBridge } from "../../shared/context-bridge.js";
+import { readSenderIdentity } from "../../shared/sender-identity.js";
 import { withholdSecretContentFromMessages } from "../../shared/tool-row.js";
 import { StallTimeoutError, formatStallFailure } from "../../shared/stall-watchdog.js";
 import { resolveUsableArtifactStorage, loadArtifactStorageConfig, type ArtifactStorage } from "../../shared/artifact-storage.js";
@@ -90,6 +92,7 @@ import {
   type CursorTurnStreamDeps,
   type TurnOnDeltaDeps,
 } from "./turn-stream.js";
+import { formatCostLimitError, COST_LIMIT_USER_COPY } from "./cost-guard.js";
 import {
   captureFileChangeProgress,
   newProgressCaptureState,
@@ -114,6 +117,7 @@ import type { ClassifiedError } from "./error-classifier.js";
 import { createAgent, createCloudAgent } from "./session-lifecycle.js";
 import { setMaxListeners } from "node:events";
 import { startHeartbeat } from "../../shared/heartbeat.js";
+import { withTimeout } from "../../shared/with-timeout.js";
 import { getShutdownSignalForQueue } from "../../runner-manager.js";
 
 /**
@@ -256,6 +260,25 @@ async function executeCursorInner(
   // can be classified with the same context as the run.wait() error path.
   let errorContext = { model: "default", mode: "local", agentId: "" };
 
+  // Periodic heartbeat for the ENTIRE activity, started before any phase runs.
+  // Setup phases make network calls (blueprint resolution, workspace clone, MCP
+  // backfill, Agent.create) that can stall; the scattered manual heartbeat()
+  // pulses between them leave every individual call uncovered. The production
+  // stale-proxy incident hung inside Agent.create with zero heartbeats and
+  // surfaced as an opaque 5-minute Temporal timeout. The label names the
+  // current phase so a stall is attributed in Temporal heartbeat details, and
+  // cancellation stays observable throughout. Safe ONLY because every SDK call
+  // below is itself bounded (agentResolveTimeoutMs, stall watchdog) — an
+  // unbounded hang under a live heartbeat would keep a dead activity alive
+  // forever.
+  let heartbeatPhase = "setup";
+  const taskQueue = Context.current().info.taskQueue;
+  const shutdownSignal = getShutdownSignalForQueue(taskQueue);
+  periodicHeartbeat = startHeartbeat(30_000, () => ({
+    phase: heartbeatPhase,
+    execution: executionId,
+  }), { shutdownSignal });
+
   try {
     // Phase 1: Hydrate execution from DB
     await reportSetupProgress(client, executionId, "Fetching execution");
@@ -269,6 +292,7 @@ async function executeCursorInner(
     const blueprint = await resolveBlueprint(client, session, config.workspaceRootDir);
 
     // Phase 2b: Resolve execution environment (MCP server credentials)
+    heartbeatPhase = "resolving_environment";
     await reportSetupProgress(client, executionId, "Resolving environment");
     const { envVars, secretKeys } = await resolveExecutionEnv(client, executionId);
     heartbeat();
@@ -279,6 +303,7 @@ async function executeCursorInner(
     // disabled the runner must provision the workspace itself, mirroring the
     // native harness. Git provisioning is idempotent across multi-turn and
     // HITL reinvocations.
+    heartbeatPhase = "provisioning_workspace";
     await reportSetupProgress(client, executionId, "Provisioning workspace");
     const workspaceProvision = await provisionCursorWorkspace(
       config, session, envVars, sessionId ?? "",
@@ -553,6 +578,7 @@ async function executeCursorInner(
     );
 
     // Phase 4a: Connect backfill for undiscovered MCP servers
+    heartbeatPhase = "resolving_mcp_servers";
     const sessionOrg = session.metadata?.org ?? "";
     mcpResolution = await backfillMcpServersIfNeeded(
       client, mcpResolution, blueprint.mergedMcpServerUsages, envVars, sessionOrg,
@@ -814,10 +840,22 @@ async function executeCursorInner(
           agents: cursorSubAgents,
         };
 
-    let resolution: AgentResolution = await resolveAgent(
-      threadId,
-      createOptions,
-      agentMode,
+    // Agent.create/Agent.resume have no timeout of their own — a degraded
+    // transport (dead proxy connection, stale HTTP/2 session) hangs them
+    // forever, which the periodic heartbeat would happily keep alive. The
+    // bound converts that hang into an immediate, named transport failure.
+    // The message carries "timed out" so the error classifier's network
+    // patterns mark it retryable.
+    heartbeatPhase = "resolving_agent";
+    const resolveTimeoutSeconds = Math.round(config.agentResolveTimeoutMs / 1000);
+    let resolution: AgentResolution = await withTimeout(
+      config.agentResolveTimeoutMs,
+      () =>
+        `Cursor agent ${threadId ? "resume" : "create"} timed out after ${resolveTimeoutSeconds}s ` +
+        `(${config.proxyEndpoint ? `via proxy ${config.proxyEndpoint}` : "direct Cursor API connection"}). ` +
+        `The transport connection is likely dead. Retry the message; if this persists, ` +
+        `check proxy and network health.`,
+      () => resolveAgent(threadId, createOptions, agentMode),
     );
 
     console.log(
@@ -877,6 +915,8 @@ async function executeCursorInner(
       appliedToolCallIds,
       interactionMode,
       buildFromPlan,
+      contextBridge: readContextBridge(blueprint.sessionSpec.metadata),
+      senderIdentity: readSenderIdentity(blueprint.sessionSpec.metadata),
     });
 
     // Phase 10a: Inject structured output instruction for Cursor harness
@@ -950,6 +990,7 @@ async function executeCursorInner(
     // The shared onDelta only needs the usage/enricher/heartbeat/state subset,
     // and it is wired at SEND time — before the accumulator exists — so it takes
     // the narrow deps. The primary send and both retry sends reuse this object.
+    const maxCostUsd = spec.executionConfig?.maxCostUsd ?? 0;
     const onDeltaDeps: TurnOnDeltaDeps = {
       usageAccumulator,
       deltaEnricher,
@@ -957,18 +998,13 @@ async function executeCursorInner(
       promptEstimatedTokens,
       executionId,
       state: turnState,
+      maxCostUsd,
     };
 
-    // Periodic heartbeat keeps Temporal informed during silent SDK operations
-    // (e.g. long tool calls, MCP requests, model thinking). Without this,
-    // the 2-minute heartbeat timeout can cancel the activity and mislabel
-    // the execution as "paused by user".
-    const taskQueue = Context.current().info.taskQueue;
-    const shutdownSignal = getShutdownSignalForQueue(taskQueue);
-    periodicHeartbeat = startHeartbeat(30_000, () => ({
-      phase: "cursor_streaming",
-      execution: executionId,
-    }), { shutdownSignal });
+    // The activity-wide periodic heartbeat (started at entry) keeps Temporal
+    // informed during silent SDK operations (long tool calls, MCP requests,
+    // model thinking); relabel it for the streaming phase.
+    heartbeatPhase = "cursor_streaming";
 
     // The Cursor SDK registers abort listeners on the cancellation signal for
     // each concurrent tool call (fetch, MCP, shell). With 10+ parallel tools,
@@ -1067,6 +1103,7 @@ async function executeCursorInner(
         turnState.pauseDetected ||
         workerShutdownDetected ||
         turnState.stallDetected ||
+        turnState.costCapExceeded ||
         Context.current().cancellationSignal.aborted
       ) {
         accumulator.cancelInProgressSubAgents();
@@ -1117,6 +1154,32 @@ async function executeCursorInner(
         return { kind: "return" };
       }
 
+      // Cost cap (cost-guard.ts): onDelta flagged the overrun and the loop
+      // cancelled the run. EXECUTION_TERMINATED, not FAILED — the platform
+      // deliberately stopped the run, work is checkpointed, and the
+      // conversation continues on the next message (the recursion-limit
+      // precedent in execute-deep-agent/streaming-terminal.ts). RETURN (not
+      // throw): a Temporal retry would re-run the identical prompt and burn
+      // the same budget again.
+      if (turnState.costCapExceeded) {
+        const estimated = usageAccumulator.snapshot().estimatedCostUsd;
+        status.phase = ExecutionPhase.EXECUTION_TERMINATED;
+        status.error = formatCostLimitError(maxCostUsd, estimated);
+        status.completedAt = utcTimestamp();
+        status.messages.push(create(AgentMessageSchema, {
+          type: MessageType.MESSAGE_SYSTEM,
+          content: COST_LIMIT_USER_COPY,
+          timestamp: utcTimestamp(),
+        }));
+        await persist(status);
+        try { resolution.agent.close(); } catch { /* best effort */ }
+        console.warn(
+          `ExecuteCursor terminated (cost cap): execution=${executionId}, ` +
+          `estimatedCostUsd=${estimated.toFixed(4)}, maxCostUsd=${maxCostUsd.toFixed(2)}`,
+        );
+        return { kind: "return" };
+      }
+
       // Worker shutdown: the runner-manager aborted the shutdown signal. NOT a
       // user pause. Checked via the shutdown signal directly so a retry (whose
       // periodic heartbeat is already stopped) still classifies it correctly.
@@ -1430,6 +1493,8 @@ async function executeCursorInner(
             attachmentPaths,
             pendingApprovals: adjudicatedApprovals,
             interactionMode,
+            contextBridge: readContextBridge(blueprint.sessionSpec.metadata),
+            senderIdentity: readSenderIdentity(blueprint.sessionSpec.metadata),
           });
 
           console.log(
@@ -1836,6 +1901,12 @@ async function executeCursorInner(
 
     return slimStatus(status);
   } finally {
+    // Stop the activity-wide periodic heartbeat on EVERY exit path
+    // (idempotent). The epilogue and catch stop it at the pause/shutdown
+    // disambiguation points; this covers early returns (e.g. the
+    // pure-reconcile resume) so no orphaned timer survives the activity.
+    periodicHeartbeat?.stop();
+
     // End the OTel turn span + record metrics with the final token snapshot on
     // EVERY exit path (idempotent). Placed here so the span covers any recovery
     // retry (whose tokens accrue after the primary stream) and never leaks on an
@@ -1989,6 +2060,18 @@ export interface BuildPromptInput {
    * .build_from_plan): both prompt paths carry the implement-plan directive.
    */
   buildFromPlan?: boolean;
+  /**
+   * Rollover context bridge from `SessionSpec.metadata` (cloud DD-013).
+   * Only the enhanced-prompt path consumes it — a resumed agent's native
+   * context IS the previous conversation, so it needs no bridge.
+   */
+  contextBridge?: string;
+  /**
+   * Channel sender identity from `SessionSpec.metadata`. Like the bridge,
+   * only the enhanced-prompt path consumes it — a resumed agent's native
+   * context already carries it from the session's first turn.
+   */
+  senderIdentity?: import("../../shared/sender-identity.js").SenderIdentity;
 }
 
 /**
@@ -2053,7 +2136,8 @@ export function buildPrompt(input: BuildPromptInput): string {
   }
 
   // First execution, or a fresh agent created after a resume failure: there is
-  // no prior conversation to inherit, so start a new turn with full context.
+  // no prior conversation to inherit, so start a new turn with full context —
+  // including the rollover bridge, when the session carries one.
   return buildEnhancedPrompt({
     instructions,
     userMessage,
@@ -2064,6 +2148,8 @@ export function buildPrompt(input: BuildPromptInput): string {
     attachmentPaths,
     interactionMode,
     buildFromPlan,
+    contextBridge: input.contextBridge,
+    senderIdentity: input.senderIdentity,
   });
 }
 

package/src/activities/execute-cursor/prompt-builder.ts

@@ -20,6 +20,11 @@ import { resolve } from "node:path";
 import type { SubAgent } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/spec_pb";
 import type { PendingApproval } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/approval_pb";
 import { ApprovalAction, InteractionMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { formatContextBridgeText } from "../../shared/context-bridge.js";
+import {
+  formatSenderIdentityText,
+  type SenderIdentity,
+} from "../../shared/sender-identity.js";
 import { PLAN_MODE_DIRECTIVE } from "../../shared/plan-mode-prompt.js";
 import {
   buildImplementPlanDirective,
@@ -60,6 +65,22 @@ export interface EnhancedPromptOptions {
    * The user message itself is just a short label ("Build from plan").
    */
   buildFromPlan?: boolean;
+  /**
+   * Rollover context bridge (cloud DD-013): a digest of the previous
+   * session's conversation, read from `SessionSpec.metadata`. Lands in the
+   * first message, so it persists in the cursor agent's own conversation
+   * store for the session's lifetime — buildEnhancedPrompt firing only on
+   * first/fresh executions is exactly the right delivery.
+   */
+  contextBridge?: string;
+  /**
+   * Channel sender identity (attribution, not authorization): the
+   * provider-verified identifier of the person on the channel, read from
+   * `SessionSpec.metadata`. Like the bridge, it lands in the first message
+   * and persists in the cursor agent's own conversation store — identity
+   * is constant per conversation (channel sessions are keyed per-sender).
+   */
+  senderIdentity?: SenderIdentity;
 }
 
 /**
@@ -119,6 +140,21 @@ export function buildEnhancedPrompt(options: EnhancedPromptOptions): string {
     sections.push(formatResponseRules());
   }
 
+  // The sender identity precedes the bridge: it is standing context about
+  // WHO the conversation is with, which the carried conversation may refer
+  // back to.
+  if (options.senderIdentity) {
+    sections.push(formatSenderIdentitySection(options.senderIdentity));
+  }
+
+  // The rollover context bridge sits directly before the protocol + task so
+  // the carried conversation is the freshest CONTEXT the model reads —
+  // while the approval protocol keeps its pinned last-before-task slot (it
+  // is an INSTRUCTION and must outweigh everything, including this bridge).
+  if (options.contextBridge) {
+    sections.push(formatContextBridgeSection(options.contextBridge));
+  }
+
   // Always last before the task: the platform's tool-approval protocol. Placed
   // here for recency so it outweighs any "ask the user first" guidance Cursor
   // surfaces from a connected MCP server (see formatToolApprovalProtocol).
@@ -252,6 +288,14 @@ export function formatInstructions(instructions: string): string {
   return `<agent_instructions>\n${instructions}\n</agent_instructions>`;
 }
 
+export function formatContextBridgeSection(bridge: string): string {
+  return `<previous_conversation_context>\n${formatContextBridgeText(bridge)}\n</previous_conversation_context>`;
+}
+
+export function formatSenderIdentitySection(identity: SenderIdentity): string {
+  return `<conversation_sender>\n${formatSenderIdentityText(identity)}\n</conversation_sender>`;
+}
+
 export function formatSkillsSection(skills: SkillMetadata[]): string {
   const entries = skills.map(
     (s) => `- **${s.name}**: ${s.description}\n  Path: \`${s.path}\``,

package/src/activities/execute-cursor/turn-stream.ts

@@ -45,6 +45,7 @@ import type { TodoTracker } from "./todo-tracker.js";
 import type { StreamingUpdateScheduler } from "../../shared/streaming-scheduler.js";
 import type { UsageAccumulator } from "./usage-accumulator.js";
 import type { createCursorEventRecorder } from "./cursor-event-recorder.js";
+import { costCapExceeded } from "./cost-guard.js";
 
 /**
  * The subset of the Cursor SDK `Run` the stream phase consumes. Kept structural
@@ -69,7 +70,8 @@ export type TurnStreamReason =
   | "paused"
   | "stalled"
   | "first-denial"
-  | "platform-stop";
+  | "platform-stop"
+  | "cost-cap";
 
 /**
  * Single owner for every flag the turn's stream produces. Before this, these
@@ -97,6 +99,8 @@ export interface TurnStreamState {
   denialCancelSettled: Promise<void> | undefined;
   /** Written by: the loop (a platform STOP signal from persist). Read by: the loop + epilogue. */
   platformStopSignaled: boolean;
+  /** Written by: onDelta (a turn-ended usage delta pushed the estimate past max_cost_usd). Read by: the loop (cancel + break) + epilogue. */
+  costCapExceeded: boolean;
   /** Written by: the loop (a stream ERROR status event) + the retry setup (reset). Read by: error classification. */
   streamErrorMessage: string | undefined;
   /** Written by: the loop (each tool_call). Read by: the stall-watchdog (message enrichment). */
@@ -118,6 +122,7 @@ export function newTurnStreamState(): TurnStreamState {
     denialLedgerDirty: false,
     denialCancelSettled: undefined,
     platformStopSignaled: false,
+    costCapExceeded: false,
     streamErrorMessage: undefined,
     lastToolName: undefined,
     eventCount: 0,
@@ -139,6 +144,13 @@ export interface TurnOnDeltaDeps {
   readonly promptEstimatedTokens: number;
   readonly executionId: string;
   readonly state: TurnStreamState;
+  /**
+   * ExecutionConfig.max_cost_usd — 0/unset disables the cap. Checked by
+   * onDelta after each turn-ended usage delta lands (the only point the
+   * running estimate advances); the loop performs the actual run.cancel().
+   * See cost-guard.ts for the semantics.
+   */
+  readonly maxCostUsd: number;
 }
 
 export interface CursorTurnStreamDeps extends TurnOnDeltaDeps {
@@ -170,7 +182,7 @@ export interface CursorTurnStreamDeps extends TurnOnDeltaDeps {
 export function makeCursorTurnOnDelta(
   deps: TurnOnDeltaDeps,
 ): (event: { update: InteractionUpdate }) => void {
-  const { usageAccumulator, deltaEnricher, heartbeat, promptEstimatedTokens, executionId, state } =
+  const { usageAccumulator, deltaEnricher, heartbeat, promptEstimatedTokens, executionId, state, maxCostUsd } =
     deps;
   return ({ update }) => {
     // Reset the stall timer on the delta channel too: a long model generation
@@ -180,6 +192,19 @@ export function makeCursorTurnOnDelta(
     if (update.type === "turn-ended" && update.usage) {
       usageAccumulator.addTurn(update.usage);
 
+      // max_cost_usd enforcement (cost-guard.ts): the running estimate only
+      // advances here, so this is the single check point. onDelta cannot reach
+      // the run — the loop reads the flag and performs the clean cancel.
+      if (!state.costCapExceeded
+          && costCapExceeded(maxCostUsd, usageAccumulator.snapshot().estimatedCostUsd)) {
+        state.costCapExceeded = true;
+        console.warn(
+          `ExecuteCursor cost cap exceeded: execution=${executionId}, ` +
+            `estimatedCostUsd=${usageAccumulator.snapshot().estimatedCostUsd.toFixed(4)}, ` +
+            `maxCostUsd=${maxCostUsd.toFixed(2)}`,
+        );
+      }
+
       if (!state.firstTurnAttributionLogged) {
         state.firstTurnAttributionLogged = true;
         const sdkInputTokens = update.usage.inputTokens ?? 0;
@@ -272,6 +297,26 @@ export async function consumeCursorTurnStream(
       }
       if (state.stallDetected) break;
 
+      // Cost cap (cost-guard.ts): onDelta flagged the overrun on a turn-ended
+      // usage delta; end the run through the same clean-cancel pattern as the
+      // stall watchdog and the first-denial stop. Fire-and-forget is correct
+      // here — nothing downstream waits on this turn's agent (unlike the
+      // first-denial stop, whose ledger read needs a stopped agent).
+      if (state.costCapExceeded) {
+        console.log(
+          `ExecuteCursor stopping stream at cost cap: execution=${executionId}`,
+        );
+        if (run.supports?.("cancel")) {
+          void run.cancel().catch((cancelErr) => {
+            console.warn(
+              `ExecuteCursor run.cancel() after cost cap failed (non-fatal): execution=${executionId}, ` +
+                `error=${cancelErr instanceof Error ? cancelErr.message : cancelErr}`,
+            );
+          });
+        }
+        break;
+      }
+
       // Progress: reset the stall timer on every stream event.
       state.stallWatchdog.recordActivity();
       if (event.type === "tool_call" && typeof event.name === "string") {
@@ -397,14 +442,18 @@ export async function consumeCursorTurnStream(
       }
     }
   } catch (streamErr) {
-    // run.cancel() — from the stall watchdog or the first-denial stop — can make
-    // the stream iterator reject as it tears down; that is the expected teardown
-    // for both, so swallow it and fall through. Anything else is a genuine stream
-    // failure — rethrow it to the activity's error handler.
-    if (!state.stallDetected && !state.firstDenialDetected) throw streamErr;
+    // run.cancel() — from the stall watchdog, the first-denial stop, or the
+    // cost-cap stop — can make the stream iterator reject as it tears down;
+    // that is the expected teardown for all three, so swallow it and fall
+    // through. Anything else is a genuine stream failure — rethrow it to the
+    // activity's error handler.
+    if (!state.stallDetected && !state.firstDenialDetected && !state.costCapExceeded) {
+      throw streamErr;
+    }
     console.warn(
       `ExecuteCursor stream ended via cancel: execution=${executionId}, ` +
-        `stall=${state.stallDetected}, firstDenial=${state.firstDenialDetected}`,
+        `stall=${state.stallDetected}, firstDenial=${state.firstDenialDetected}, ` +
+        `costCap=${state.costCapExceeded}`,
     );
   } finally {
     state.stallWatchdog.stop();
@@ -412,10 +461,12 @@ export async function consumeCursorTurnStream(
 
   // Report why the stream ended, in the same precedence the activity's epilogue
   // applies: a stall (an EXECUTION_FAILED terminal) outranks everything; a
-  // platform stop and a first denial are distinct proceed/return outcomes; a
-  // pause is the fallback for a cancellation with no other cause.
+  // platform stop, a cost-cap stop, and a first denial are distinct
+  // return/proceed outcomes; a pause is the fallback for a cancellation with
+  // no other cause.
   if (state.stallDetected) return "stalled";
   if (state.platformStopSignaled) return "platform-stop";
+  if (state.costCapExceeded) return "cost-cap";
   if (state.firstDenialDetected) return "first-denial";
   if (state.pauseDetected || isCancelled()) return "paused";
   return "completed";

package/src/activities/execute-deep-agent/__tests__/hitl-reject.test.ts

@@ -251,6 +251,7 @@ const httpConfig: Config = {
   checkpointerProxyEndpoint: "http://localhost:7234",
   primaryModel: "claude-sonnet",
   cursorStreamStallTimeoutMs: 180000,
+  agentResolveTimeoutMs: 120000,
   workspaceLockTimeoutMs: 900000,
 };
 

package/src/activities/execute-deep-agent/__tests__/hitl-resume-approve-all.test.ts

@@ -296,6 +296,7 @@ const baseConfig: Config = {
   checkpointerProxyEndpoint: "http://localhost:7234",
   primaryModel: "claude-sonnet",
   cursorStreamStallTimeoutMs: 180000,
+  agentResolveTimeoutMs: 120000,
   workspaceLockTimeoutMs: 900000,
 };
 

package/src/activities/execute-deep-agent/__tests__/hitl-resume-history.test.ts

@@ -250,6 +250,7 @@ const baseConfig: Config = {
   checkpointerProxyEndpoint: "http://localhost:7234",
   primaryModel: "claude-sonnet",
   cursorStreamStallTimeoutMs: 180000,
+  agentResolveTimeoutMs: 120000,
   workspaceLockTimeoutMs: 900000,
 };
 

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

@@ -47,6 +47,7 @@ describe("ExecuteDeepAgent activity", () => {
     checkpointerProxyEndpoint: null,
     primaryModel: "gpt-4.1",
     cursorStreamStallTimeoutMs: 180000,
+    agentResolveTimeoutMs: 120000,
     workspaceLockTimeoutMs: 900000,
   };
 

package/src/activities/execute-deep-agent/__tests__/prompt-builder.test.ts

@@ -208,6 +208,64 @@ describe("buildEnhancedSystemPrompt", () => {
     expect(prompt).not.toContain("## Workspace");
   });
 
+  describe("rollover context bridge (DD-013)", () => {
+    const base = {
+      instructions: "Test",
+      provisionResults: [],
+      containerRoot: "",
+      skillsPromptSection: "",
+      workspaceFileRefs: [],
+      workspaceRoot: "",
+      injectedFiles: [],
+    };
+
+    it("appends the bridge as standing session context (every-turn injection)", () => {
+      const prompt = buildEnhancedSystemPrompt({
+        ...base,
+        contextBridge: "Subject: Orders\nUser: where is my order?\nAssistant: Shipped.",
+      });
+
+      expect(prompt).toContain("## Previous conversation context");
+      expect(prompt).toContain("User: where is my order?");
+      expect(prompt).toContain("Do not repeat it back");
+    });
+
+    it("omits the section when the session carries no bridge", () => {
+      const prompt = buildEnhancedSystemPrompt(base);
+
+      expect(prompt).not.toContain("## Previous conversation context");
+    });
+  });
+
+  describe("channel sender identity", () => {
+    const base = {
+      instructions: "Test",
+      provisionResults: [],
+      containerRoot: "",
+      skillsPromptSection: "",
+      workspaceFileRefs: [],
+      workspaceRoot: "",
+      injectedFiles: [],
+    };
+
+    it("appends the sender as standing session context (every-turn injection)", () => {
+      const prompt = buildEnhancedSystemPrompt({
+        ...base,
+        senderIdentity: { value: "15550001111", kind: "whatsapp_phone" },
+      });
+
+      expect(prompt).toContain("## Conversation sender");
+      expect(prompt).toContain("WhatsApp phone number");
+      expect(prompt).toContain("15550001111");
+    });
+
+    it("omits the section when the session carries no identity (console sessions)", () => {
+      const prompt = buildEnhancedSystemPrompt(base);
+
+      expect(prompt).not.toContain("## Conversation sender");
+    });
+  });
+
   describe("plan mode", () => {
     const base = {
       instructions: "Test",

package/src/activities/execute-deep-agent/__tests__/sequential-gate-resume.test.ts

@@ -256,6 +256,7 @@ const memoryConfig: Config = {
   checkpointerProxyEndpoint: null,
   primaryModel: "claude-sonnet",
   cursorStreamStallTimeoutMs: 180000,
+  agentResolveTimeoutMs: 120000,
   workspaceLockTimeoutMs: 900000,
 };