@bermudi/pi-delegate 0.1.18 → 0.1.20

package/dispatch.ts

@@ -1,14 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { AgentToolUpdateCallback } from "@earendil-works/pi-agent-core";
-import {
-  ticketRegistry,
-  generateTicketId,
-  deliverTicketResults,
-  sweepTickets,
-  resolveFinalTicketStatus,
-  settleTicket,
-  notifyWaiters,
-} from "./tickets.ts";
+import { getDefaultDelegateRuntime, type DelegateRuntime } from "./runtime.ts";
+import { PauseController } from "./pause.ts";
 import {
   getConcurrencyLimit,
   getMaxAsyncTickets,
@@ -18,7 +11,7 @@ import {
 import type { DelegateConfig } from "./config.ts";
 import { getCurrentLeafId } from "./leaf.ts";
 import { getModelKey, mapConcurrentByModel } from "./concurrency.ts";
-import { aggregateTaskResults, sumUsage } from "./usage.ts";
+import { aggregateTaskResults, emptyUsage, sumUsage } from "./usage.ts";
 import { runResolvedTask, updateProgressFromRun } from "./lifecycle.ts";
 import {
   fmtDuration,
@@ -36,8 +29,13 @@ import {
   type SharedWriteConflict,
 } from "./shared-write-safety.ts";
 import type { CallSpan } from "./telemetry.ts";
-import { prepareIsolatedBatch } from "./isolated-workspace.ts";
+import {
+  prepareIsolatedBatch,
+  type IsolatedReconcileOptions,
+  type PreparedIsolatedBatch,
+} from "./isolated-workspace.ts";
 import { sanitizeTerminalLine } from "./utils.ts";
+import { checkScratchWorkspaceSupport } from "./workspace.ts";
 import { quarantinedTasks } from "./session-quarantine.ts";
 import type {
   AgentConfig,
@@ -135,6 +133,7 @@ export function makeFireUpdater(
   resolved: ResolvedTask[],
   parentModelId: string | undefined,
   dispatchWarning?: string,
+  serializedNotice?: string,
 ): () => void {
   return () =>
     onUpdate?.({
@@ -150,6 +149,7 @@ export function makeFireUpdater(
         progress: [...progress],
         parentModel: parentModelId,
         dispatchWarning,
+        serializedNotice,
       },
     });
 }
@@ -165,6 +165,10 @@ export interface AsyncDispatchInput {
   callSpan?: CallSpan;
   dispatchConfig: DelegateConfig;
   dispatchWarning?: string;
+  /** Same-call shared-writer groups admission serialized into task order. */
+  serializedGroups?: SharedWriteConflict[];
+  serializedNotice?: string;
+  runtime?: DelegateRuntime;
 }
 
 /** Inputs needed by the sync (blocking) dispatch path. */
@@ -179,6 +183,10 @@ export interface SyncDispatchInput {
   callSpan?: CallSpan;
   dispatchConfig: DelegateConfig;
   dispatchWarning?: string;
+  /** Same-call shared-writer groups admission serialized into task order. */
+  serializedGroups?: SharedWriteConflict[];
+  serializedNotice?: string;
+  runtime?: DelegateRuntime;
 }
 
 /** Inputs for the normal task-validation, resolution, and dispatch path. */
@@ -192,6 +200,7 @@ export interface DelegateDispatchInput {
   signal: AbortSignal | undefined;
   onUpdate: AgentToolUpdateCallback<DelegateDetails> | undefined;
   callSpan?: CallSpan;
+  runtime?: DelegateRuntime;
 }
 
 function taskReference(task: DispatchableTask, index: number): string {
@@ -207,12 +216,42 @@ function asAdmissionWriter(task: ResolvedTask): ResolvedTask {
     : task;
 }
 
-function sharedWriteRejection(
+const SCRATCH_VIABILITY_TIMEOUT_MS = 5_000;
+
+/** Verify scratch viability for the given task cwds before a rejection message
+ * recommends it. Resolves with the clause text to append: a recommendation
+ * when every cwd passes the same read-only pre-flight scratch setup runs,
+ * otherwise a short unavailability note carrying the blocking reason.
+ * Uncertainty (timeout, unexpected error) fails closed — no recommendation. */
+async function scratchRecommendation(cwds: readonly string[]): Promise<string> {
+  if (!cwds.length) return "";
+  try {
+    await Promise.all(
+      cwds.map((cwd) =>
+        checkScratchWorkspaceSupport(
+          cwd,
+          AbortSignal.timeout(SCRATCH_VIABILITY_TIMEOUT_MS),
+        ),
+      ),
+    );
+    return ', or use workspace: "scratch" when changes may be discarded';
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    return ` workspace: "scratch" is unavailable in this checkout (${reason})`;
+  }
+}
+
+/** Compose the shared-write rejection after the admission lock has released:
+ * the scratch clause is verified against scratch's own pre-flight, so the
+ * message never vouches for a mode this checkout cannot run (linked Git
+ * worktrees, nested repositories, non-Linux hosts). */
+async function sharedWriteRejection(
   tasks: DispatchableTask[],
   parentModelId: string | undefined,
   conflicts: SharedWriteConflict[],
-  references: readonly string[] = tasks.map(taskReference),
-): DelegateToolResult {
+  references: readonly string[],
+  cwds: readonly string[],
+): Promise<DelegateToolResult> {
   const scopes = conflicts
     .map(({ scope, taskIndexes }) => {
       const refs = taskIndexes
@@ -221,6 +260,7 @@ function sharedWriteRejection(
       return `${refs} share ${scope.kind === "git" ? "Git root" : "directory"} '${scope.root}'.`;
     })
     .join(" ");
+  const scratch = await scratchRecommendation(cwds);
   return {
     content: [
       {
@@ -228,7 +268,7 @@ function sharedWriteRejection(
         text:
           `Rejected before dispatch; no tasks were started. ${scopes} ` +
           "Each listed task has mutating or unclassified tool capability, so concurrent shared execution could silently overwrite work. " +
-          'Run them sequentially, use workspace: "isolated" for Git-backed ordered reconciliation, or use workspace: "scratch" when changes may be discarded. ' +
+          `Run them sequentially, use workspace: "isolated" for Git-backed ordered reconciliation${scratch}. ` +
           "External processes remain outside this check.",
       },
     ],
@@ -236,26 +276,69 @@ function sharedWriteRejection(
   };
 }
 
-function sharedWriteSafetyFailure(
+async function sharedWriteSafetyFailure(
   tasks: DispatchableTask[],
   parentModelId: string | undefined,
   error: unknown,
-): DelegateToolResult {
+  cwds: readonly string[],
+): Promise<DelegateToolResult> {
   const detail =
     error instanceof Error ? error.message : "Unknown workspace error.";
+  const scratch = await scratchRecommendation(cwds);
   return {
     content: [
       {
         type: "text",
         text:
           `Rejected before dispatch; no tasks were started because shared-write safety could not be verified. ${detail} ` +
-          'Fix the task directory or Git metadata, run tasks sequentially, use workspace: "isolated" for Git-backed ordered reconciliation, or use workspace: "scratch" when changes may be discarded.',
+          `Fix the task directory or Git metadata, run tasks sequentially, use workspace: "isolated" for Git-backed ordered reconciliation${scratch}.`,
       },
     ],
     details: { tasks, results: [], progress: [], parentModel: parentModelId },
   };
 }
 
+/** Build the predecessor gate that runs serialized task chains one at a time,
+ * in task order. Each chained successor awaits its predecessor's completion
+ * before acquiring a global slot; `complete` must be called in every task's
+ * `finally` so throw, abort, and queued-abort paths all unblock successors. */
+function buildSerializationGate(
+  groups: readonly SharedWriteConflict[] | undefined,
+  progress: TaskProgress[],
+):
+  | {
+      beforeAcquire: (index: number) => Promise<void>;
+      complete: (index: number) => void;
+    }
+  | undefined {
+  if (!groups?.length) return undefined;
+  const predecessor = new Map<number, number>();
+  for (const { taskIndexes } of groups) {
+    for (let position = 1; position < taskIndexes.length; position++) {
+      predecessor.set(taskIndexes[position]!, taskIndexes[position - 1]!);
+      const row = progress[taskIndexes[position]!];
+      if (row) row.waitingFor = taskIndexes[position - 1]!;
+    }
+  }
+  if (predecessor.size === 0) return undefined;
+  const settled = new Map<number, Promise<void>>();
+  const resolvers = new Map<number, () => void>();
+  for (const index of new Set(predecessor.values())) {
+    let resolve!: () => void;
+    settled.set(index, new Promise<void>((r) => (resolve = r)));
+    resolvers.set(index, resolve);
+  }
+  return {
+    beforeAcquire: async (index) => {
+      const predecessorIndex = predecessor.get(index);
+      if (predecessorIndex !== undefined) await settled.get(predecessorIndex);
+      const row = progress[index];
+      if (row) row.waitingFor = undefined;
+    },
+    complete: (index) => resolvers.get(index)?.(),
+  };
+}
+
 /** Validate, resolve, and dispatch a non-short-circuit delegate operation. */
 export async function dispatchDelegate(
   input: DelegateDispatchInput,
@@ -276,10 +359,11 @@ export async function dispatchDelegate(
     signal,
     onUpdate,
     callSpan,
+    runtime = getDefaultDelegateRuntime(),
   } = input;
   const tasks = params.tasks ?? [];
 
-  const validationError = validateTasks(tasks, agents, parentModelId);
+  const validationError = validateTasks(tasks, agents, parentModelId, runtime);
   if (validationError) {
     callSpan?.finish({
       status: "failed",
@@ -296,6 +380,7 @@ export async function dispatchDelegate(
     agents,
     parentDefaults,
     dispatchConfig,
+    runtime,
   );
   if (resolveResult.error !== undefined) {
     callSpan?.finish({
@@ -310,36 +395,28 @@ export async function dispatchDelegate(
     };
   }
   const resolved = resolveResult.tasks;
-  if (params.async && resolved.some((task) => task.workspace === "isolated")) {
-    callSpan?.finish({
-      status: "failed",
-      totalTokens: 0,
-      totalCost: 0,
-      wallMs: Date.now() - callSpan.startedAt,
-    });
-    return {
-      content: [
-        {
-          type: "text",
-          text: 'Invalid delegate call: workspace "isolated" is synchronous; remove async.',
-        },
-      ],
-      details: {
-        tasks,
-        results: [],
-        progress: [],
-        parentModel: parentModelId,
-      },
-    };
-  }
 
-  const dispatchWarning = dispatchConfig.allowUnsafeSharedWrites
+  // Mutated inside the admission lock: unsafe mode's standing warning, and the
+  // serialization notice built when same-call shared writers are ordered into
+  // task order instead of rejected. Mutually exclusive by construction —
+  // unsafe mode skips admission entirely.
+  let dispatchWarning = dispatchConfig.allowUnsafeSharedWrites
     ? UNSAFE_SHARED_WRITES_WARNING
     : undefined;
+  let serializedNotice: string | undefined;
+  let serializedGroups: SharedWriteConflict[] | undefined;
   const signalWasAbortedBeforeAdmission = signal?.aborted === true;
   let syncReservation: symbol | undefined;
   let admissionResult:
-    DelegateToolResult | { progress: TaskProgress[]; fire: () => void };
+    | DelegateToolResult
+    | { progress: TaskProgress[]; fire: () => void }
+    | {
+        rejected: {
+          conflicts: SharedWriteConflict[];
+          references: string[];
+          cwds: string[];
+        };
+      };
 
   try {
     admissionResult = await withSharedWriteAdmissionLock(async () => {
@@ -360,7 +437,7 @@ export async function dispatchDelegate(
           taskReference(tasks[index]!, index),
         );
 
-        for (const ticket of ticketRegistry.values()) {
+        for (const ticket of runtime.tickets.values()) {
           if (
             ticket.status !== "running" &&
             ticket.status !== "cancelling" &&
@@ -391,29 +468,66 @@ export async function dispatchDelegate(
         }
 
         const incomingCount = resolved.length;
-        const conflicts = (
-          await findSharedWriteConflicts(
-            [...incomingForSafety, ...activeResolved],
-            signal,
-          )
-        ).filter(({ taskIndexes }) => {
-          if (!taskIndexes.some((index) => index < incomingCount)) return false;
-          // Multiple isolated tasks in this call intentionally share one
-          // baseline/root. Any shared task or active dispatch in the same
-          // conflict group still rejects the call.
-          return !taskIndexes.every(
-            (index) =>
-              index < incomingCount &&
-              resolved[index]?.workspace === "isolated",
-          );
-        });
-        if (conflicts.length) {
-          return sharedWriteRejection(
-            tasks,
-            parentModelId,
-            conflicts,
-            references,
-          );
+        const rejectConflicts: SharedWriteConflict[] = [];
+        const serializedConflicts: SharedWriteConflict[] = [];
+        const rejectedCwds = new Set<string>();
+        for (const conflict of await findSharedWriteConflicts(
+          [...incomingForSafety, ...activeResolved],
+          signal,
+        )) {
+          const { taskIndexes } = conflict;
+          if (!taskIndexes.some((index) => index < incomingCount)) continue;
+          if (taskIndexes.every((index) => index < incomingCount)) {
+            const workspaces = new Set(
+              taskIndexes.map((index) => resolved[index]?.workspace),
+            );
+            if (workspaces.has("isolated")) {
+              if (workspaces.size === 1) {
+                // Multiple isolated tasks in this call intentionally share
+                // one baseline/root; no shared writer is involved.
+                continue;
+              }
+              // Mixed isolated/shared in this call: a shared writer cannot be
+              // ordered against the isolated reservation window (baseline
+              // snapshot through reconciliation).
+              rejectConflicts.push(conflict);
+            } else {
+              // Same-call shared writers: serialize in task order instead of
+              // rejecting. Concurrent dispatch is unordered anyway, so
+              // serial-in-dispatch-order refines the same contract.
+              serializedConflicts.push(conflict);
+            }
+          } else {
+            // An active writer (async ticket, running sync dispatch, or
+            // quarantined task) is involved: queueing behind unknown-duration
+            // work cannot be ordered safely here.
+            rejectConflicts.push(conflict);
+          }
+          for (const index of taskIndexes) {
+            if (index < incomingCount) rejectedCwds.add(resolved[index]!.cwd);
+          }
+        }
+        if (rejectConflicts.length) {
+          return {
+            rejected: {
+              conflicts: rejectConflicts,
+              references,
+              cwds: [...rejectedCwds],
+            },
+          };
+        }
+        if (serializedConflicts.length) {
+          serializedGroups = serializedConflicts;
+          serializedNotice = `Serialized: ${serializedConflicts
+            .map(
+              ({ scope, taskIndexes }) =>
+                `${taskIndexes
+                  .map((index) => references[index] ?? `Task ${index + 1}`)
+                  .join(", ")} share ${
+                  scope.kind === "git" ? "Git root" : "directory"
+                } '${scope.root}' — running one at a time in task order.`,
+            )
+            .join(" ")}`;
         }
       }
 
@@ -425,6 +539,7 @@ export async function dispatchDelegate(
         resolved,
         parentModelId,
         dispatchWarning,
+        serializedNotice,
       );
       fire();
 
@@ -439,6 +554,9 @@ export async function dispatchDelegate(
           callSpan,
           dispatchConfig,
           dispatchWarning,
+          serializedGroups,
+          serializedNotice,
+          runtime,
         });
       }
 
@@ -483,18 +601,29 @@ export async function dispatchDelegate(
       totalCost: 0,
       wallMs: Date.now() - callSpan.startedAt,
     });
-    return sharedWriteSafetyFailure(tasks, parentModelId, error);
+    return await sharedWriteSafetyFailure(tasks, parentModelId, error, [
+      ...new Set(resolved.map((task) => task.cwd)),
+    ]);
+  }
+
+  if ("rejected" in admissionResult) {
+    callSpan?.finish({
+      status: "failed",
+      totalTokens: 0,
+      totalCost: 0,
+      wallMs: Date.now() - (callSpan?.startedAt ?? Date.now()),
+    });
+    const { conflicts, references, cwds } = admissionResult.rejected;
+    return await sharedWriteRejection(
+      tasks,
+      parentModelId,
+      conflicts,
+      references,
+      cwds,
+    );
   }
 
   if ("content" in admissionResult) {
-    if (admissionResult.content[0]?.text.includes("Rejected before dispatch")) {
-      callSpan?.finish({
-        status: "failed",
-        totalTokens: 0,
-        totalCost: 0,
-        wallMs: Date.now() - callSpan.startedAt,
-      });
-    }
     return admissionResult;
   }
 
@@ -510,6 +639,9 @@ export async function dispatchDelegate(
       callSpan,
       dispatchConfig,
       dispatchWarning,
+      serializedGroups,
+      serializedNotice,
+      runtime,
     });
   } finally {
     if (syncReservation) activeSyncDispatches.delete(syncReservation);
@@ -519,8 +651,12 @@ export async function dispatchDelegate(
 /** Deliver a settled ticket and, when leaf affinity downgraded delivery to a
  *  non-waking `nextTurn` message, tell the human — otherwise the completion is
  *  silent apart from the footer clearing. */
-function finishTicketDelivery(pi: ExtensionAPI, ticket: AsyncTicket): void {
-  if (deliverTicketResults(pi, ticket) === "deferred") {
+function finishTicketDelivery(
+  pi: ExtensionAPI,
+  ticket: AsyncTicket,
+  runtime: DelegateRuntime,
+): void {
+  if (runtime.tickets.deliverTicketResults(pi, ticket) === "deferred") {
     notifyCrossLeafDelivery(ticket);
   }
 }
@@ -541,6 +677,88 @@ function settleAsyncCall(
   callSpan.finish({ status, totalTokens, totalCost, wallMs });
 }
 
+function taskCompletedSuccessfully(result: TaskResult): boolean {
+  return (
+    !result.error &&
+    result.integration?.status !== "retained" &&
+    result.integration?.status !== "conflict" &&
+    result.integration?.status !== "apply_failed"
+  );
+}
+
+function completeUnexpectedResults(
+  resolved: readonly ResolvedTask[],
+  progress: TaskProgress[],
+  current: readonly (TaskResult | undefined)[],
+  error: unknown,
+): TaskResult[] {
+  const reason = error instanceof Error ? error.message : String(error);
+  return resolved.map((task, index) => {
+    const result = current[index];
+    if (result) return result;
+    const p = progress[index]!;
+    p.status = "failed";
+    p.error = reason;
+    return {
+      id: task.id,
+      agent: task.agentName,
+      resumedFrom: task.resumeFromDisplay,
+      output: "",
+      error: reason,
+      durationMs: p.durationMs,
+      tokens: 0,
+      usage: emptyUsage(),
+      workspace: task.workspace,
+      touchedFiles: [],
+      attributedFiles: [],
+    };
+  });
+}
+
+async function reconcileIsolatedResults(
+  batch: PreparedIsolatedBatch,
+  resolved: readonly ResolvedTask[],
+  results: TaskResult[],
+  options?: IsolatedReconcileOptions,
+): Promise<TaskResult[]> {
+  try {
+    return await batch.reconcile(results, options);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    console.error("[delegate] isolated reconciliation failed", error);
+    for (let index = 0; index < results.length; index++) {
+      if (resolved[index]?.workspace !== "isolated") continue;
+      const existing = results[index]?.integration;
+      results[index] = {
+        ...results[index]!,
+        integration: {
+          status: "apply_failed",
+          proposedFiles: existing?.proposedFiles ?? [],
+          appliedFiles: [],
+          conflicts: [
+            ...(existing?.conflicts ?? []),
+            { path: "(batch)", reason: detail },
+          ],
+          ...(existing?.baselineRef
+            ? { baselineRef: existing.baselineRef }
+            : {}),
+          ...(existing?.proposalRef
+            ? { proposalRef: existing.proposalRef }
+            : {}),
+          ...(existing?.patchPath ? { patchPath: existing.patchPath } : {}),
+          ...(existing?.worktreePath
+            ? { worktreePath: existing.worktreePath }
+            : {}),
+          ...(existing?.cleanupIssue
+            ? { cleanupIssue: existing.cleanupIssue }
+            : {}),
+        },
+      };
+    }
+    return results;
+  }
+}
+
 /** Fire-and-forget background execution. Registers an `AsyncTicket`, kicks off
  *  the concurrent run, and returns the ticket acknowledgment immediately.
  *  Results are delivered via `deliverTicketResults` when all tasks settle. */
@@ -555,10 +773,13 @@ export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
     callSpan,
     dispatchConfig,
     dispatchWarning,
+    serializedGroups,
+    serializedNotice,
+    runtime = getDefaultDelegateRuntime(),
   } = input;
 
-  sweepTickets();
-  const runningCount = [...ticketRegistry.values()].filter(
+  runtime.tickets.sweepTickets();
+  const runningCount = [...runtime.tickets.values()].filter(
     (t) => t.status === "running" || t.status === "cancelling",
   ).length;
   const maxAsyncTickets = getMaxAsyncTickets(dispatchConfig);
@@ -580,7 +801,7 @@ export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
     };
   }
 
-  const ticketId = generateTicketId();
+  const ticketId = runtime.tickets.generateTicketId();
   const controller = new AbortController();
   const ticket: AsyncTicket = {
     id: ticketId,
@@ -602,17 +823,33 @@ export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
     telemetryConfig: callSpan?.telemetryConfig,
     workersSettled: false,
     dispatchWarning,
+    serializedNotice,
     // Capture the dispatch-scoped snapshot so async workers and later poll/wait
     // formatting use the same retry/stall/output/provider settings that were
     // in effect when the ticket was spawned.
     config: dispatchConfig,
   };
-  ticketRegistry.set(ticketId, ticket);
+  runtime.tickets.set(ticketId, ticket);
+  let lastPauseState = "running";
+  const pause = new PauseController(() => {
+    if (pause.state !== lastPauseState) {
+      lastPauseState = pause.state;
+      if (ticket.status === "running")
+        console.info(`[delegate] ticket '${ticketId}' ${lastPauseState}`);
+    }
+    for (const p of ticket.progress) p.paused = pause.isParked(p.index);
+    runtime.tickets.notifyWaiters(ticket);
+    syncDelegateStatus(undefined, runtime);
+  });
+  ticket.pause = pause;
+  // Preparation/source integration are operations too: a pause request must
+  // not claim quiet while either is mutating a workspace.
+  pause.enter(-1);
   callSpan?.spawn();
   // Footer visibility for the new background work (see status.ts). Uses the
   // ctx cached from the dispatch path in extension.ts — DelegateToolCtx is
   // the intentionally narrowed surface and does not carry `ui`.
-  syncDelegateStatus();
+  syncDelegateStatus(undefined, runtime);
 
   // Capture values for the closure — do NOT use `signal` from execute()
   // The parent turn's signal dies when execute() returns.
@@ -620,6 +857,7 @@ export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
   const modelRegistry = ctx.modelRegistry;
 
   const asyncEnv: TaskRunEnv = {
+    pause,
     signal: ticketSignal,
     modelRegistry,
     ticketId,
@@ -630,16 +868,17 @@ export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
       callSpan?.telemetryConfig ?? getTelemetryConfig(dispatchConfig),
     async: true,
     config: dispatchConfig,
+    runtime,
     onProgress: (p, u) => {
       updateProgressFromRun(p, u);
-      notifyWaiters(ticket);
+      runtime.tickets.notifyWaiters(ticket);
       // Live subagent counts in the footer. Deduped by text, so only
       // running/pending count transitions trigger a render.
-      syncDelegateStatus();
+      syncDelegateStatus(undefined, runtime);
     },
     onStatusChange: () => {
-      notifyWaiters(ticket);
-      syncDelegateStatus();
+      runtime.tickets.notifyWaiters(ticket);
+      syncDelegateStatus(undefined, runtime);
     },
   };
 
@@ -652,27 +891,118 @@ export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
   // In particular, result delivery is allowed to fail without re-entering the
   // worker completion path; the terminal ticket remains available to poll.
   const finishLiveSettlement = (t: AsyncTicket): void => {
-    syncDelegateStatus();
+    syncDelegateStatus(undefined, runtime);
     settleAsyncCall(t, callSpan);
-    finishTicketDelivery(pi, t);
+    finishTicketDelivery(pi, t, runtime);
   };
 
-  const completion = mapConcurrentByModel(
-    resolved,
-    (t) => getModelKey(t.model),
-    (modelKey) => getConcurrencyLimit(modelKey, dispatchConfig),
-    async (t, i) => {
-      const result = await runResolvedTask(asyncEnv, t, ticket.progress[i]!, i);
-      ticket.results[i] = result;
-      return result;
-    },
-    ticketSignal,
-  )
-    .then(() => {
-      // mapConcurrentByModel is the worker-settled barrier. Publish that before
-      // terminal formatting/delivery so the final spill projection is safely
-      // memoized; shutdown may already have formatted an intentionally uncached
-      // partial snapshot while this flag was false.
+  const completion = (async () => {
+    try {
+      let executionResolved = resolved;
+      let isolatedBatch: PreparedIsolatedBatch | undefined;
+      try {
+        await pause.checkpoint(-1, ticketSignal);
+        isolatedBatch = await prepareIsolatedBatch(resolved, ticketSignal);
+        if (isolatedBatch) executionResolved = isolatedBatch.resolved;
+      } catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(
+          `Isolated workspace setup failed; no subagents were started. ${detail}`,
+          { cause: error },
+        );
+      } finally {
+        pause.leave(-1);
+      }
+
+      let results: TaskResult[];
+      const gate = buildSerializationGate(serializedGroups, ticket.progress);
+      try {
+        results = await mapConcurrentByModel(
+          executionResolved,
+          (t) => getModelKey(t.model),
+          (modelKey) => getConcurrencyLimit(modelKey, dispatchConfig),
+          async (t, i) => {
+            pause.enter(i);
+            try {
+              await pause.checkpoint(i, ticketSignal);
+              const result = await runResolvedTask(
+                asyncEnv,
+                t,
+                ticket.progress[i]!,
+                i,
+              );
+              const group = serializedGroups?.findIndex((group) =>
+                group.taskIndexes.includes(i),
+              );
+              if (group !== undefined && group >= 0)
+                result.serializedGroup = group;
+              ticket.results[i] = result;
+              return result;
+            } finally {
+              pause.leave(i);
+              gate?.complete(i);
+            }
+          },
+          ticketSignal,
+          async (i) => {
+            await gate?.beforeAcquire(i);
+            await pause.checkpoint(i, ticketSignal);
+          },
+        );
+      } catch (error) {
+        results = completeUnexpectedResults(
+          resolved,
+          ticket.progress,
+          ticket.results,
+          error,
+        );
+        if (isolatedBatch) {
+          pause.enter(-1);
+          try {
+            await pause.checkpoint(-1, ticketSignal);
+            results = await reconcileIsolatedResults(
+              isolatedBatch,
+              resolved,
+              results,
+              {
+                shouldApplySource: () => false,
+                retainedReason:
+                  "Batch execution failed before source application; completed proposals were retained for recovery.",
+              },
+            );
+          } finally {
+            pause.leave(-1);
+          }
+        }
+        ticket.results = [...results];
+        throw error;
+      }
+      if (isolatedBatch) {
+        pause.enter(-1);
+        try {
+          await pause.checkpoint(-1, ticketSignal);
+          results = await reconcileIsolatedResults(
+            isolatedBatch,
+            resolved,
+            results,
+            {
+              shouldApplySource: () =>
+                ticket.status === "running" && !ticketSignal.aborted,
+              signal: ticketSignal,
+              retainedReason:
+                "The async ticket was cancelled before source application; the proposal was retained for recovery.",
+            },
+          );
+        } finally {
+          pause.leave(-1);
+        }
+        ticket.results = [...results];
+      }
+
+      // Worker execution and isolated reconciliation are complete. Publish that
+      // before terminal formatting/delivery so the final spill projection is
+      // safely memoized; shutdown may already have formatted an intentionally
+      // uncached partial snapshot while this flag was false.
       ticket.workersSettled = true;
       // Shutdown marks the ticket terminal before cooperative worker aborts
       // have finished. Still write one final aggregate after every result has
@@ -682,43 +1012,36 @@ export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
         settleAsyncCall(ticket, callSpan);
         return;
       }
-      // All tasks settled — determine final ticket status.
-      // Use progress (set by runResolvedTask) for settled-ness so the
-      // status reflects work completion, not just result-array density.
-      // A partial ticket (not all settled, e.g. aborted mid-flight) must
-      // NOT be marked "done" — that would mask incomplete work as
-      // complete. resolveFinalTicketStatus returns "failed" for that
-      // case and for any case with a failed task.
-      // A "cancelling" ticket that outlived its workers settles as
-      // "cancelled": the per-task results record what actually happened;
-      // the ticket state reports that the batch was aborted by the caller.
-      settleTicket(ticket, {
+      // Use progress (set by runResolvedTask) for settled-ness so a partial
+      // ticket can never be marked done. A cancelling ticket reports cancelled
+      // even when some workers completed before the abort.
+      runtime.tickets.settleTicket(ticket, {
         status:
           ticket.status === "running"
-            ? resolveFinalTicketStatus(ticket)
+            ? runtime.tickets.resolveFinalTicketStatus(ticket)
             : "cancelled",
       });
       finishLiveSettlement(ticket);
-    })
-    .catch((err) => {
-      // mapConcurrentByModel waits for all sibling workers before rejecting.
+    } catch (err) {
+      // Preparation and reconciliation join the same terminal path as workers:
+      // any unexpected rejection must leave the ticket pollable and settled.
       ticket.workersSettled = true;
-      // Defense-in-depth — should not happen if individual tasks catch properly.
-      // Even an unexpected worker rejection must leave the shutdown aggregate
-      // with every result that did settle, without touching the stale UI.
       if (ticket.status === "cancelled") {
         settleAsyncCall(ticket, callSpan);
         return;
       }
-      settleTicket(ticket, {
-        status: ticket.status === "cancelling" ? "cancelled" : "failed",
-        error: err instanceof Error ? err.message : String(err),
+      const cancelling = ticket.status === "cancelling";
+      runtime.tickets.settleTicket(ticket, {
+        status: cancelling ? "cancelled" : "failed",
+        ...(cancelling
+          ? {}
+          : { error: err instanceof Error ? err.message : String(err) }),
       });
       finishLiveSettlement(ticket);
-    })
-    .finally(() => {
+    } finally {
       ticket.workersSettled = true;
-    });
+    }
+  })();
   ticket.completion = completion;
 
   return {
@@ -728,6 +1051,7 @@ export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
         text: [
           `Async ticket: ${ticketId}`,
           `${resolved.length} task(s) dispatched · ${runningCount + 1}/${maxAsyncTickets} async slots in use`,
+          ...(serializedNotice ? [serializedNotice] : []),
           ...(dispatchWarning ? [`WARNING: ${dispatchWarning}`] : []),
           "",
           "Work is detached. Stop this turn to let final results auto-deliver.",
@@ -745,6 +1069,7 @@ export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
       status: ticket.status,
       elapsedMs: Date.now() - ticket.created,
       dispatchWarning,
+      serializedNotice,
     },
   };
 }
@@ -765,6 +1090,9 @@ export async function dispatchSync(
     callSpan,
     dispatchConfig,
     dispatchWarning,
+    serializedGroups,
+    serializedNotice,
+    runtime = getDefaultDelegateRuntime(),
   } = input;
 
   const startedAt = Date.now();
@@ -807,6 +1135,7 @@ export async function dispatchSync(
       callSpan?.telemetryConfig ?? getTelemetryConfig(dispatchConfig),
     async: false,
     config: dispatchConfig,
+    runtime,
     onProgress: (p, u) => {
       updateProgressFromRun(p, u);
       fire();
@@ -814,32 +1143,55 @@ export async function dispatchSync(
     onStatusChange: () => fire(),
   };
 
-  let results = await mapConcurrentByModel(
-    executionResolved,
-    (t) => getModelKey(t.model),
-    (modelKey) => getConcurrencyLimit(modelKey, dispatchConfig),
-    async (t, i) => runResolvedTask(syncEnv, t, progress[i]!, i),
-    signal,
+  const partialResults: (TaskResult | undefined)[] = new Array(
+    executionResolved.length,
   );
-  if (isolatedBatch) {
-    try {
-      results = await isolatedBatch.reconcile(results);
-    } catch (error) {
-      const detail = error instanceof Error ? error.message : String(error);
-      console.error("[delegate] isolated reconciliation failed", error);
-      for (let index = 0; index < results.length; index++) {
-        if (resolved[index]?.workspace !== "isolated") continue;
-        results[index] = {
-          ...results[index]!,
-          integration: {
-            status: "apply_failed",
-            proposedFiles: [],
-            appliedFiles: [],
-            conflicts: [{ path: "(batch)", reason: detail }],
-          },
-        };
-      }
-    }
+  let results: TaskResult[];
+  let isolatedReconciled = false;
+  const gate = buildSerializationGate(serializedGroups, progress);
+  try {
+    results = await mapConcurrentByModel(
+      executionResolved,
+      (t) => getModelKey(t.model),
+      (modelKey) => getConcurrencyLimit(modelKey, dispatchConfig),
+      async (t, i) => {
+        try {
+          const result = await runResolvedTask(syncEnv, t, progress[i]!, i);
+          const group = serializedGroups?.findIndex((group) =>
+            group.taskIndexes.includes(i),
+          );
+          if (group !== undefined && group >= 0) result.serializedGroup = group;
+          partialResults[i] = result;
+          return result;
+        } finally {
+          gate?.complete(i);
+        }
+      },
+      signal,
+      gate?.beforeAcquire,
+    );
+  } catch (error) {
+    if (!isolatedBatch) throw error;
+    results = completeUnexpectedResults(
+      resolved,
+      progress,
+      partialResults,
+      error,
+    );
+    results = await reconcileIsolatedResults(isolatedBatch, resolved, results, {
+      shouldApplySource: () => false,
+      retainedReason:
+        "Batch execution failed before source application; completed proposals were retained for recovery.",
+    });
+    isolatedReconciled = true;
+  }
+  if (isolatedBatch && !isolatedReconciled) {
+    results = await reconcileIsolatedResults(isolatedBatch, resolved, results, {
+      shouldApplySource: () => !signal?.aborted,
+      signal,
+      retainedReason:
+        "The parent cancelled before source application; the proposal was retained for recovery.",
+    });
   }
 
   // ── Format for LLM ────────────────────────────────────────────
@@ -847,10 +1199,11 @@ export async function dispatchSync(
   const elapsedTotal = Date.now() - startedAt;
 
   const parts: string[] = [];
-  const succeeded = finalResults.filter((r) => !r.error).length;
+  const succeeded = finalResults.filter(taskCompletedSuccessfully).length;
   parts.push(
     `${succeeded}/${finalResults.length} tasks completed successfully · ${fmtDuration(elapsedTotal)} wall time\n`,
   );
+  if (serializedNotice) parts.push(serializedNotice);
   if (dispatchWarning) parts.push(`WARNING: ${dispatchWarning}`);
   for (let i = 0; i < finalResults.length; i++) {
     const r = finalResults[i]!;
@@ -863,14 +1216,9 @@ export async function dispatchSync(
   );
   if (overlapWarning) parts.push("", overlapWarning);
 
-  const status = finalResults.some(
-    (r) =>
-      r.error ||
-      r.integration?.status === "conflict" ||
-      r.integration?.status === "apply_failed",
-  )
-    ? "failed"
-    : "success";
+  const status = finalResults.every(taskCompletedSuccessfully)
+    ? "success"
+    : "failed";
   const totalTokens = finalResults.reduce((sum, r) => sum + r.tokens, 0);
   const totalCost = finalResults.reduce(
     (sum, r) => sum + r.usage.cost.total,
@@ -893,6 +1241,7 @@ export async function dispatchSync(
       elapsedMs: elapsedTotal,
       overlapWarning: overlapWarning || undefined,
       dispatchWarning,
+      serializedNotice,
     },
     // Aggregate subagent spend so Pi folds it into the parent's
     // session/footer totals. Sync dispatch only — async results arrive via a