@stigmer/runner 3.2.1 → 3.2.2

package/src/activities/call-transform.ts

@@ -14,7 +14,11 @@
  */
 
 import { ApplicationFailure } from "@temporalio/activity";
-import { evaluateExpression } from "../workflow-engine/expression.js";
+import {
+  evaluateExpression,
+  isStrictExpr,
+  sanitizeExpr,
+} from "../workflow-engine/expression.js";
 
 export interface TransformConfig {
   readonly engine: string;
@@ -38,6 +42,13 @@ export async function transformAction(
       "TRANSFORM_MISSING_EXPRESSION",
     );
   }
+  if (typeof config.expression !== "string") {
+    throw ApplicationFailure.nonRetryable(
+      `transform: 'expression' must be a jq string, got ${typeof config.expression}. ` +
+        "Fix the expression in the workflow's transform task_config.",
+      "TRANSFORM_INVALID_EXPRESSION",
+    );
+  }
 
   const engine = normalizeEngine(config.engine || "JQ");
 
@@ -50,5 +61,12 @@ export async function transformAction(
 
   const data = config.input !== undefined ? config.input : taskInput;
 
-  return evaluateExpression(config.expression, data, {});
+  // The expression arrives unresolved (deferred code — see the
+  // call-function builder). Accept both the strict `${ ... }` wrapper
+  // and the bare jq form the converter emits.
+  const expression = isStrictExpr(config.expression)
+    ? sanitizeExpr(config.expression)
+    : config.expression;
+
+  return evaluateExpression(expression, data, {});
 }

package/src/activities/call-validate.ts

@@ -18,7 +18,11 @@
  */
 
 import { ApplicationFailure } from "@temporalio/activity";
