feat(runner): dispatch each approval independently and accept partial answer sets

Author: mmabrouk

services/runner/src/engines/sandbox_agent/run-turn.ts

@@ -200,6 +200,14 @@ export async function runTurn(
       env.sessionDestroyRequested = true;
       return env.sandbox.destroySession?.(env.session.id);
     });
+    if (opts.resume?.carriedForward.length) {
+      for (const gate of opts.resume.carriedForward) {
+        env.parkedApprovals.set(gate.toolCallId, gate);
+        env.parkedApproval ??= gate;
+        pause.markPausedToolCall(gate.toolCallId);
+      }
+      env.approvalGateCount = env.parkedApprovals.size;
+    }
     // A human pause resolves this signal exactly once, the moment the turn parks for input — the one
     // place every pause path converges, so the one place to retire the run-limits deadlines for good.
     void pause.signal.then(() => runLimits.notePaused());
@@ -592,11 +600,8 @@ export async function runTurn(
     // resolves, and the pause signal ends the turn.
     let promptPromise: Promise<unknown>;
     if (opts.resume) {
-      // The new (resume) turn owns streaming + tracing; the environment is already wired to route
-      // continued events into this turn's sink (env.currentTurn was set above). Every parked gate
-      // of the turn is answered here, one `respondPermission` per gate keyed by its tool-call id.
-      // All decisions share the ONE held prompt promise (one prompt per turn), so it is set once;
-      // answering the last gate lets the original prompt continue from here.
+      // The resume turn owns continued events; each decision answers one parked gate by id.
+      // Carried gates keep the shared original prompt pending until a later answer.
       const decisions = opts.resume.decisions;
       promptPromise = Promise.resolve(decisions[0]?.promptPromise);
       promptPromise.catch(() => {});
@@ -629,9 +634,8 @@ export async function runTurn(
         // independently — an approve and a deny in the same turn each land on the right call.
         await env.session.respondPermission(decision.permissionId, decision.reply);
         // The gate is answered: resolve its durable interaction row (the parked pending row the
-        // cold path would otherwise resolve via its decision map). The fresh per-turn pause
-        // controller starts with an EMPTY pausedToolCallIds set, so the resumed calls'
-        // `tool_call_update` frames are no longer suppressed and stream through.
+        // cold path would otherwise resolve via its decision map). Only carried-forward ids were
+        // re-marked paused, so answered calls stream their terminal frames normally.
         resolveInteractionToken(decision.interactionToken, {
           approved: decision.reply === "once",
           toolCallId: decision.toolCallId,
@@ -640,6 +644,9 @@ export async function runTurn(
           `[keepalive] resume answered gate reply=${decision.reply} tool=${decision.toolName ?? "?"}`,
         );
       }
+      // The harness still holds carried gates inside the original prompt, so re-arm the pause after
+      // this answer batch and let the normal park path refresh their approval TTL.
+      if (opts.resume.carriedForward.length > 0) pause.pause();
     } else {
       promptPromise = Promise.resolve(
         env.session.prompt([{ type: "text", text: turnText }]),

services/runner/src/engines/sandbox_agent/runtime-contracts.ts

@@ -157,13 +157,13 @@ export interface RunTurnOptions {
    */
   approvalParkMode?: boolean;
   /**
-   * A live approval resume: answer every parked gate of the turn (keyed by tool-call id) and
-   * stream the continued prompt's events. A turn can hold more than one parked gate, so the
-   * resume carries a LIST — the server builds it from the inbound approval replies, one decision
-   * per parked gate. All decisions share the one held prompt promise (there is one prompt per
-   * turn); `runTurn` answers each gate then awaits that single continuation.
+   * A live approval resume: answer the matching parked gates and carry the untouched gates into
+   * the next park. All decisions share the one held prompt promise (there is one prompt per turn).
    */
-  resume?: { decisions: ResumeApprovalInput[] };
+  resume?: {
+    decisions: ResumeApprovalInput[];
+    carriedForward: ParkedApproval[];
+  };
 }
 
 /**

services/runner/src/server.ts

@@ -37,6 +37,7 @@ import {
   runSandboxAgent,
   runTurn,
   shouldPark,
+  type ParkedApproval,
   type ResumeApprovalInput,
   type RunTurnOptions,
   type SessionEnvironment,
@@ -678,15 +679,12 @@ export async function runWithKeepalive(
     // history fingerprint (an edited transcript must not continue wrongly), and a hard mount-expiry
     // bound — if the parked session's mount credentials are past expiry, its durable cwd can no
     // longer be written, so evict to cold.
-    // The turn may hold several parked gates (parallel gated tool calls). Build one resume
-    // decision per parked gate, keyed by tool-call id. The whole turn resumes live ONLY when the
-    // request answers EVERY parked gate — the frontend's all-settled rule guarantees a resume /run
-    // is sent only after the human answered all cards, so a partial set is a mismatch that
-    // degrades to cold (which re-raises and multiplexes whatever subset). `parked` (the first
-    // gate) is the representative for logging and the per-turn-uniform checks.
+    // Split parallel parked gates by tool-call id. Any non-empty answer set resumes live; untouched
+    // gates stay pending in the same process and are carried into the next approval park.
     const parked = existing.environment.parkedApproval;
     const parkedList = [...existing.environment.parkedApprovals.values()];
     const resumeDecisions: ResumeApprovalInput[] = [];
+    const carriedForward: ParkedApproval[] = [];
     let mismatch: string | undefined;
     if (parkedList.length === 0) {
       mismatch = "no-parked-gate";
@@ -703,9 +701,8 @@ export async function runWithKeepalive(
         }
         const decision = approvalDecisionForToolCall(request, gate.toolCallId);
         if (!decision) {
-          // A gate with no matching reply: fresh user text, or the human answered only some cards.
-          mismatch = "no-matching-approval";
-          break;
+          carriedForward.push(gate);
+          continue;
         }
         resumeDecisions.push({
           permissionId: gate.permissionId,
@@ -746,7 +743,8 @@ export async function runWithKeepalive(
       ).length;
       const rejectCount = resumeDecisions.length - approveCount;
       klog(
-        `resume key=${key} gates=${resumeDecisions.length} ` +
+        `resume key=${key} gates=${parkedList.length} answered=${resumeDecisions.length} ` +
+          `carried=${carriedForward.length} ` +
           `approve=${approveCount} reject=${rejectCount} tool=${parked?.toolName ?? "?"}`,
       );
       let result: AgentRunResult;
@@ -761,7 +759,7 @@ export async function runWithKeepalive(
           signal,
           {
             approvalParkMode: true,
-            resume: { decisions: resumeDecisions },
+            resume: { decisions: resumeDecisions, carriedForward },
           },
         );
       } catch (err) {
@@ -839,8 +837,8 @@ const runAgent: RunAgent = (request, emit, signal, options) => {
 };
 
 /**
- * The durable interaction token of a parked approval gate this request answers in-band, if
- * any. The turn-start cancel-stale sweep must spare it: the gate belongs to the PREVIOUS turn
+ * The durable interaction tokens of parked approval gates this request answers in-band, if
+ * any. The turn-start cancel-stale sweep must spare them: each gate belongs to the PREVIOUS turn
  * (so the sweep's own `turn_id` exemption misses it), an in-band answer never transitions the
  * row off `pending` (only the interactions-plane respond endpoint does), and the resume
  * resolves the token after consuming the decision. Swept first, the granted gate's record
@@ -855,18 +853,13 @@ function inBandAnswerTokens(request: AgentRunRequest): string[] | undefined {
     keepalivePools[provider].awaitingApproval(sessionId)?.environment
       .parkedApprovals;
   if (!parked || parked.size === 0) return undefined;
-  // A turn can park several gates. Spare tokens from the stale sweep ONLY when this request
-  // answers EVERY parked gate — that is exactly when the dispatch resumes live and resolves them.
-  // If any gate is unanswered the turn degrades to cold (the all-or-cold resume rule), and sparing
-  // an answered subset would strand those interaction rows as pending forever (no live resume ever
-  // resolves them). In that case spare nothing: the cold path re-raises and the sweep correctly
-  // cancels the old rows.
+  // A partial resume resolves only the answered rows. Carried-forward rows stay pending and receive
+  // a fresh approval park, so only matching answer tokens are exempt from stale cancellation.
   const tokens: string[] = [];
   for (const gate of parked.values()) {
-    if (approvalDecisionForToolCall(request, gate.toolCallId) === undefined) {
-      return undefined;
+    if (approvalDecisionForToolCall(request, gate.toolCallId) !== undefined) {
+      tokens.push(gate.interactionToken);
     }
-    tokens.push(gate.interactionToken);
   }
   return tokens.length > 0 ? tokens : undefined;
 }