@bermudi/pi-delegate 0.1.19 → 0.1.20

package/dispatch.ts

@@ -1,6 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { AgentToolUpdateCallback } from "@earendil-works/pi-agent-core";
 import { getDefaultDelegateRuntime, type DelegateRuntime } from "./runtime.ts";
+import { PauseController } from "./pause.ts";
 import {
   getConcurrencyLimit,
   getMaxAsyncTickets,
@@ -303,6 +304,7 @@ async function sharedWriteSafetyFailure(
  * `finally` so throw, abort, and queued-abort paths all unblock successors. */
 function buildSerializationGate(
   groups: readonly SharedWriteConflict[] | undefined,
+  progress: TaskProgress[],
 ):
   | {
       beforeAcquire: (index: number) => Promise<void>;
@@ -314,6 +316,8 @@ function buildSerializationGate(
   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;
@@ -328,6 +332,8 @@ function buildSerializationGate(
     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)?.(),
   };
@@ -824,6 +830,21 @@ export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
     config: dispatchConfig,
   };
   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
@@ -836,6 +857,7 @@ export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
   const modelRegistry = ctx.modelRegistry;
 
   const asyncEnv: TaskRunEnv = {
+    pause,
     signal: ticketSignal,
     modelRegistry,
     ticketId,
@@ -879,6 +901,7 @@ export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
       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) {
@@ -887,31 +910,44 @@ export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
           `Isolated workspace setup failed; no subagents were started. ${detail}`,
           { cause: error },
         );
+      } finally {
+        pause.leave(-1);
       }
 
       let results: TaskResult[];
-      const gate = buildSerializationGate(serializedGroups);
+      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,
-          gate?.beforeAcquire,
+          async (i) => {
+            await gate?.beforeAcquire(i);
+            await pause.checkpoint(i, ticketSignal);
+          },
         );
       } catch (error) {
         results = completeUnexpectedResults(
@@ -921,34 +957,46 @@ export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
           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: () => false,
+              shouldApplySource: () =>
+                ticket.status === "running" && !ticketSignal.aborted,
+              signal: ticketSignal,
               retainedReason:
-                "Batch execution failed before source application; completed proposals were retained for recovery.",
+                "The async ticket was cancelled before source application; the proposal was retained for recovery.",
             },
           );
+        } finally {
+          pause.leave(-1);
         }
         ticket.results = [...results];
-        throw error;
-      }
-      if (isolatedBatch) {
-        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.",
-          },
-        );
-        ticket.results = [...results];
       }
 
       // Worker execution and isolated reconciliation are complete. Publish that
@@ -1100,7 +1148,7 @@ export async function dispatchSync(
   );
   let results: TaskResult[];
   let isolatedReconciled = false;
