feat(frontend): parallel-approval hold, reload integrity, and context-driven config sections

hosting/docker-compose/ee/docker-compose.dev.yml

@@ -403,6 +403,12 @@ services:
             AGENTA_RUNNER_HOST: ${AGENTA_RUNNER_HOST:-0.0.0.0}
             AGENTA_RUNNER_TOKEN: ${AGENTA_RUNNER_TOKEN:?AGENTA_RUNNER_TOKEN is required}
             PI_CODING_AGENT_DIR: /pi-agent
+            # Claude Code harness (subscription / runtime_provided auth). CLAUDE_CONFIG_DIR is the
+            # writable config/state mount the run-plan requires; CLAUDE_CODE_OAUTH_TOKEN is the login
+            # (macOS keeps the Claude login in Keychain, which can't be bind-mounted, so the token is
+            # the local auth path). Both resolve from the loaded env file.
+            CLAUDE_CONFIG_DIR: /claude-config
+            CLAUDE_CODE_OAUTH_TOKEN: ${CLAUDE_CODE_OAUTH_TOKEN:-}
             # The API as reached FROM this container — by its compose service name, over the
             # network (the same `http://api:8000` the workers use), NOT the public
             # `http://localhost/api` (which doesn't resolve inside a container). Used by the
@@ -430,6 +436,10 @@ services:
             # Read-write on purpose: the harness refreshes its own OAuth token here and the new
             # token must persist back to the host login (a copy would discard it).
             - ${HOME}/.pi/agent:/pi-agent:rw
+            # Claude Code config/state (writable). The login comes from CLAUDE_CODE_OAUTH_TOKEN; this
+            # dir holds the settings/session state the harness reads and refreshes. Dedicated dir (not
+            # ~/.claude) so the container never touches the host's real Claude config.
+            - ${HOME}/.agenta-claude-config:/claude-config:rw
         # === NETWORK ============================================== #
         networks:
             - agenta-network

services/runner/src/engines/sandbox_agent/acp-interactions.ts