-import { evaluateExpression } from "../workflow-engine/expression.js";
+import {
+  evaluateExpression,
+  isStrictExpr,
+  sanitizeExpr,
+} from "../workflow-engine/expression.js";
 
 export interface ValidateConfig {
   readonly input: unknown;
@@ -160,7 +164,28 @@ async function validateRules(
   const errors: ValidationError[] = [];
 
   for (const rule of rules) {
-    const result = await evaluateExpression(rule.expression, data, {});
+    // Config guard: the expression must be a jq string. Anything else is
+    // a workflow-definition defect (or an upstream resolution bug) — name
+    // the rule and what to fix instead of crashing in the jq engine.
+    if (typeof rule.expression !== "string" || rule.expression.length === 0) {
+      errors.push({
+        rule: rule.name,
+        message:
+          `Rule '${rule.name}' has an invalid 'expression': expected a jq ` +
+          `predicate string, got ${typeof rule.expression}. Fix the rule in ` +
+          `the workflow's validate task_config.`,
+      });
+      continue;
+    }
+
+    // Rule expressions arrive unresolved (deferred code — see the
+    // call-function builder). Accept both the strict `${ ... }` wrapper
+    // and a bare jq predicate.
+    const expr = isStrictExpr(rule.expression)
+      ? sanitizeExpr(rule.expression)
+      : rule.expression;
+
+    const result = await evaluateExpression(expr, data, {});
     if (!result) {
       errors.push({
         rule: rule.name,

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

@@ -25,6 +25,7 @@ import { StigmerClient } from "../client/stigmer-client.js";
 import { mcpServerToResolved } from "../shared/mcp-resolver.js";
 import { toMcpClientConfig } from "../shared/mcp-manager.js";
 import { detectOAuthChallenge } from "../shared/mcp-oauth-detect.js";
+import { withTimeout } from "../shared/with-timeout.js";
 import type { McpServer } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
 import type { Config } from "../config.js";
 
@@ -326,7 +327,12 @@ async function connectAndDiscover(
   const resourceTemplates: DiscoveredResourceTemplateResult[] = [];
 
   try {
-    await withTimeout(SESSION_INIT_TIMEOUT_MS, slug, async () => {
+    const timeoutMessage =
+      `MCP server '${slug}' did not respond within ` +
+      `${Math.round(SESSION_INIT_TIMEOUT_MS / 1000)}s. If this server requires compilation or ` +
+      `package installation on first run (e.g. go run, npx), the cold ` +
+      `start may have exceeded the discovery timeout.`;
+    await withTimeout(SESSION_INIT_TIMEOUT_MS, timeoutMessage, async () => {
       await client.initializeConnections();
 
       const mcpClient = await client.getClient(slug);
@@ -411,33 +417,6 @@ async function classifyHttpOAuthFailure(
   return detectOAuthChallenge(connection.url, connection.headers, slug);
 }
 
-async function withTimeout<T>(
-  ms: number,
-  serverSlug: string,
-  fn: () => Promise<T>,
-): Promise<T> {
-  return new Promise<T>((resolve, reject) => {
-    const timer = setTimeout(() => {
-      reject(new Error(
-        `MCP server '${serverSlug}' did not respond within ` +
-        `${Math.round(ms / 1000)}s. If this server requires compilation or ` +
-        `package installation on first run (e.g. go run, npx), the cold ` +
-        `start may have exceeded the discovery timeout.`,
-      ));
-    }, ms);
-
-    fn()
-      .then((result) => {
-        clearTimeout(timer);
-        resolve(result);
-      })
-      .catch((err) => {
-        clearTimeout(timer);
-        reject(err);
-      });
-  });
-}
-
 // ─────────────────────────────────────────────────────────────────────────────
 // Temporal Activity Factory
 // ─────────────────────────────────────────────────────────────────────────────

package/src/activities/execute-cursor/__tests__/build-prompt.test.ts

@@ -87,6 +87,71 @@ describe("buildPrompt", () => {
     expect(prompt).toContain(USER_MESSAGE);
   });
 
+  it("carries the rollover context bridge on the first execution (DD-013)", () => {
+    const prompt = buildPrompt(
+      input({
+        resolution: resolution("local", "created_first_execution"),
+        contextBridge: "Subject: Orders\nUser: where is my order?\nAssistant: Shipped.",
+      }),
+    );
+    expect(prompt).toContain("<previous_conversation_context>");
+    expect(prompt).toContain("User: where is my order?");
+    // The bridge is CONTEXT; the approval protocol keeps its pinned
+    // last-before-task slot so instructions outweigh it.
+    expect(prompt.indexOf("<previous_conversation_context>"))
+      .toBeLessThan(prompt.indexOf("<tool_approval_protocol>"));
+  });
+
+  it("never bridges a successfully resumed agent — its native context IS the conversation", () => {
+    const prompt = buildPrompt(
+      input({
+        resolution: resolution("local", "resumed_successfully"),
+        contextBridge: "Subject: Orders\nUser: hi\nAssistant: hello",
+      }),
+    );
+    expect(prompt).toBe(USER_MESSAGE);
+  });
+
+  it("omits the bridge section when the session carries none", () => {
+    const prompt = buildPrompt(
+      input({ resolution: resolution("local", "created_first_execution") }),
+    );
+    expect(prompt).not.toContain("<previous_conversation_context>");
+  });
+
+  it("carries the channel sender identity on the first execution", () => {
+    const prompt = buildPrompt(
+      input({
+        resolution: resolution("local", "created_first_execution"),
+        senderIdentity: { value: "15550001111", kind: "whatsapp_phone" },
+      }),
+    );
+    expect(prompt).toContain("<conversation_sender>");
+    expect(prompt).toContain("WhatsApp phone number");
+    expect(prompt).toContain("15550001111");
+    // Identity is CONTEXT like the bridge; the approval protocol keeps its
+    // pinned last-before-task slot.
+    expect(prompt.indexOf("<conversation_sender>"))
+      .toBeLessThan(prompt.indexOf("<tool_approval_protocol>"));
+  });
+
+  it("never re-sends the identity to a successfully resumed agent — its native context carries it", () => {
+    const prompt = buildPrompt(
+      input({
+        resolution: resolution("local", "resumed_successfully"),
+        senderIdentity: { value: "U0USER", kind: "slack_user_id" },
+      }),
+    );
+    expect(prompt).toBe(USER_MESSAGE);
+  });
+
+  it("omits the sender section when the session carries no identity (console sessions)", () => {
+    const prompt = buildPrompt(
+      input({ resolution: resolution("local", "created_first_execution") }),
+    );
+    expect(prompt).not.toContain("<conversation_sender>");
+  });
+
   it("uses the reinvocation prompt for a HITL reinvocation (human-meaningful, no opaque ids)", () => {
     const approvalDecisions = new Map<string, ApprovalAction>([
       ["tool-call-1", ApprovalAction.APPROVE],

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";
@@ -115,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";
 
 /**
@@ -257,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");
@@ -270,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();
@@ -280,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 ?? "",
@@ -554,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,
@@ -815,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(
@@ -878,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
@@ -962,16 +1001,10 @@ async function executeCursorInner(
       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,
@@ -1460,6 +1493,8 @@ async function executeCursorInner(
             attachmentPaths,
             pendingApprovals: adjudicatedApprovals,
             interactionMode,
+            contextBridge: readContextBridge(blueprint.sessionSpec.metadata),
+            senderIdentity: readSenderIdentity(blueprint.sessionSpec.metadata),
           });
 
           console.log(
@@ -1866,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
@@ -2019,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;
 }
 
 /**
@@ -2083,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,
@@ -2094,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-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,
 };
 

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

@@ -10,6 +10,11 @@ import { relative } from "node:path";
 import { InteractionMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import type { ProvisionResult, GitMetadata } from "../../shared/workspace/types.js";
 import { SourceType } from "../../shared/workspace/types.js";
+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,
@@ -106,6 +111,24 @@ export interface PromptBuilderInput {
    * 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`. Injected on
+   * EVERY turn by design: the native system prompt is rebuilt per
+   * invocation (never checkpointed with the message history), so a
+   * first-turn-only injection would vanish from turn 2 onward. The bridge
+   * is standing session context, like skills.
+   */
+  contextBridge?: string;
+  /**
+   * Channel sender identity (attribution, not authorization): the
+   * provider-verified identifier of the person on the channel, read from
+   * `SessionSpec.metadata`. Injected on EVERY turn like the bridge — the
+   * native system prompt is rebuilt per invocation, and the sender is
+   * constant for the session's lifetime (channel sessions are keyed
+   * per-sender).
+   */
+  senderIdentity?: SenderIdentity;
 }
 
 export interface InjectedFile {
@@ -147,6 +170,18 @@ export function buildEnhancedSystemPrompt(input: PromptBuilderInput): string {
     prompt += buildInjectedFilesSection(input.injectedFiles);
   }
 
+  if (input.senderIdentity) {
+    prompt +=
+      "\n\n## Conversation sender\n\n" +
+      formatSenderIdentityText(input.senderIdentity);
+  }
+
+  if (input.contextBridge) {
+    prompt +=
+      "\n\n## Previous conversation context\n\n" +
+      formatContextBridgeText(input.contextBridge);
+  }
+
   prompt += RESPONSE_RULES;
   prompt += SUB_AGENT_RULES;
 

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

@@ -23,6 +23,8 @@ import type { DynamicStructuredTool } from "@langchain/core/tools";
 import type { Config } from "../../config.js";
 import type { StigmerClient } from "../../client/stigmer-client.js";
 import { createCheckpointer } from "../../shared/checkpointer/factory.js";
+import { readContextBridge } from "../../shared/context-bridge.js";
+import { readSenderIdentity } from "../../shared/sender-identity.js";
 import { connectMcpServers, type McpConnectionResult } from "../../shared/mcp-manager.js";
 import { resolveMcpServers } from "../../shared/mcp-resolver.js";
 import { backfillMcpServersIfNeeded } from "../../shared/connect-backfill.js";
@@ -386,6 +388,8 @@ export async function performSetup(deps: SetupDependencies): Promise<SetupResult
       injectedFiles,
       interactionMode: execution.spec!.executionConfig?.interactionMode,
       buildFromPlan: execution.spec!.executionConfig?.buildFromPlan,
+      contextBridge: readContextBridge(session.spec!.metadata),
+      senderIdentity: readSenderIdentity(session.spec!.metadata),
     });
 
     // Step 9: Construct the LLM model. Resolution to the provider API id

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

@@ -221,6 +221,7 @@ export function toProtoEvent(desc: WorkflowEventDescriptor): WorkflowExecutionEv
         case: "taskStarted",
         value: create(TaskStartedPayloadSchema, {
           taskKind: TASK_KIND_MAP[desc.taskKind] ?? 0,
+          inputSummary: toJsonObject(desc.inputSummary),
           attemptNumber: desc.attemptNumber,
         }),
       };
@@ -233,6 +234,7 @@ export function toProtoEvent(desc: WorkflowEventDescriptor): WorkflowExecutionEv
         value: create(TaskCompletedPayloadSchema, {
           taskKind: TASK_KIND_MAP[desc.taskKind] ?? 0,
           durationMs: BigInt(desc.durationMs),
+          outputSummary: toJsonObject(desc.outputSummary),
           costMicros: BigInt(desc.costMicros),
           tokensUsed: BigInt(desc.tokensUsed),
         }),