-  const gate = buildSerializationGate(serializedGroups);
+  const gate = buildSerializationGate(serializedGroups, progress);
   try {
     results = await mapConcurrentByModel(
       executionResolved,
@@ -1109,6 +1157,10 @@ export async function dispatchSync(
       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 {

package/extension.ts

@@ -1,4 +1,5 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { registerSubagentBrowser } from "./browser.ts";
 import { getDefaultDelegateRuntime, type DelegateRuntime } from "./runtime.ts";
 import { discoverAgents } from "./agents.ts";
 import { getSubagentManualMarkdown } from "./manual.ts";
@@ -136,6 +137,7 @@ export default function delegateExtension(
   // its SQLite handle. Permit the new runtime to open a fresh backend; stale
   // workers from the old runtime remain blocked from reopening it.
   prepareTelemetryForSession();
+  const browserHistory = registerSubagentBrowser(pi, runtime);
 
   // Async completion arrives as a custom message after the original tool call
   // has returned. Give it the same compact/expanded UI as sync results while
@@ -156,6 +158,8 @@ export default function delegateExtension(
     prepareArguments: normalizeDelegateArguments,
 
     async execute(_id, params: DelegateArguments, signal, onUpdate, ctx) {
+      const browserGeneration = browserHistory.generation;
+      const captureBrowser = ctx.mode === "tui" && !params.async;
       // Reload user-edited delegate.json at the start of every execution.
       // Help, poll, cancel, wait, and invalid calls observe new settings, and
       // the global concurrency cap is reconfigured so hot-reloaded maxConcurrent
@@ -243,6 +247,16 @@ export default function delegateExtension(
       }
 
       // ── Cancel action ─────────────────────────────────────────────────
+      if (params.ticketAction === "pause" || params.ticketAction === "resume") {
+        const result = runtime.tickets.handlePause({
+          ticket: params.ticket,
+          ticketAction: params.ticketAction,
+        });
+        syncDelegateStatus(ctx, runtime);
+        succeedCall();
+        return result;
+      }
+
       if (params.ticketAction === "cancel") {
         const result = runtime.tickets.handleCancel(params);
         // A forced cancel flips the ticket to "cancelling" — keep the
@@ -331,7 +345,7 @@ export default function delegateExtension(
       // visible without restarting Pi.
       invalidateHostDepsCache();
       try {
-        return await dispatchDelegate({
+        const result = await dispatchDelegate({
           pi,
           params,
           ctx,
@@ -342,11 +356,25 @@ export default function delegateExtension(
             tools: pi.getActiveTools(),
           },
           signal,
-          onUpdate,
+          onUpdate: captureBrowser
+            ? (update) => {
+                browserHistory.update(
+                  _id,
+                  update.details,
+                  false,
+                  browserGeneration,
+                );
+                onUpdate?.(update);
+              }
+            : onUpdate,
           callSpan,
           runtime,
         });
+        if (captureBrowser)
+          browserHistory.update(_id, result.details, true, browserGeneration);
+        return result;
       } catch (err) {
+        if (captureBrowser) browserHistory.fail(_id, err, browserGeneration);
         failCall();
         throw err;
       }

package/format.ts

@@ -586,6 +586,7 @@ export function latestActivity(p: TaskProgress): ToolActivity | null {
  *  - "last: read src/bar.ts" after a tool completes and the model is thinking
  *  - "thinking" when no activity has been recorded yet */
 export function formatActivityLabel(p: TaskProgress): string {
+  if (p.paused) return "paused between turns";
   const activity = inFlightActivity(p) ?? latestActivity(p);
   if (!activity) return "thinking";
   const call = sanitizeTerminalLine(
@@ -599,6 +600,7 @@ export function formatActivityLabel(p: TaskProgress): string {
  *  as {@link formatActivityLabel} but adds elapsed time for in-flight tools and
  *  a completion/error icon for finished ones. */
 export function compactActivity(p: TaskProgress): string {
+  if (p.paused) return "paused between turns";
   const activity = inFlightActivity(p) ?? latestActivity(p);
   if (!activity) return "thinking…";
   const call = sanitizeTerminalLine(
@@ -656,18 +658,31 @@ export function findTouchedOverlaps(
   results: readonly {
     attributedFiles?: string[];
     workspace?: WorkspaceMode;
+    serializedGroup?: number;
+    incomplete?: string;
   }[],
 ): string[] {
-  const counts = new Map<string, number>();
+  const owners = new Map<string, (typeof results)[number][]>();
+  const overlaps = new Set<string>();
   for (const r of results) {
-    for (const f of r.attributedFiles ?? []) {
-      counts.set(f, (counts.get(f) ?? 0) + 1);
+    for (const f of new Set(r.attributedFiles ?? [])) {
+      const previous = owners.get(f) ?? [];
+      if (
+        previous.some(
+          (other) =>
+            r.serializedGroup === undefined ||
+            r.serializedGroup !== other.serializedGroup ||
+            r.incomplete !== undefined ||
+            other.incomplete !== undefined,
+        )
+      ) {
+        overlaps.add(f);
+      }
+      previous.push(r);
+      owners.set(f, previous);
     }
   }
-  return [...counts.entries()]
-    .filter(([, count]) => count > 1)
-    .map(([file]) => file)
-    .sort();
+  return [...overlaps].sort();
 }
 
 /**
@@ -680,5 +695,5 @@ export function findTouchedOverlaps(
  */
 export function formatTouchedOverlapWarning(overlaps: string[]): string | null {
   if (!overlaps.length) return null;
-  return `WARNING: These tasks reported touching the same file(s): ${overlaps.join(", ")}. Delegate does not isolate or serialize file access and does not roll back completed writes.`;
+  return `WARNING: Tasks without a verified ordering reported touching the same file(s): ${overlaps.join(", ")}. File reports do not prove simultaneous writes or a conflict; completed writes are not rolled back.`;
 }

package/lifecycle.ts

@@ -361,6 +361,8 @@ export function updateProgressFromRun(
     u.durationMs,
   );
   p.lastActivityAt = u.lastActivityAt;
+  p.assistantPreview = u.assistantPreview;
+  p.activity = u.activity;
   p.activities = mergeToolActivities(p.activities, u.activities);
   p.failureKind = u.failureKind;
 }
@@ -1546,6 +1548,7 @@ async function runTaskAttempt(
       timing.taskStartedAt,
       timing.deadlineAt,
       env.config,
+      env.pause ? { controller: env.pause, index: p.index } : undefined,
     );
 
     accounting.cumulativeTokens += r.tokens;

package/manual.ts

@@ -114,7 +114,7 @@ export function getSubagentManualMarkdown(
     "",
     "The three handles have different lifetimes:",
     "",
-    "- **ticket** — controls one async batch with `poll`, `wait`, or `cancel`.",
+    "- **ticket** — controls one async batch with `poll`, `wait`, `pause`, `resume`, or `cancel`.",
     "- **sessionId** — a caller-chosen key for a live multi-turn worker, retained until close or parent shutdown.",
     "- **resumeFrom** — an absolute `.jsonl` transcript path used to recover an interrupted worker.",
     "",
@@ -139,6 +139,7 @@ export function getSubagentManualMarkdown(
     ...builtinLines,
     "",
     "Start with a built-in and its configured defaults. Set only `agent` and `prompt`; omit `model`, `thinking`, `tools`, and `workspace` unless the user requests an override or a concrete task requirement makes the built-in default unsuitable.",
+    "A scout needs no scratch copy with its read-only defaults. Adding `bash` makes it write-capable regardless of its name; an explicit scratch copy can then be appropriate for disposable shell-based investigation.",
     "",
     "Prefer `default` for general work: it is the only built-in guaranteed to run the parent's exact model and thinking. `scout`/`coder`/`reviewer` apply any configured delegate.json tiers (`agentOverrides`, `agentOverridesByParentModel`) and may run a different model or thinking level than the parent. `scout` is read-only; `coder` and `reviewer` use the shared workspace unless overridden. Choose a specialist for its role, not its name.",
     "",
@@ -168,6 +169,12 @@ export function getSubagentManualMarkdown(
     "",
     schemaTable(delegateArgumentsSchema.properties),
     "",
+    "## Pause and Resume",
+    "",
+    'Use `delegate({ ticketAction: "pause", ticket: "<id>" })` to pause an async batch, and `ticketAction: "resume"` to continue its same live sessions. These controls return a snapshot immediately.',
+    "Pause finishes each current model response and its tool calls, then blocks before the next model request. Not-yet-started tasks stay queued. `pausing` means an operation is still finishing; `paused` means all remaining work has reached a checkpoint. A task that finishes naturally need not pause.",
+    "The inactivity watchdog is suspended at a paused turn boundary, but explicit wall-clock `deadlineMs` budgets continue. Wait does not resume. Cancel and shutdown still abort paused work. Live sessions, concurrency slots, workspace reservations, and scratch/isolated workspaces remain held; pause does not survive Pi exit or reload. Isolated preparation/application already in progress finishes before pausing; background processes are not frozen and files may be unfinished.",
+    "",
     "## Session Reuse",
     "",
     "When `sessionId` is set, the subagent is kept alive in a pool for the duration of the pi session.",
@@ -229,6 +236,8 @@ export function getSubagentManualMarkdown(
     "",
     '- `delegate({ ticketAction: "poll" })` \u2014 list all tickets',
     '- `delegate({ ticketAction: "poll", ticket: "abc123" })` \u2014 take one progress snapshot',
+    '- `delegate({ ticketAction: "pause", ticket: "abc123" })` \u2014 pause between turns, not after the entire task',
+    '- `delegate({ ticketAction: "resume", ticket: "abc123" })` \u2014 continue the same live sessions',
     '- `delegate({ ticketAction: "wait", ticket: "abc123" })` \u2014 block until finished; omit `timeoutMs` when the result is needed this turn',
     '- `delegate({ ticketAction: "wait", ticket: "abc123", timeoutMs: 600000 })` \u2014 bounded wait; timeout includes the latest snapshot, so do not poll afterward',
     '- `delegate({ ticketAction: "cancel", ticket: "abc123" })` \u2014 preview activity and partial effects before cancelling',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bermudi/pi-delegate",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "description": "Delegate tool for the Pi coding agent.",
   "keywords": [
     "pi-package"

package/pause.ts

@@ -0,0 +1,81 @@
+/** Cooperative, in-memory ticket pause. Active operations finish; participants
+ * park at a checkpoint before starting their next operation. This neither
+ * freezes child processes nor releases workspace reservations/concurrency. */
+export type PauseState = "running" | "pausing" | "paused";
+
+export class PauseController {
+  private requested = false;
+  private readonly active = new Set<number>();
+  private readonly parked = new Set<number>();
+  private readonly wake = new Set<() => void>();
+
+  constructor(private readonly onChange: () => void = () => {}) {}
+
+  get state(): PauseState {
+    if (!this.requested) return "running";
+    return [...this.active].every((index) => this.parked.has(index))
+      ? "paused"
+      : "pausing";
+  }
+
+  isParked(index: number): boolean {
+    return this.requested && this.parked.has(index);
+  }
+
+  private publish(): void {
+    try {
+      this.onChange();
+    } catch (error) {
+      console.error("[delegate] pause state notification failed", error);
+    }
+  }
+
+  pause(): void {
+    if (this.requested) return;
+    this.requested = true;
+    this.publish();
+  }
+
+  resume(): void {
+    if (!this.requested) return;
+    this.requested = false;
+    for (const wake of this.wake) wake();
+    this.publish();
+  }
+
+  enter(index: number): void {
+    this.active.add(index);
+    this.publish();
+  }
+
+  leave(index: number): void {
+    this.active.delete(index);
+    this.parked.delete(index);
+    this.publish();
+  }
+
+  /** Abort unblocks the checkpoint without clearing another task's pause.
+   * Callers still observe their signal and take their normal cancellation path. */
+  async checkpoint(index: number, signal?: AbortSignal): Promise<void> {
+    if (!this.requested || signal?.aborted) return;
+    this.parked.add(index);
+    this.publish();
+    try {
+      while (this.requested && !signal?.aborted) {
+        await new Promise<void>((resolve) => {
+          const wake = () => {
+            this.wake.delete(wake);
+            signal?.removeEventListener("abort", wake);
+            resolve();
+          };
+          this.wake.add(wake);
+          signal?.addEventListener("abort", wake, { once: true });
+          if (signal?.aborted) wake();
+        });
+      }
+    } finally {
+      this.parked.delete(index);
+      this.publish();
+    }
+  }
+}

package/render-branches.ts

@@ -54,6 +54,7 @@ export interface RenderState {
 
 /** Shared inputs for the partial and final render branches. */
 export interface BranchCtx {
+  pauseState?: import("./pause.ts").PauseState;
   progress: TaskProgress[];
   taskResults: (TaskResult | { error: string })[];
   total: number;
@@ -98,7 +99,11 @@ export function renderPartialBranch(ctx: BranchCtx, h: RenderHelpers): void {
   // Keep the live and final summaries in the same order so the header remains
   // easy to scan as a partial result resolves into its final form.
   const headerParts: string[] = [];
-  if (running > 0) headerParts.push(`${running} running`);
+  const paused = progress.filter(
+    (p) => p.status === "running" && p.paused,
+  ).length;
+  if (running > paused) headerParts.push(`${running - paused} running`);
+  if (paused > 0) headerParts.push(`${paused} paused`);
   headerParts.push(`${finished}/${total} finished`);
   if (failed > 0) headerParts.push(`${failed} failed`);
   headerParts.push(
@@ -111,7 +116,9 @@ export function renderPartialBranch(ctx: BranchCtx, h: RenderHelpers): void {
   const stateLabel =
     ctx.ticketStatus === "cancelling"
       ? `${theme.fg("error", "■ cancelling")} · `
-      : "";
+      : ctx.pauseState && ctx.pauseState !== "running"
+        ? `${theme.fg("warning", `Ⅱ ${ctx.pauseState}`)} · `
+        : "";
   const expandHint = toolExpandHint();
   const detailHint =
     !expanded && running > 0 && expandHint
@@ -362,7 +369,11 @@ export function renderFinalBranch(ctx: BranchCtx, h: RenderHelpers): void {
   if (ticketId && ticketIsLive) {
     // Background ticket — frame it as in-progress, not a finished result.
     const ticketParts = [`${finalized}/${total} finished`];
-    if (running > 0) ticketParts.push(`${running} active`);
+    const paused = progress.filter(
+      (p) => p.status === "running" && p.paused,
+    ).length;
+    if (running > paused) ticketParts.push(`${running - paused} active`);
+    if (paused > 0) ticketParts.push(`${paused} paused`);
     if (pending > 0) ticketParts.push(`${pending} queued`);
     if (failed > 0) ticketParts.push(`${failed} failed`);
     if (cancelled > 0) ticketParts.push(`${cancelled} cancelled`);
@@ -373,7 +384,9 @@ export function renderFinalBranch(ctx: BranchCtx, h: RenderHelpers): void {
     const stateLabel =
       ticketStatus === "cancelling"
         ? ` ${theme.fg("error", "cancelling")}`
-        : "";
+        : ctx.pauseState && ctx.pauseState !== "running"
+          ? ` ${theme.fg("warning", ctx.pauseState)}`
+          : "";
     lines.push(
       `${glyph}${stateLabel} ${theme.fg("muted", `${ticketLabel}${ticketParts.join(" · ")}`)}${detailHint}`,
       "",

package/render-result.ts

@@ -202,6 +202,7 @@ export function renderDelegateResult(
     lines,
     ticketId,
     ticketStatus,
+    pauseState: details.pauseState,
     elapsedMs: details.elapsedMs,
   };
 

package/runner.ts

@@ -3,6 +3,7 @@ import type {
   AgentSession,
   AgentSessionEvent,
 } from "@earendil-works/pi-coding-agent";
+import { AssistantPreview } from "./assistant-preview.ts";
 import {
   getGitChangedFiles,
   extractAttributedFromActivities,
@@ -127,6 +128,10 @@ export async function runAgentSession(
   deadlineAt?: number,
   /** Dispatch-scoped delegate.json snapshot for the stall timeout. */
   delegateConfig?: import("./config.ts").DelegateConfig,
+  pause?: {
+    controller: import("./pause.ts").PauseController;
+    index: number;
+  },
 ): Promise<{
   output: string;
   error?: string;
@@ -176,6 +181,8 @@ export async function runAgentSession(
   let recoveryBarrier: QuiescenceBarrier | undefined;
   let abandonmentSafety: Promise<void> | undefined;
   let unsubscribeFull: (() => void) | undefined;
+  let unsubscribePause: (() => void) | undefined;
+  let pausedAtTurnBoundary = false;
   let unsubscribeRecovery: (() => void) | undefined;
   const safeLog = (message: string, error?: unknown): void => {
     try {
@@ -187,11 +194,18 @@ export async function runAgentSession(
   const removeFullListener = (): void => {
     const remove = unsubscribeFull;
     unsubscribeFull = undefined;
+    const removePause = unsubscribePause;
+    unsubscribePause = undefined;
     try {
       remove?.();
     } catch (error) {
       safeLog("[delegate] full AgentSession listener cleanup failed", error);
     }
+    try {
+      removePause?.();
+    } catch (error) {
+      safeLog("[delegate] turn-pause listener cleanup failed", error);
+    }
   };
   const removeRecoveryListener = (): void => {
     const remove = unsubscribeRecovery;
@@ -206,6 +220,7 @@ export async function runAgentSession(
     }
   };
   const activities: ToolActivity[] = [];
+  const assistantPreview = new AssistantPreview();
   const pendingById = new Map<string, ToolActivity>();
   let notifyCancellationRequested!: () => void;
   const cancellationRequested = new Promise<void>((resolve) => {
@@ -377,6 +392,8 @@ export async function runAgentSession(
     try {
       const cancellationSource = currentCancellationSource();
       onProgress({
+        assistantPreview: assistantPreview.text,
+        activity: phase,
         tokens: delta,
         toolUses,
         durationMs: Date.now() - startTime,
@@ -415,7 +432,13 @@ export async function runAgentSession(
   };
   const armStallWatchdog = (graceMs = 0) => {
     clearStallWatchdog();
-    if (!stallTimeoutMs || stalled || signal?.aborted || deadlineExceeded)
+    if (
+      !stallTimeoutMs ||
+      stalled ||
+      signal?.aborted ||
+      deadlineExceeded ||
+      pausedAtTurnBoundary
+    )
       return;
 
     const grace = Number.isFinite(graceMs) && graceMs > 0 ? graceMs : 0;
@@ -625,6 +648,35 @@ export async function runAgentSession(
   // result, isError) — AgentSession forwards the underlying agent events
   // verbatim. Retry and compaction events are handled below; queue/bookkeeping
   // events and thinking changes are intentionally ignored.
+  // AgentSession subscribers are notifications, not an awaited barrier.
+  // Pi core explicitly awaits Agent subscribers before proceeding from
+  // turn_start to the next model request, including retries/continuations.
+  // Never gate turn_end: a final turn should be allowed to finish the task.
+  if (pause) {
+    unsubscribePause = session.agent.subscribe(async (event, turnSignal) => {
+      if (event.type !== "turn_start" || pause.controller.state === "running")
+        return;
+      pausedAtTurnBoundary = true;
+      clearStallWatchdog();
+      try {
+        await pause.controller.checkpoint(
+          pause.index,
+          turnSignal && signal
+            ? AbortSignal.any([turnSignal, signal])
+            : (turnSignal ?? signal),
+        );
+        if (turnSignal?.aborted || signal?.aborted) {
+          throw new Error(
+            "Paused turn cancelled before the next model request",
+          );
+        }
+      } finally {
+        pausedAtTurnBoundary = false;
+        noteActivity("resuming at turn boundary");
+      }
+    });
+  }
+
   unsubscribeFull = session.subscribe((event: AgentSessionEvent) => {
     barrier.noteEvent();
     recoveryBarrier?.noteEvent();
@@ -678,12 +730,14 @@ export async function runAgentSession(
       case "message_start":
       case "message_update":
         if (event.message?.role === "assistant") {
+          assistantPreview.update(extractOutput([event.message]));
           rememberPartialAssistant(event.message);
         }
         noteActivity("streaming model output");
         break;
       case "message_end":
         if (event.message.role === "assistant") {
+          assistantPreview.finish(extractOutput([event.message]));
           assistantMessagesForAttempt.push(event.message);
           // Keep a text-bearing partial if the host follows a provider
           // exception with an empty synthetic failure message. A real