@@ -51,6 +51,13 @@ export interface AttachPermissionResponderInput {
    * gracefully because a paused Claude turn never resolves `session.prompt()` on its own.
    */
   onPause?: () => void;
+  /**
+   * Collect-then-pause seam for parkable APPROVAL gates (keep-alive only). Parallel gates arrive
+   * staggered, so instead of ending the turn on the first, each gate calls this to (re)arm a
+   * debounced pause — the turn parks once the harness goes quiet, with the whole batch of gates
+   * emitted. When absent (cold path, client tools) the gate falls back to `onPause` (pause now).
+   */
+  onScheduleApprovalPause?: () => void;
   log?: (msg: string) => void;
   /** Called with the ACP tool-call id when a gate pauses the turn. */
   onPausedToolCall?: (id: string) => void;
@@ -112,6 +119,7 @@ export function attachPermissionResponder({
   latch,
   serverPermissions = new Map(),
   onPause,
+  onScheduleApprovalPause,
   log,
   onPausedToolCall,
   onCreateInteraction,
@@ -155,35 +163,41 @@ export function attachPermissionResponder({
     gate: GateDescriptor,
     gateType: ParkedApprovalGateType,
   ): void => {
-    // Signal the parkable gate BEFORE the latch so a keep-alive resume can record the pending
-    // permission id and the multi-gate detector counts every pending gate (not just the first).
+    // Record the parkable gate so a keep-alive resume can answer it via `respondPermission`. In
+    // collect-then-pause mode every gate is recorded (the whole parallel batch parks together).
     const gateToolCallId = stringValue(req?.toolCall?.toolCallId);
+    const eventId = interactionEventId(id, gateToolCallId);
     onUserApprovalGate?.({
       permissionId: id,
       toolCallId: gateToolCallId ?? "",
       toolName: gate.toolName,
       args: gate.args,
-      interactionToken: interactionEventId(id, gateToolCallId),
+      interactionToken: eventId,
       gateType,
     });
-    if (!latch.tryAcquire()) return;
-    const toolCallId = stringValue(req?.toolCall?.toolCallId);
-    const eventId = interactionEventId(id, toolCallId);
-    if (toolCallId) onPausedToolCall?.(toolCallId);
+    // Keep-alive (`onScheduleApprovalPause` present): emit EVERY concurrent gate and debounce the
+    // pause, so a parallel batch surfaces as N approval cards that park together. Cold path keeps
+    // the one-pause-per-turn latch — a single gate emits, and a multi-gate turn tears down cold as
+    // before (its siblings are settled and replayed as retry nudges).
+    const collecting = Boolean(onScheduleApprovalPause);
+    if (!collecting && !latch.tryAcquire()) return;
+    // A duplicate delivery of the SAME gate (same id + tool-call) must not double-emit its card.
+    if (createdInteractionIds.has(eventId)) return;
+    if (gateToolCallId) onPausedToolCall?.(gateToolCallId);
     run.emitEvent({
       type: "interaction_request",
       id: eventId,
       kind: "user_approval",
       payload: {
-        toolCallId,
+        toolCallId: gateToolCallId,
         toolCall: stampResolvedName(req?.toolCall, gate),
         availableReplies: stringArray(req?.availableReplies),
         options: req?.options,
       },
     });
     createdInteractionIds.add(eventId);
     onCreateInteraction?.(eventId, gate.toolName, gate.args, "user_approval");
-    onPause?.();
+    (onScheduleApprovalPause ?? onPause)?.();
   };
 
   const pauseClientTool = (

services/runner/src/engines/sandbox_agent/environment-setup.ts

@@ -2,23 +2,14 @@ import { rmSync } from "node:fs";
 
 import { apiBase } from "../../apiBase.ts";
 
-import {
-  resolveRunSessionId,
-  type AgentRunRequest,
-} from "../../protocol.ts";
+import { resolveRunSessionId, type AgentRunRequest } from "../../protocol.ts";
 import { type ClientToolOutcome } from "../../responder.ts";
 import type { ClientToolRelay } from "../../tools/client-tool-relay.ts";
-import {
-  agentMountPath,
-  signAgentMountCredentials,
-} from "./agent-mount.ts";
+import { agentMountPath, signAgentMountCredentials } from "./agent-mount.ts";
 import { createToolCallCorrelationIndex } from "./client-tools.ts";
 import { buildDaemonEnv, resolveDaemonBinary } from "./daemon.ts";
 import { conciseError } from "./errors.ts";
-import {
-  signSessionMountCredentials,
-  type MountCredentials,
-} from "./mount.ts";
+import { signSessionMountCredentials, type MountCredentials } from "./mount.ts";
 import {
   buildPiExtensionEnv,
   configurePiSessionWorkspace,
@@ -347,8 +338,9 @@ export async function prepareEnvironmentSetup(
     closeToolMcp: undefined,
     currentTurn: undefined,
     lastTurnToolCallIds: [],
-    parkedApproval: undefined,
+    parkedApprovals: [],
     approvalGateCount: 0,
+    deferredSiblingSettled: false,
     destroyed: false,
     destroy: async () => {},
     clearTurn: () => {},

services/runner/src/engines/sandbox_agent/pause.ts

@@ -13,6 +13,7 @@ export class PendingApprovalPauseController {
   private readonly pausedToolCallIds = new Set<string>();
   private resolvePause: (() => void) | undefined;
   private eventDrain: Promise<void> = Promise.resolve();
+  private pauseTimer: ReturnType<typeof setTimeout> | undefined;
 
   readonly signal: Promise<void>;
 
@@ -24,8 +25,49 @@ export class PendingApprovalPauseController {
     });
   }
 
+  /**
+   * Debounced pause: (re)arm a timer so the turn pauses only once the harness has been quiet for
+   * `delayMs`. Parallel approval gates arrive staggered (~0.5s apart, measured), so pausing on the
+   * FIRST would strand the rest; each incoming gate calls this again to extend the window, and the
+   * turn parks once with the whole batch. A late gate that lands after the timer fires falls back to
+   * the straggler path (force-settled → cold retry), exactly as a non-collected gate does today.
+   * `pause()` (client tool, non-parkable, teardown) still ends the turn immediately.
+   */
+  schedulePause(delayMs: number): void {
+    if (this.pendingApproval) return; // already paused; the batch is closed
+    // No collection window: pause on this gate immediately (synchronous), i.e. today's
+    // one-gate-per-turn behavior. Also the deterministic path for tests.
+    if (delayMs <= 0) {
+      this.pause();
+      return;
+    }
+    if (this.pauseTimer) clearTimeout(this.pauseTimer);
+    this.pauseTimer = setTimeout(() => {
+      this.pauseTimer = undefined;
+      this.pause();
+    }, delayMs);
+    // Do not keep the event loop alive solely for the collection window.
+    this.pauseTimer.unref?.();
+  }
+
+  /**
+   * Cancel any armed collect-window timer without pausing. Turn-scoped, like `runLimits.dispose()`:
+   * `run-turn.ts` calls it in `finally` so a timer this turn armed can never fire against the pooled
+   * `env` after the turn exited some other way (run-limit trip, throw). No-op once `pause()` ran.
+   */
+  dispose(): void {
+    if (this.pauseTimer) {
+      clearTimeout(this.pauseTimer);
+      this.pauseTimer = undefined;
+    }
+  }
+
   pause(): void {
     if (this.pendingApproval) return;
+    if (this.pauseTimer) {
+      clearTimeout(this.pauseTimer);
+      this.pauseTimer = undefined;
+    }
     this.pendingApproval = true;
     let destroyResult: Promise<void> | void | undefined;
     try {