@llblab/pi-actors 0.54.0 → 0.56.0

package/lib/run-ui-runtime.ts

@@ -1,9 +1,11 @@
 /**
  * Ambient run observability runtime.
  * Zones: run watcher lifecycle, terminal reconciliation, status animation, shutdown teardown
- * Owns event-driven run UI coordination without owning actor execution semantics.
+ * Owns event-driven run UI/delivery coordination and callback-generation fences; excludes actor execution semantics and public stream activation.
  */
 
+import { Container, Markdown, Spacer, Text, stripTerminalSequences } from "@earendil-works/pi-tui";
+
 import * as AsyncRuns from "./async-runs.ts";
 import * as Limits from "./limits.ts";
 import * as Observability from "./observability.ts";
@@ -11,20 +13,27 @@ import * as Paths from "./paths.ts";
 import * as Pi from "./pi.ts";
 import * as RunDelivery from "./run-delivery.ts";
 import * as RunDeliveryLineage from "./run-delivery-lineage.ts";
+import * as RunIndex from "./runs-index.ts";
+import { formatLiteralBlock, formatMarkdownField } from "./tools-response.ts";
 
 export interface RunUiRuntime {
   close(): void;
+  isCurrentSessionContext(ctx: Pi.ExtensionContext): boolean;
   flushCompletionBatch(ctx: Pi.ExtensionContext): boolean;
+  onTurnEnd(event: Pi.TurnEndEvent, ctx: Pi.ExtensionContext): Pi.TurnEndEventResult | undefined;
   projectContext(messages: unknown[], ctx: Pi.ExtensionContext): unknown[];
   shutdown(
     eventReason: string,
     ownerId: string | undefined,
     ctx?: Pi.ExtensionContext,
   ): void;
-  start(ctx: Pi.ExtensionContext, ownerId: string): void;
+  start(ctx: Pi.ExtensionContext, ownerId: string, event?: Pi.SessionStartEvent): void;
 }
 
 export interface RunUiRuntimeDeps {
+  /** Trusted kernel opt-in for verified fresh creation; never actor data, continuity proof or bootstrap. */
+  completionStreamSessionAdmission?: (ctx: Pi.ExtensionContext, event: Pi.SessionStartEvent) => boolean;
+  captureCompletionBatch?: typeof RunDelivery.admitRunCompletionBatch;
   animationIntervalMs?: number;
   createRunStateWatcher?: typeof Observability.createRunStateWatcher;
   createRunTerminalReconciliationLoop?:
@@ -38,10 +47,89 @@ export interface RunUiRuntimeDeps {
   teardownRunsOwnedByParent?: typeof AsyncRuns.teardownRunsOwnedByParent;
 }
 
+function formatSteerDiagnosticMessage(eventId: string, stage: "admission" | "delivery", message: string): string {
+  const fields = [formatMarkdownField("event", eventId), formatMarkdownField("attention", "steer"),
+    formatMarkdownField("stage", stage), formatMarkdownField("result", stage === "admission" ? "remains retryable" : "request failed")];
+  if (stage === "delivery") fields.push(formatMarkdownField("delivery", "unconfirmed"), formatMarkdownField("presentation", "unconfirmed"));
+  let end = Math.min(message.length, 240);
+  const last = message.charCodeAt(end - 1), next = message.charCodeAt(end);
+  if (last >= 0xd800 && last <= 0xdbff && next >= 0xdc00 && next <= 0xdfff) end -= 1;
+  const preview = message.slice(0, end), clipped = end < message.length;
+  if (Buffer.from(preview).toString("utf8") !== preview) {
+    fields.push(formatMarkdownField("diagnostic", "unavailable"), formatMarkdownField("diagnostic_reason", "malformed legacy preview"),
+      formatMarkdownField("diagnostic_omission", "[omitted: unknown]"));
+  } else {
+    fields.push(formatMarkdownField("diagnostic", preview + (clipped ? "…" : "")));
+    if (clipped) fields.push(formatMarkdownField("diagnostic_omission", "[omitted: unknown]"));
+  }
+  return fields.join("\n");
+}
+
+/** Transcript-only view of the exact delivered content; never re-read a Run or infer body labels. */
+export function registerRunCompletionRenderer(pi: Pi.ExtensionAPI): void {
+  pi.registerMessageRenderer(Pi.RUN_COMPLETION_BATCH_CUSTOM_TYPE, (message, { expanded, outputPad }, theme) => {
+    if (typeof message.content !== "string") return undefined;
+    let presentation: unknown;
+    try { presentation = Object.getOwnPropertyDescriptor(message.details as object, "pi_actors_presentation")?.value; } catch { /* no layout hint */ }
+    const view = RunDelivery.readRunCompletionPresentation(message.content, presentation);
+    if (!view) return undefined;
+    if (!expanded && view.segments) {
+      const component = new Container(), markdownTheme = { ...Pi.getMarkdownTheme(), codeBlockIndent: "" };
+      component.addChild(new Spacer(1));
+      let pieces = 0;
+      for (const segment of view.segments) {
+        // Only compiler separator/marker chunks drive spacing; whitespace bodies remain Markdown.
+        if (segment.kind === "separator" || (segment.kind === "marker" && /^\n+$/u.test(segment.text))) continue;
+        if (pieces++) component.addChild(new Spacer(1));
+        const text = stripTerminalSequences(segment.text).replaceAll(/\r\n|\r/gu, "\n");
+        component.addChild(segment.kind === "body"
+          ? new Markdown(text, outputPad, 0, markdownTheme, { color: value => theme.fg("customMessageText", value) })
+          : new Text(theme.fg("muted", text), outputPad, 0));
+      }
+      component.addChild(new Spacer(1));
+      component.addChild(new Text(theme.fg("muted", "Expand message for technical details."), outputPad, 0));
+      component.addChild(new Spacer(1));
+      return component;
+    }
+    if (!expanded && view.blocks) {
+      const component = new Container(), markdownTheme = { ...Pi.getMarkdownTheme(), codeBlockIndent: "" };
+      component.addChild(new Spacer(1));
+      for (const [index, [kind, start, end]] of view.blocks.entries()) {
+        if (index) component.addChild(new Spacer(1));
+        let text = stripTerminalSequences(message.content.slice(start, end)).replaceAll(/\r\n|\r/gu, "\n");
+        if (kind === "header") {
+          // Only validated compiler headers may hide whole reference rows; body lookalikes stay visible.
+          text = text.split("\n").filter(line => !line.startsWith("references: ") && !line.startsWith("run_files: ")).join("\n").replace(/\n$/u, "");
+        }
+        component.addChild(kind === "body"
+          ? new Markdown(text, outputPad, 0, markdownTheme, { color: value => theme.fg("customMessageText", value) })
+          : new Text(theme.fg(kind === "header" || kind === "marker" ? "muted" : "customMessageText", text), outputPad, 0));
+      }
+      component.addChild(new Spacer(1));
+      component.addChild(new Text(theme.fg("muted", "Expand message for technical details."), outputPad, 0));
+      component.addChild(new Spacer(1));
+      return component;
+    }
+    const text = expanded ? message.content : view.text;
+    const label = view.yaml || (view.records && !view.single) ? "" : theme.fg("customMessageLabel", view.single ? "Run result" : "Run Batch") + "\n\n";
+    return new Text(label + theme.fg("customMessageText", stripTerminalSequences(text).replaceAll(/\r\n|\r/gu, "\n"))
+      + (!expanded && view.compact ? "\n\n" + theme.fg("muted", "Expand message for technical details.") : ""), outputPad, 1);
+  });
+}
+
 export function createRunUiRuntime(deps: RunUiRuntimeDeps): RunUiRuntime {
+  if (deps.captureCompletionBatch && deps.completionStreamSessionAdmission) throw new Error("Candidate completion capture cannot use completion streams");
+  const fencedCompletionSession = Boolean(deps.captureCompletionBatch || deps.completionStreamSessionAdmission);
   let activeContext: Pi.ExtensionContext | undefined;
   let activeOwnerId: string | undefined;
+  let sessionTicket: object | undefined;
+  let sessionManager: Pi.ExtensionContext["sessionManager"] | undefined;
+  let streamSessionAdmitted = false;
+  const contextTickets = new WeakMap<Pi.ExtensionContext, object>();
+  const seenManagers = new WeakSet<Pi.ExtensionContext["sessionManager"]>();
   let animationInterval: NodeJS.Timeout | undefined;
+  let displayRunningSubagents = 0;
+  let displayFrame = 0;
   let deliveryTimeout: NodeJS.Timeout | undefined;
   let notifyTimeout: NodeJS.Timeout | undefined;
   let recoverQueuedSteers = false;
@@ -51,9 +139,15 @@ export function createRunUiRuntime(deps: RunUiRuntimeDeps): RunUiRuntime {
   const deliveryObservation = Observability.createRunUiObservationState();
   const retirementAttempts = new Set<string>();
   const steerDiagnostics = new Set<string>();
+  const completionDiagnostics = new Set<string>();
 
   const close = (): void => {
     running = false;
+    displayRunningSubagents = 0;
+    displayFrame = 0;
+    sessionTicket = undefined;
+    sessionManager = undefined;
+    streamSessionAdmitted = false;
     activeContext = undefined;
     activeOwnerId = undefined;
     try {
@@ -72,6 +166,7 @@ export function createRunUiRuntime(deps: RunUiRuntimeDeps): RunUiRuntime {
     deliveryTimeout = undefined;
     recoverQueuedSteers = false;
     steerDiagnostics.clear();
+    completionDiagnostics.clear();
     if (animationInterval) clearInterval(animationInterval);
     animationInterval = undefined;
   };
@@ -89,7 +184,8 @@ export function createRunUiRuntime(deps: RunUiRuntimeDeps): RunUiRuntime {
     }
     const message = error instanceof Error ? error.message : String(error);
     try {
-      expectedContext.ui.notify(`Actor ${label} failed: ${message}`, "error");
+      expectedContext.ui.notify([formatMarkdownField("callback", label), formatMarkdownField("result", "failed"),
+        formatMarkdownField("diagnostic", message)].join("\n"), "error");
     } catch {
       /* stale context or unavailable UI */
     }
@@ -97,14 +193,15 @@ export function createRunUiRuntime(deps: RunUiRuntimeDeps): RunUiRuntime {
   const runActiveCallback = (
     label: string,
     callback: (ctx: Pi.ExtensionContext, ownerId: string) => void,
+    expectedTicket: object | undefined,
   ): void => {
-    if (!running || !activeContext || !activeOwnerId) return;
+    if (expectedTicket !== sessionTicket || !running || !activeContext || !activeOwnerId) return;
     const ctx = activeContext;
     try {
       if (deps.getActiveContext() !== ctx) return;
       callback(ctx, activeOwnerId);
     } catch (error) {
-      stopAfterCallbackFailure(label, error, ctx);
+      if (expectedTicket === sessionTicket) stopAfterCallbackFailure(label, error, ctx);
     }
   };
   const retireCandidateRuns = (
@@ -169,16 +266,6 @@ export function createRunUiRuntime(deps: RunUiRuntimeDeps): RunUiRuntime {
       if (steer.phase === "presented") finishPresentedSteer(ownerId, steer);
     }
   };
-  const boundedSteerContent = (event: Observability.RunAttentionEvent): string => {
-    const text = Observability.formatRunAttentionMessage(event);
-    if (Buffer.byteLength(text, "utf8") <= Limits.RUN_DELIVERY_STEER_MAX_BYTES) {
-      return text;
-    }
-    let end = Math.min(text.length, Limits.RUN_DELIVERY_STEER_MAX_BYTES - 3);
-    while (end > 0 && Buffer.byteLength(text.slice(0, end), "utf8") >
-      Limits.RUN_DELIVERY_STEER_MAX_BYTES - 3) end -= 1;
-    return `${text.slice(0, end)}…`;
-  };
   const admitSteerEvents = (
     ctx: Pi.ExtensionContext,
     ownerId: string,
@@ -191,15 +278,17 @@ export function createRunUiRuntime(deps: RunUiRuntimeDeps): RunUiRuntime {
         if (!steerDiagnostics.has(key)) {
           steerDiagnostics.add(key);
           ctx.ui.notify(
-            `Actor urgent steer ${event.id} remains retryable because its Run generation is unavailable.`,
+            formatSteerDiagnosticMessage(event.id, "admission", "Run generation unavailable."),
             "warning",
           );
         }
         continue;
       }
       try {
+        if (journal(ownerId).steers.some(steer => steer.run === event.run && steer.state_dir === event.stateDir &&
+          steer.run_instance_id === event.runInstanceId && steer.event_id === event.id)) continue;
         RunDelivery.admitRunSteerEnvelope({
-          content: boundedSteerContent(event),
+          content: Observability.formatRunSteerMessage(event),
           eventId: event.id,
           kind: event.kind,
           level: event.level,
@@ -217,7 +306,7 @@ export function createRunUiRuntime(deps: RunUiRuntimeDeps): RunUiRuntime {
         if (!steerDiagnostics.has(key)) {
           steerDiagnostics.add(key);
           ctx.ui.notify(
-            `Actor urgent steer ${event.id} remains retryable: ${message.replaceAll(/\s+/g, " ").slice(0, 240)}`,
+            formatSteerDiagnosticMessage(event.id, "admission", message),
             "warning",
           );
         }
@@ -225,6 +314,7 @@ export function createRunUiRuntime(deps: RunUiRuntimeDeps): RunUiRuntime {
     }
   };
   const admitCompletionTransitions = (
+    ctx: Pi.ExtensionContext,
     ownerId: string,
     snapshot: Observability.RunUiSnapshot,
   ): boolean => {
@@ -234,14 +324,95 @@ export function createRunUiRuntime(deps: RunUiRuntimeDeps): RunUiRuntime {
       snapshot.transitions,
       snapshot.summary.runs,
     ).slice(0, Limits.RUN_DELIVERY_BATCH_MAX_MEMBERS);
-    if (members.length === 0) return false;
-    RunDelivery.admitRunCompletionBatch({
+    if (members.length === 0 || !isCurrentOwner(ctx)) return false;
+    const fileNavigation: RunDelivery.RunCompletionFileNavigation[] = [];
+    for (const member of RunDelivery.orderRunCompletionMembers(members, true)) {
+      let locations: Readonly<RunIndex.RunDirectoryNavigation>;
+      try {
+        const observed = snapshot.summary.runs.find(run => run.run === member.run && run.runInstanceId === member.run_instance_id && run.stateDir === member.state_dir);
+        locations = !observed ? Object.freeze({ state: "unavailable", reason: "identity_unavailable" })
+          : observed.ownerId !== ownerId ? Object.freeze({ state: "unavailable", reason: "session_mismatch" })
+          : RunIndex.readRunDirectoryNavigation(member.state_dir, { run: member.run, run_instance_id: member.run_instance_id, ownerId: observed.ownerId }, Pi.getSessionId(ctx));
+      } catch { locations = Object.freeze({ state: "unavailable", reason: "navigation_unavailable" }); }
+      fileNavigation.push({ member_index: members.indexOf(member), locations });
+      if (Buffer.byteLength(JSON.stringify(fileNavigation), "utf8") > Limits.RUN_DELIVERY_MODEL_MAX_BYTES) { fileNavigation.pop(); break; }
+    }
+    if (!isCurrentOwner(ctx)) return false;
+    if (!canUseCompletionSession(ctx, ownerId)) return false;
+    const capture = deps.completionStreamSessionAdmission ? RunDelivery.captureRunCompletionStreamBatch : deps.captureCompletionBatch ?? RunDelivery.admitRunCompletionBatch;
+    capture({
       members,
+      fileNavigation,
       ownerId,
       tempDir: Paths.EXTENSION_RUNTIME_PATHS.tempDir,
     });
     return true;
   };
+  const acceptCompletionBatch = (ownerId: string, batchId: string): boolean => {
+    const input = { batchId, ownerId, tempDir: Paths.EXTENSION_RUNTIME_PATHS.tempDir };
+    if (!RunDelivery.markRunCompletionBatchQueued(input)) return false;
+    if (!RunDelivery.markRunCompletionBatchPresented(input)) return false;
+    const accepted = journal(ownerId).completion_batch;
+    return accepted ? finishPresentedBatch(ownerId, accepted) : false;
+  };
+  const reconcileCompletionBatch = (ctx: Pi.ExtensionContext, ownerId: string): boolean => {
+    const batch = journal(ownerId).completion_batch;
+    if (!batch) return false;
+    if (batch.phase === "pending") {
+      // Returning boundary drafts is not acceptance: prove the exact entry before acknowledging it.
+      const evidence = Pi.inspectRunCompletionBatchSessionEvidence(ctx, {
+        batchId: batch.batch_id,
+        content: RunDelivery.formatRunCompletionBatchMessage(batch),
+      });
+      if (evidence.status === "absent") return false;
+      if (evidence.status !== "present") {
+        const key = `${batch.batch_id}:${evidence.status}:${evidence.reason ?? ""}`;
+        if (!completionDiagnostics.has(key)) {
+          completionDiagnostics.add(key);
+          ctx.ui.notify(
+            "\n" + [formatMarkdownField("batch", batch.batch_id), formatMarkdownField("stage", "completion recovery"),
+                formatMarkdownField("evidence", evidence.status), formatMarkdownField("phase", "pending"),
+                formatMarkdownField("reason", evidence.reason ?? "conflicting session evidence")].join("\n"),
+            "warning",
+          );
+        }
+        return true;
+      }
+    }
+    if (fencedCompletionSession && !canUseCompletionSession(ctx, ownerId)) return true;
+    return !acceptCompletionBatch(ownerId, batch.batch_id);
+  };
+  const pendingCompletionBatch = (ctx: Pi.ExtensionContext, ownerId: string): RunDelivery.RunCompletionBatch | undefined => {
+    const existing = journal(ownerId).completion_batch;
+    if (existing) return existing;
+    const snapshot = Observability.readRunDeliverySnapshot(deliveryObservation, ownerId);
+    admitCompletionTransitions(ctx, ownerId, snapshot);
+    Observability.pruneRunUiObservationState(deliveryObservation, snapshot);
+    return journal(ownerId).completion_batch;
+  };
+  const isCurrentOwner = (ctx: Pi.ExtensionContext): boolean => {
+    if (!running || !activeOwnerId) return false;
+    if (!fencedCompletionSession) {
+      try { return Pi.getSessionId(ctx) === activeOwnerId; } catch { return false; }
+    }
+    const ticket = sessionTicket, ownerId = activeOwnerId, known = contextTickets.get(ctx);
+    if (!ticket || (known && known !== ticket)) return false;
+    try {
+      if (deps.getActiveContext() !== activeContext) return false;
+      const manager = ctx.sessionManager;
+      if (manager !== sessionManager || manager.getSessionId() !== ownerId || ticket !== sessionTicket || !running) return false;
+      contextTickets.set(ctx, ticket);
+      return true;
+    } catch { return false; }
+  };
+  const canUseCompletionSession = (ctx: Pi.ExtensionContext, ownerId: string): boolean => {
+    if (deps.captureCompletionBatch && !isCurrentOwner(ctx)) return false;
+    if (!deps.completionStreamSessionAdmission) return !journal(ownerId).completion_stream;
+    if (!isCurrentOwner(ctx)) return false;
+    const ticket = sessionTicket, state = journal(ownerId).completion_stream;
+    // No metadata is not disconnected. The opt-in path never bootstraps or falls back to local indices.
+    return streamSessionAdmitted && Boolean(state) && ticket === sessionTicket && isCurrentOwner(ctx);
+  };
   const isIdle = (ctx: Pi.ExtensionContext): boolean =>
     typeof ctx.isIdle !== "function" || ctx.isIdle();
   const isDeliveryRoot = (ownerId: string): boolean => {
@@ -270,7 +441,9 @@ export function createRunUiRuntime(deps: RunUiRuntimeDeps): RunUiRuntime {
           if (!steerDiagnostics.has(key)) {
             steerDiagnostics.add(key);
             ctx.ui.notify(
-              `Actor urgent steer recovery is ${evidence.status}: ${evidence.reason ?? "conflicting session evidence"}. Event ${steer.event_id} remains queued.`,
+              [formatMarkdownField("event", steer.event_id), formatMarkdownField("attention", "steer"),
+                formatMarkdownField("stage", "recovery"), formatMarkdownField("evidence", evidence.status),
+                formatMarkdownField("phase", "queued"), formatMarkdownField("reason", evidence.reason ?? "conflicting session evidence")].join("\n"),
               "warning",
             );
           }
@@ -299,7 +472,7 @@ export function createRunUiRuntime(deps: RunUiRuntimeDeps): RunUiRuntime {
         });
         const message = error instanceof Error ? error.message : String(error);
         ctx.ui.notify(
-          `Actor urgent steer delivery failed for event ${steer.event_id}: ${message.replaceAll(/\s+/g, " ").slice(0, 240)}`,
+          formatSteerDiagnosticMessage(steer.event_id, "delivery", message),
           "error",
         );
         continue;
@@ -315,12 +488,14 @@ export function createRunUiRuntime(deps: RunUiRuntimeDeps): RunUiRuntime {
   };
   const scheduleCompletionFlush = (): void => {
     if (!running) return;
+    const ticket = sessionTicket;
     if (deliveryTimeout) clearTimeout(deliveryTimeout);
     deliveryTimeout = setTimeout(() => {
+      if (ticket !== sessionTicket) return;
       deliveryTimeout = undefined;
       runActiveCallback("completion delivery callback", (ctx) => {
         flushCompletionBatch(ctx);
-      });
+      }, ticket);
     }, deps.deliveryDebounceMs ?? 100);
     deliveryTimeout.unref?.();
   };
@@ -330,22 +505,30 @@ export function createRunUiRuntime(deps: RunUiRuntimeDeps): RunUiRuntime {
     notify = false,
     terminalOnly = false,
   ): boolean => {
-    const snapshot = Observability.readRunUiSnapshot(observation, ownerId);
-    ctx.ui.setStatus(
-      "zz-pi-actors-runs",
-      snapshot.status ? ctx.ui.theme.fg("dim", snapshot.status) : undefined,
-    );
-    if (!notify) return false;
+    // Derive both projections before any UI/retirement callback. The subsequent
+    // flush still observes afresh; these facts only drive display/candidate scheduling.
+    const ticket = sessionTicket;
+    const pair = notify && isDeliveryRoot(ownerId)
+      ? Observability.readRunUiAndDeliverySnapshots(observation, deliveryObservation, ownerId)
+      : undefined;
+    const snapshot = pair?.ui ?? Observability.readRunUiSnapshot(observation, ownerId);
+    if (ticket !== sessionTicket || (fencedCompletionSession && !isCurrentOwner(ctx))) return false;
+    // Animation retains display data only; all admission paths continue observing independently.
+    displayRunningSubagents = snapshot.summary.runningSubagents;
+    displayFrame = 0;
+    const status = snapshot.status && ctx.mode === "tui" ? ctx.ui.theme.fg("dim", snapshot.status) : snapshot.status;
+    if (ticket !== sessionTicket) return false;
+    ctx.ui.setStatus("zz-pi-actors-runs", status);
+    if (ticket !== sessionTicket) return false;
+    if (!notify || (fencedCompletionSession && !isCurrentOwner(ctx))) return false;
     const sink = Pi.createNotificationSink(deps.pi, ctx);
     retireCandidateRuns(ctx, snapshot.summary);
-    const deliverySnapshot = isDeliveryRoot(ownerId)
-      ? Observability.readRunDeliverySnapshot(deliveryObservation, ownerId)
-      : undefined;
+    const deliverySnapshot = pair?.delivery;
     const hasCompletionCandidates = deliverySnapshot
-      ? Observability.collectRunCompletionBatchMembers(
+      ? Observability.hasRunCompletionBatchMembers(
           deliverySnapshot.transitions,
           deliverySnapshot.summary.runs,
-        ).length > 0
+        )
       : false;
     const hasCompletionBatch = isDeliveryRoot(ownerId) &&
       Boolean(journal(ownerId).completion_batch);
@@ -380,29 +563,31 @@ export function createRunUiRuntime(deps: RunUiRuntimeDeps): RunUiRuntime {
       );
     }
   };
-  const scheduleUpdate = (): void => {
-    if (!running) return;
+  const scheduleUpdate = (ticket: object | undefined): void => {
+    if (ticket !== sessionTicket || !running) return;
     if (notifyTimeout) clearTimeout(notifyTimeout);
     notifyTimeout = setTimeout(() => {
+      if (ticket !== sessionTicket) return;
       runActiveCallback("Run watcher callback", (ctx, ownerId) => {
         watcher.refresh();
         const completionDeferred = update(ctx, ownerId, true);
+        if (ticket !== sessionTicket) return;
         if (!completionDeferred) deps.onRunEvent();
-        reportDiagnostics(ctx);
-      });
+        if (ticket === sessionTicket) reportDiagnostics(ctx);
+      }, ticket);
     }, deps.notificationDelayMs ?? 50);
     notifyTimeout.unref?.();
   };
-  const watcher = (deps.createRunStateWatcher ?? Observability.createRunStateWatcher)({
+  const createWatcher = (ticket: object | undefined) => (deps.createRunStateWatcher ?? Observability.createRunStateWatcher)({
     stateRoot: Paths.EXTENSION_RUNTIME_PATHS.runStateRoot,
-    onChange: scheduleUpdate,
+    onChange: () => scheduleUpdate(ticket),
   });
-  const reconciliation = (
+  const createReconciliation = (ticket: object | undefined) => (
     deps.createRunTerminalReconciliationLoop ??
     Observability.createRunTerminalReconciliationLoop
   )({
     onError: (error) => {
-      if (!running || !activeContext) return;
+      if (ticket !== sessionTicket || !running || !activeContext) return;
       stopAfterCallbackFailure(
         "terminal reconciliation callback",
         error,
@@ -413,61 +598,31 @@ export function createRunUiRuntime(deps: RunUiRuntimeDeps): RunUiRuntime {
       runActiveCallback("terminal reconciliation callback", (ctx, ownerId) => {
         update(ctx, ownerId, true);
         reportDiagnostics(ctx);
-      });
+      }, ticket);
     },
     refreshWatcher: () => {
-      if (running) watcher.refresh();
+      if (ticket === sessionTicket && running) watcher.refresh();
     },
   });
+  let watcher = createWatcher(undefined);
+  let reconciliation = createReconciliation(undefined);
 
   flushCompletionBatch = (ctx: Pi.ExtensionContext): boolean => {
     const ownerId = activeOwnerId;
-    if (!running || !ownerId) return false;
-    try {
-      if (Pi.getSessionId(ctx) !== ownerId) return false;
-    } catch {
-      return false;
-    }
+    if (!ownerId || !isCurrentOwner(ctx)) return false;
     if (flushSteers(ctx, ownerId)) return true;
     if (!isDeliveryRoot(ownerId)) return false;
-    let batch = journal(ownerId).completion_batch;
-    if (!batch) {
-      const snapshot = Observability.readRunDeliverySnapshot(
-        deliveryObservation,
-        ownerId,
-      );
-      admitCompletionTransitions(ownerId, snapshot);
-      Observability.pruneRunUiObservationState(deliveryObservation, snapshot);
-      batch = journal(ownerId).completion_batch;
-    }
+    if (!canUseCompletionSession(ctx, ownerId)) return true;
+    if (reconcileCompletionBatch(ctx, ownerId)) return true;
+    const batch = pendingCompletionBatch(ctx, ownerId);
     if (!batch) return false;
-    if (batch.phase === "presented") {
-      finishPresentedBatch(ownerId, batch);
-      const snapshot = Observability.readRunDeliverySnapshot(
-        deliveryObservation,
-        ownerId,
-      );
-      admitCompletionTransitions(ownerId, snapshot);
-      Observability.pruneRunUiObservationState(deliveryObservation, snapshot);
-      batch = journal(ownerId).completion_batch;
-      if (!batch) return false;
-    }
-    if (!isIdle(ctx)) return true;
-    const content = RunDelivery.formatRunCompletionBatchMessage(batch);
-    if (batch.phase === "queued") {
-      if (!RunDelivery.markRunCompletionBatchPresented({
-        batchId: batch.batch_id,
-        ownerId,
-        tempDir: Paths.EXTENSION_RUNTIME_PATHS.tempDir,
-      })) return true;
-      const accepted = journal(ownerId).completion_batch;
-      if (accepted) finishPresentedBatch(ownerId, accepted);
-      return flushCompletionBatch(ctx);
-    }
     if (!isIdle(ctx)) return true;
+    const projected = RunDelivery.projectRunCompletionBatchPresentation(batch);
+    if (!isIdle(ctx) || !isCurrentOwner(ctx)) return true;
     try {
-      Pi.sendRunCompletionBatch(deps.pi, batch.batch_id, content);
+      Pi.sendRunCompletionBatch(deps.pi, batch.batch_id, projected.content, projected.presentation);
     } catch (error) {
+      if (fencedCompletionSession && !isCurrentOwner(ctx)) throw error;
       RunDelivery.recordRunCompletionBatchDeliveryFailure({
         batchId: batch.batch_id,
         error,
@@ -476,40 +631,35 @@ export function createRunUiRuntime(deps: RunUiRuntimeDeps): RunUiRuntime {
       });
       throw error;
     }
-    if (!RunDelivery.markRunCompletionBatchQueued({
-      batchId: batch.batch_id,
-      ownerId,
-      tempDir: Paths.EXTENSION_RUNTIME_PATHS.tempDir,
-    })) {
-      throw new Error("Completion batch changed before queue acknowledgment");
-    }
-    if (!RunDelivery.markRunCompletionBatchPresented({
-      batchId: batch.batch_id,
-      ownerId,
-      tempDir: Paths.EXTENSION_RUNTIME_PATHS.tempDir,
-    })) {
+    if (fencedCompletionSession && !canUseCompletionSession(ctx, ownerId)) return true;
+    if (!acceptCompletionBatch(ownerId, batch.batch_id)) {
       throw new Error("Completion batch changed before durable acceptance");
     }
-    const accepted = journal(ownerId).completion_batch;
-    if (accepted) finishPresentedBatch(ownerId, accepted);
-    ctx.ui.notify(
-      `Actor completions ready: ${batch.members.length}`,
-      "info",
-    );
     return true;
   };
 
   return {
     close,
+    isCurrentSessionContext: isCurrentOwner,
     flushCompletionBatch,
+    onTurnEnd(event, ctx) {
+      const ownerId = activeOwnerId;
+      if (
+        !ownerId || !isCurrentOwner(ctx) || !isDeliveryRoot(ownerId) ||
+        event.outcome !== "completed" || isIdle(ctx) || ctx.signal?.aborted ||
+        ctx.hasPendingMessages?.() || event.context.pendingMessages.length > 0
+      ) return undefined;
+      if (flushSteers(ctx, ownerId) || !canUseCompletionSession(ctx, ownerId) || reconcileCompletionBatch(ctx, ownerId)) return undefined;
+      const batch = pendingCompletionBatch(ctx, ownerId);
+      if (!batch || !isCurrentOwner(ctx)) return undefined;
+      const projected = RunDelivery.projectRunCompletionBatchPresentation(batch);
+      const entry = Pi.createRunCompletionBatchEntry(batch.batch_id, projected.content, projected.presentation);
+      if (!canUseCompletionSession(ctx, ownerId)) return undefined;
+      return { entries: [...event.entries, entry], continue: true };
+    },
     projectContext(messages, ctx) {
       const ownerId = activeOwnerId;
-      if (!running || !ownerId) return messages;
-      try {
-        if (Pi.getSessionId(ctx) !== ownerId) return messages;
-      } catch {
-        return messages;
-      }
+      if (!ownerId || !isCurrentOwner(ctx)) return messages;
       const steerContext = Pi.dedupeRunSteerContext(messages);
       let contextMessages = steerContext.messages;
       for (const steer of journal(ownerId).steers) {
@@ -539,6 +689,7 @@ export function createRunUiRuntime(deps: RunUiRuntimeDeps): RunUiRuntime {
           item.steer_id === steer.steer_id);
         if (durable) finishPresentedSteer(ownerId, durable);
       }
+      if (!canUseCompletionSession(ctx, ownerId)) return contextMessages;
       const projected = Pi.dedupeRunCompletionBatchContext(contextMessages);
       const batch = journal(ownerId).completion_batch;
       if (!batch) return projected.messages;
@@ -549,18 +700,7 @@ export function createRunUiRuntime(deps: RunUiRuntimeDeps): RunUiRuntime {
           batch.batch_id,
         );
       }
-      if (!RunDelivery.markRunCompletionBatchQueued({
-        batchId: batch.batch_id,
-        ownerId,
-        tempDir: Paths.EXTENSION_RUNTIME_PATHS.tempDir,
-      })) return projected.messages;
-      if (!RunDelivery.markRunCompletionBatchPresented({
-        batchId: batch.batch_id,
-        ownerId,
-        tempDir: Paths.EXTENSION_RUNTIME_PATHS.tempDir,
-      })) return projected.messages;
-      const presented = journal(ownerId).completion_batch;
-      if (presented) finishPresentedBatch(ownerId, presented);
+      if (!fencedCompletionSession || canUseCompletionSession(ctx, ownerId)) acceptCompletionBatch(ownerId, batch.batch_id);
       return projected.messages;
     },
     shutdown(eventReason, ownerId, ctx) {
@@ -575,30 +715,57 @@ export function createRunUiRuntime(deps: RunUiRuntimeDeps): RunUiRuntime {
       if (teardown.failed === 0 || !ctx) return;
       try {
         ctx.ui.notify(
-          `Actor shutdown teardown: killed=${teardown.killed} failed=${teardown.failed} skipped=${teardown.skipped} discovery_failed=${teardown.discoveryFailed}. Summary: ${teardown.summaryPath ?? "unavailable"}.`,
+          [formatMarkdownField("stage", "shutdown teardown"), formatMarkdownField("killed", String(teardown.killed)),
+            formatMarkdownField("failed", String(teardown.failed)), formatMarkdownField("skipped", String(teardown.skipped)),
+            formatMarkdownField("discovery_failed", String(teardown.discoveryFailed)),
+            formatMarkdownField("summary", teardown.summaryPath == null ? "unavailable" : formatLiteralBlock(teardown.summaryPath)),
+            formatMarkdownField("basis", "teardown report; not scope closure")].join("\n"),
           "warning",
         );
       } catch {
         /* stale shutdown context */
       }
     },
-    start(ctx, ownerId) {
+    start(ctx, ownerId, event) {
       close();
+      const ticket = {};
+      sessionTicket = ticket;
       activeContext = ctx;
       activeOwnerId = ownerId;
       recoverQueuedSteers = true;
       running = true;
       try {
-        recoverPresentedBatch(ownerId);
+        if (fencedCompletionSession) {
+          sessionManager = ctx.sessionManager;
+          const fresh = !seenManagers.has(sessionManager) && !contextTickets.has(ctx);
+          seenManagers.add(sessionManager);
+          if (!contextTickets.has(ctx)) contextTickets.set(ctx, ticket);
+          if (deps.captureCompletionBatch && !fresh) sessionManager = undefined;
+          if (deps.completionStreamSessionAdmission && fresh && event && (event.reason === "new" || event.reason === "fork") && isCurrentOwner(ctx)) {
+            const admitted = deps.completionStreamSessionAdmission(ctx, event) === true && isCurrentOwner(ctx);
+            if (ticket !== sessionTicket) return;
+            streamSessionAdmitted = admitted;
+          }
+        }
+        if (ticket !== sessionTicket) return;
+        watcher = createWatcher(ticket);
+        reconciliation = createReconciliation(ticket);
+        if (canUseCompletionSession(ctx, ownerId)) recoverPresentedBatch(ownerId);
         recoverPresentedSteers(ownerId);
         Observability.primeRunAttentionState(observation, ownerId);
         update(ctx, ownerId, true, true);
+        if (ticket !== sessionTicket) return;
         watcher.refresh();
+        if (ticket !== sessionTicket) return;
         reconciliation.start();
+        if (ticket !== sessionTicket || ctx.mode !== "tui") return;
         animationInterval = setInterval(() => {
-          runActiveCallback("status animation callback", (current, currentOwnerId) =>
-            update(current, currentOwnerId),
-          );
+          runActiveCallback("status animation callback", (current) => {
+            const status = Observability.renderSubagentStatus(displayRunningSubagents, ++displayFrame);
+            const themed = status ? current.ui.theme.fg("dim", status) : status;
+            if (ticket !== sessionTicket) return;
+            current.ui.setStatus("zz-pi-actors-runs", themed);
+          }, ticket);
         }, deps.animationIntervalMs ?? 1000);
         animationInterval.unref?.();
       } catch (error) {