@tt-a1i/openpi 0.5.0 → 0.6.1

package/extensions/subagents/src/result-delivery.ts

@@ -1,10 +1,16 @@
 import type { ConsumableResultDeliveryQueue } from "../../shared/result-delivery.ts";
+import {
+  type CompletionOwner,
+  createCompletionInbox,
+} from "../../shared/completion-inbox.ts";
 
 export interface SubagentResultDeliveryOptions<T> {
   /** True only when the parent has no run or queued continuation in flight. */
   readonly isIdle: () => boolean;
   /** Deliver one drained batch and wake the parent. */
   readonly deliver: (results: readonly T[]) => void;
+  /** Current Pi Session transcript owner. */
+  readonly owner?: () => CompletionOwner | undefined;
 }
 
 /**
@@ -22,50 +28,63 @@ export interface SubagentResultDeliveryOptions<T> {
  * The parent boundary wakes even if an earlier extension handler has already
  * started another turn: Pi queues the follow-up into that active run.
  *
- * The Map is the one-shot gate: `subagent_wait` may consume a result before it
- * is delivered, and whichever path drains first prevents duplicate delivery.
+ * The shared inbox is the one-shot gate: `subagent_wait` may consume a result
+ * before it is delivered, and whichever path claims first prevents duplicate
+ * delivery.
  */
 export function createSubagentResultDelivery<T extends { id: string }>(
   options: SubagentResultDeliveryOptions<T>,
 ) {
-  const pending = new Map<string, T>();
+  const inbox = createCompletionInbox<T>();
+  const owner = options.owner ?? (() => ({ sessionId: "test", epoch: 0 }));
 
   const flush = () => {
-    if (pending.size === 0) return;
-    const results = [...pending.values()];
-    pending.clear();
+    const envelopes = inbox.claim(owner());
+    if (envelopes.length === 0) return;
+    const results = envelopes.map((envelope) => envelope.payload);
     try {
       options.deliver(results);
+      inbox.acknowledge(envelopes.map((envelope) => envelope.deliveryId));
     } catch (error) {
       // A synchronous session teardown may reject append/send. Preserve the
       // original batch ahead of anything deferred re-entrantly while delivery
       // ran, so a later boundary can retry without loss or reordering.
-      const current = [...pending.values()];
-      pending.clear();
-      for (const result of results) pending.set(result.id, result);
-      for (const result of current) pending.set(result.id, result);
+      inbox.retry(envelopes, owner());
       throw error;
     }
   };
 
   const queue = {
     defer(result: T) {
-      pending.set(result.id, result);
+      const currentOwner = owner();
+      inbox.defer(
+        {
+          deliveryId: `subagent:${result.id}`,
+          owner: currentOwner ?? { sessionId: "unowned", epoch: 0 },
+          producer: "subagent",
+          producerId: result.id,
+          terminalRef: { kind: "subagent-snapshot", id: result.id },
+          wake: "follow-up",
+          payload: result,
+        },
+        currentOwner,
+      );
       if (options.isIdle()) flush();
     },
     consume(ids: Iterable<string>) {
-      for (const id of ids) pending.delete(id);
+      inbox.consume("subagent", ids);
     },
     /** Flush at the authoritative parent boundary. */
     parentSettled() {
       flush();
     },
     clear() {
-      pending.clear();
+      inbox.clear();
     },
     size() {
-      return pending.size;
+      return inbox.size();
     },
+    inspectDeadLetters: inbox.inspectDeadLetters,
   };
   return queue satisfies ConsumableResultDeliveryQueue<T>;
 }

package/extensions/subagents/src/runtime.ts

@@ -45,6 +45,9 @@ export function createSubagentRuntime(config: SubagentManagerConfig = {}) {
 
 export type SubagentRuntime = ReturnType<typeof createSubagentRuntime>;
 
+/** Canonical interruption, distinct from a known startup failure. */
+export class SubagentToolInterruptedError extends Error {}
+
 /**
  * Run an effect from an async tool handler. Typed failures and defects are
  * converted to thrown Errors (what pi's tool contract expects); interruption
@@ -60,9 +63,13 @@ export async function runTool<A, E>(
     options.signal ? { signal: options.signal } : undefined,
   );
   if (Exit.isSuccess(exit)) return exit.value;
-  if (Cause.hasInterruptsOnly(exit.cause)) {
-    throw new Error(options.interruptMessage ?? "Operation was aborted.");
-  }
   const [first] = Cause.prettyErrors(exit.cause);
+  if (Cause.hasInterrupts(exit.cause)) {
+    const interrupted = options.interruptMessage ?? "Operation was aborted.";
+    const detail = Cause.hasInterruptsOnly(exit.cause)
+      ? ""
+      : ` ${first?.message ?? Cause.pretty(exit.cause)}`;
+    throw new SubagentToolInterruptedError(`${interrupted}${detail}`);
+  }
   throw new Error(first?.message ?? Cause.pretty(exit.cause));
 }

package/extensions/ui-customization/footer.ts

@@ -1,5 +1,5 @@
 import { homedir } from "node:os";
-import { relative } from "node:path";
+import { posix, win32 } from "node:path";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import {
   getCapabilities,
@@ -117,10 +117,21 @@ export function formatTokens(tokens: number) {
   return `${(tokens / 1_000_000).toFixed(1)}m`;
 }
 
-export function formatDirectory(cwd: string) {
-  const home = homedir();
-  if (cwd === home) return "~";
-  const display = cwd.startsWith(`${home}/`) ? `~/${relative(home, cwd)}` : cwd;
+export function formatDirectory(
+  cwd: string,
+  home = homedir(),
+  pathModule = process.platform === "win32" ? win32 : posix,
+) {
+  const relativePath = pathModule.relative(home, cwd);
+  const outsideHome =
+    relativePath === ".." ||
+    relativePath.startsWith(`..${pathModule.sep}`) ||
+    pathModule.isAbsolute(relativePath);
+  const display = outsideHome
+    ? cwd
+    : relativePath
+      ? `~/${relativePath.replaceAll(pathModule.sep, "/")}`
+      : "~";
   return sanitizeTerminalLabel(display);
 }
 

package/extensions/user-input-fold/index.ts

@@ -40,8 +40,35 @@ type Segment =
   | { kind: "prose"; lines: string[] }
   | { kind: "code"; open: string; content: string[]; close: string };
 
-const FENCE_OPEN = /^ {0,3}`{3,}/;
-const FENCE_CLOSE = /^ {0,3}`{3,}[ \t]*\r?$/;
+const FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})/;
+
+/**
+ * Parse an opening code fence (CommonMark §4.5): which character it uses and
+ * how long it is. A backtick fence's info string may not contain backticks.
+ */
+function openFence(line: string) {
+  const match = FENCE_OPEN.exec(line);
+  if (!match) return undefined;
+  const fence = match[1];
+  if (fence[0] === "`" && line.slice(match[0].length).includes("`")) {
+    return undefined;
+  }
+  return { char: fence[0], length: fence.length };
+}
+
+/**
+ * A closing fence must use the same character as the opening fence and be at
+ * least as long: a ``` line does not close a ```` block, and backticks never
+ * close a tilde block.
+ */
+function isCloseFence(line: string, open: { char: string; length: number }) {
+  const match = /^ {0,3}(`{3,}|~{3,})[ \t]*\r?$/.exec(line);
+  return (
+    match !== null &&
+    match[1][0] === open.char &&
+    match[1].length >= open.length
+  );
+}
 
 function countLines(markdown: string) {
   const parts = markdown.split("\n");
@@ -60,7 +87,8 @@ function parseSegments(lines: string[]): Segment[] {
   let prose: string[] = [];
   let i = 0;
   while (i < lines.length) {
-    if (!FENCE_OPEN.test(lines[i])) {
+    const fence = openFence(lines[i]);
+    if (!fence) {
       prose.push(lines[i]);
       i += 1;
       continue;
@@ -74,13 +102,21 @@ function parseSegments(lines: string[]): Segment[] {
     let close: string | undefined;
     let j = i + 1;
     while (j < lines.length && close === undefined) {
-      if (FENCE_CLOSE.test(lines[j])) close = lines[j];
+      if (isCloseFence(lines[j], fence)) close = lines[j];
       else content.push(lines[j]);
       j += 1;
     }
     if (close === undefined) {
-      // Unterminated fence: fold the whole message conservatively as text.
-      return [{ kind: "prose", lines }];
+      // Unterminated fence: the block runs to the end of the message. Keep it
+      // as a code block with a synthesized closing fence so a folded preview
+      // never leaks an unclosed fence into the TUI.
+      segments.push({
+        kind: "code",
+        open,
+        content,
+        close: fence.char.repeat(fence.length),
+      });
+      return segments;
     }
     segments.push({ kind: "code", open, content, close });
     i = j;

package/extensions/web/index.ts

@@ -5,6 +5,11 @@ import type {
   ExtensionAPI,
   ExtensionCommandContext,
 } from "@earendil-works/pi-coding-agent";
+import {
+  missingPiCodingAgentDiagnostic,
+  PI_CODING_AGENT_ENTRY_ENV,
+  resolvePiCodingAgentEntry,
+} from "../../web/host/pi-coding-agent-entry.ts";
 
 const DEFAULT_SHUTDOWN_TIMEOUT_MS = 5_000;
 
@@ -26,12 +31,20 @@ interface SpawnWebOptions {
   stdio: "inherit";
 }
 
-function webProcessEnvironment(cwd: string) {
+function webProcessEnvironment(
+  cwd: string,
+  piCodingAgentEntry: string | undefined,
+) {
   const environment: NodeJS.ProcessEnv = { ...process.env, PWD: cwd };
   delete environment.OLDPWD;
   delete environment.INIT_CWD;
   delete environment.PI_SESSION_ID;
   delete environment.PI_SESSION_FILE;
+  if (piCodingAgentEntry) {
+    environment[PI_CODING_AGENT_ENTRY_ENV] = piCodingAgentEntry;
+  } else {
+    delete environment[PI_CODING_AGENT_ENTRY_ENV];
+  }
   return environment;
 }
 
@@ -40,6 +53,7 @@ export interface WebCommandDependencies {
   spawn(command: string, args: string[], options: SpawnWebOptions): WebProcess;
   clearTerminal(): void;
   holdParentSigint(): () => void;
+  resolvePiCodingAgentEntry(): string | undefined;
   shutdownTimeoutMs: number;
 }
 
@@ -65,6 +79,8 @@ const defaultDependencies: WebCommandDependencies = {
     process.on("SIGINT", keepPiAlive);
     return () => process.removeListener("SIGINT", keepPiAlive);
   },
+  resolvePiCodingAgentEntry: () =>
+    resolvePiCodingAgentEntry({ source: "host" }),
   shutdownTimeoutMs: DEFAULT_SHUTDOWN_TIMEOUT_MS,
 };
 
@@ -95,6 +111,7 @@ function runWebInForeground(
   dependencies: WebCommandDependencies,
   setActive: (active: ActiveWebProcess | undefined) => void,
   isShuttingDown: () => boolean,
+  piCodingAgentEntry: string,
 ) {
   return ctx.ui.custom<WebExit>((tui, _theme, _keybindings, done) => {
     let finished = false;
@@ -128,7 +145,7 @@ function runWebInForeground(
         [dependencies.entrypoint, "web", "--no-workspace"],
         {
           cwd: childCwd,
-          env: webProcessEnvironment(childCwd),
+          env: webProcessEnvironment(childCwd, piCodingAgentEntry),
           shell: false,
           stdio: "inherit",
         },
@@ -191,6 +208,11 @@ export default function web(
         ctx.ui.notify("OpenPI Web Workbench is already running.", "warning");
         return;
       }
+      const piCodingAgentEntry = dependencies.resolvePiCodingAgentEntry();
+      if (!piCodingAgentEntry) {
+        ctx.ui.notify(missingPiCodingAgentDiagnostic(), "error");
+        return;
+      }
 
       running = true;
       try {
@@ -201,6 +223,7 @@ export default function web(
             active = next;
           },
           () => shuttingDown,
+          piCodingAgentEntry,
         );
         if (shuttingDown) return;
         if (result.kind === "error") {

package/extensions/workflows/acceptance.ts

@@ -22,6 +22,25 @@ export interface AcceptanceLedger {
   readonly status: "accepted" | "rejected" | "missing" | "malformed";
   readonly criteria: readonly AcceptanceCriterionResult[];
   readonly errors: readonly string[];
+  /** Child-authored judgment retained only for migration; never a runtime fact. */
+  readonly authority?: "model-self-attestation";
+  readonly deprecated?: {
+    readonly since: "0.5";
+    readonly removal: "1.0";
+  };
+}
+
+export const ACCEPTANCE_DEPRECATION_WARNING =
+  "acceptance is deprecated since OpenPI 0.5 and will be removed in 1.0; it is model self-attestation, not runtime-verified evidence, and does not determine ok";
+
+function ledger(
+  value: Omit<AcceptanceLedger, "authority" | "deprecated">,
+): AcceptanceLedger {
+  return {
+    ...value,
+    authority: "model-self-attestation",
+    deprecated: { since: "0.5", removal: "1.0" },
+  };
 }
 
 const ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
@@ -169,6 +188,12 @@ export function isAcceptanceLedger(value: unknown): value is AcceptanceLedger {
       value.status === "rejected" ||
       value.status === "missing" ||
       value.status === "malformed") &&
+    (value.authority === undefined ||
+      value.authority === "model-self-attestation") &&
+    (value.deprecated === undefined ||
+      (record(value.deprecated) &&
+        value.deprecated.since === "0.5" &&
+        value.deprecated.removal === "1.0")) &&
     value.errors.every((error) => typeof error === "string") &&
     value.criteria.every(
       (criterion) =>
@@ -187,7 +212,7 @@ export function acceptanceInstruction(contract: AcceptanceContract) {
       `- ${criterion.id}: ${criterion.description}${criterion.requiredEvidence?.length ? `; required evidence labels: ${criterion.requiredEvidence.join(", ")}` : ""}`,
   );
   return [
-    "Acceptance is explicit evidence, not a self-awarded success claim.",
+    "Deprecated compatibility protocol: this acceptance ledger is your own model self-attestation, not runtime-verified evidence, and it does not determine execution success.",
     "Include an `acceptance.criteria` array in structured_output with exactly these ids. Mark rejected when the criterion is not demonstrated. Evidence entries must be concise labels or concrete references; do not invent evidence.",
     ...criteria,
   ].join("\n");
@@ -198,19 +223,19 @@ export function evaluateAcceptance(
   structured: unknown,
 ): AcceptanceLedger {
   if (!record(structured) || !record(structured.acceptance)) {
-    return {
+    return ledger({
       status: "missing",
       criteria: [],
       errors: ["structured result omitted acceptance"],
-    };
+    });
   }
   const rawCriteria = structured.acceptance.criteria;
   if (!Array.isArray(rawCriteria)) {
-    return {
+    return ledger({
       status: "malformed",
       criteria: [],
       errors: ["acceptance.criteria is not an array"],
-    };
+    });
   }
   const errors: string[] = [];
   const byId = new Map<string, AcceptanceCriterionResult>();
@@ -265,14 +290,15 @@ export function evaluateAcceptance(
       errors.push(`unexpected acceptance criterion "${id}"`);
     }
   }
-  if (errors.length) return { status: "malformed", criteria: results, errors };
-  return {
+  if (errors.length)
+    return ledger({ status: "malformed", criteria: results, errors });
+  return ledger({
     status: results.every((result) => result.status === "accepted")
       ? "accepted"
       : "rejected",
     criteria: results,
     errors: [],
-  };
+  });
 }
 
 export function applyAcceptance(options: {
@@ -284,15 +310,13 @@ export function applyAcceptance(options: {
   const ledger = options.contract
     ? evaluateAcceptance(options.contract, options.structured)
     : undefined;
-  const acceptanceError =
-    ledger && ledger.status !== "accepted"
-      ? `Acceptance ${ledger.status}${ledger.errors.length ? `: ${ledger.errors.join("; ")}` : ": one or more criteria were rejected"}`
-      : undefined;
-  const ok = options.agentOk && !acceptanceError;
-  const error = ok
-    ? undefined
-    : options.agentError
-      ? `${options.agentError}${acceptanceError ? `; ${acceptanceError}` : ""}`
-      : (acceptanceError ?? "Agent failed");
-  return { ok, ...(ledger ? { ledger } : {}), ...(error ? { error } : {}) };
+  const ok = options.agentOk;
+  const error = ok ? undefined : (options.agentError ?? "Agent failed");
+  return {
+    ok,
+    ...(ledger
+      ? { ledger, acceptanceWarning: ACCEPTANCE_DEPRECATION_WARNING }
+      : {}),
+    ...(error ? { error } : {}),
+  };
 }

package/extensions/workflows/completion-projection.ts

@@ -230,7 +230,9 @@ function buildOperatorReport(
               : "running";
       lines.push(
         `- [${agent.label}]${agent.phase ? ` (${agent.phase})` : ""} ${state}` +
-          (agent.acceptance ? ` · acceptance ${agent.acceptance.status}` : "") +
+          (agent.acceptance
+            ? ` · deprecated model self-attestation ${agent.acceptance.status}`
+            : "") +
           (agent.error ? ` — ${agent.error}` : ""),
       );
     }

package/extensions/workflows/dashboard.ts

@@ -143,18 +143,54 @@ export function readPersistedWorkflowDetails(
   runId: string,
   options: ReadPersistedRunOptions = {},
 ): WorkflowDetails | undefined {
-  let details: WorkflowDetails | undefined;
+  const details = normalizeReadRecord(
+    runId,
+    readPersistedWorkflowRecord(runId),
+  );
+  if (!details) return undefined;
+  if (options.hydrateArtifacts) hydrateRunArtifacts(runId, details);
+  return details;
+}
+
+function normalizeReadRecord(runId: string, raw: unknown) {
+  try {
+    return normalizePersistedWorkflowDetails(runId, raw);
+  } catch {
+    return undefined;
+  }
+}
+
+function readPersistedWorkflowRecord(runId: string) {
   try {
     const raw: unknown = JSON.parse(
       fs.readFileSync(path.join(runsDir(), runId, "workflow.json"), "utf8"),
     );
-    details = normalizePersistedWorkflowDetails(runId, raw);
+    return raw && typeof raw === "object"
+      ? (raw as Record<string, unknown>)
+      : undefined;
   } catch {
     return undefined;
   }
-  if (!details) return undefined;
-  if (options.hydrateArtifacts) hydrateRunArtifacts(runId, details);
-  return details;
+}
+
+function matchesRunScope(
+  record: { startedAt?: unknown; finishedAt?: unknown; sessionId?: unknown },
+  runId: string,
+  sessionId: string,
+  referencedRunIds: ReadonlySet<string>,
+  startedSince: number,
+  fromRetention = false,
+) {
+  const touchedAt = Math.max(
+    typeof record.startedAt === "number" ? record.startedAt : 0,
+    typeof record.finishedAt === "number" ? record.finishedAt : 0,
+  );
+  return (
+    touchedAt >= startedSince &&
+    (fromRetention ||
+      record.sessionId === sessionId ||
+      referencedRunIds.has(runId))
+  );
 }
 
 function isWorktreeCleanup(
@@ -220,6 +256,14 @@ function normalizeDelivery(value: unknown): WorkflowDetails["delivery"] {
       : 0;
   return {
     id: sanitizeLine(record.id, 256),
+    ...(typeof record.ownerSessionId === "string" && record.ownerSessionId
+      ? { ownerSessionId: sanitizeLine(record.ownerSessionId, 256) }
+      : {}),
+    ...(typeof record.ownerEpoch === "number" &&
+    Number.isSafeInteger(record.ownerEpoch) &&
+    record.ownerEpoch >= 0
+      ? { ownerEpoch: record.ownerEpoch }
+      : {}),
     state,
     attempts,
     updatedAt,
@@ -573,27 +617,41 @@ export function loadRunEntries(
   retained: ReadonlyMap<string, WorkflowDetails> = new Map(),
 ): RunEntry[] {
   const entries: RunEntry[] = [];
-  const runIds = new Set([...listPersistedRunIds(), ...retained.keys()]);
+  const runIds = new Set([
+    ...listPersistedRunIds(),
+    ...retained.keys(),
+    ...active.keys(),
+  ]);
   for (const runId of runIds) {
     const live = active.get(runId);
     if (live) {
       entries.push({ runId, details: live, live: true });
       continue;
     }
-    const persisted = readPersistedWorkflowDetails(runId, {
-      hydrateArtifacts: true,
-    });
+    // Reject unrelated history before normalizing potentially large inline
+    // transcripts. Side artifacts belong to explicit detail navigation.
+    const raw = readPersistedWorkflowRecord(runId);
+    if (
+      raw &&
+      !matchesRunScope(raw, runId, sessionId, referencedRunIds, startedSince)
+    ) {
+      continue;
+    }
+    const persisted = normalizeReadRecord(runId, raw);
     const retainedDetails = retained.get(runId);
     const details = persisted ?? retainedDetails;
     if (!details) continue;
     const fromRetention =
       persisted === undefined && retainedDetails !== undefined;
-    const touchedAt = Math.max(details.startedAt, details.finishedAt ?? 0);
     if (
-      touchedAt < startedSince ||
-      (!fromRetention &&
-        details.sessionId !== sessionId &&
-        !referencedRunIds.has(runId))
+      !matchesRunScope(
+        details,
+        runId,
+        sessionId,
+        referencedRunIds,
+        startedSince,
+        fromRetention,
+      )
     ) {
       continue;
     }
@@ -710,6 +768,9 @@ type DetailFocus = "phases" | "agents";
 export class WorkflowDashboard {
   private view: View = "list";
   private entries: RunEntry[] = [];
+  private historyLoaded = false;
+  private seenRetainedRunIds = new Set<string>();
+  private hydratedRunIds = new Set<string>();
   private listIndex = 0;
   private phaseIndex = 0;
   private agentIndex = 0;
@@ -818,13 +879,68 @@ export class WorkflowDashboard {
 
   private refresh() {
     const selected = this.entries[this.listIndex]?.runId;
-    this.entries = loadRunEntries(
-      this.getActive(),
-      this.sessionId,
-      this.referencedRunIds,
-      this.startedSince,
-      this.getRetained(),
-    );
+    const active = this.getActive();
+    const retained = this.getRetained();
+    if (!this.historyLoaded) {
+      this.entries = loadRunEntries(
+        active,
+        this.sessionId,
+        this.referencedRunIds,
+        this.startedSince,
+        retained,
+      );
+      this.historyLoaded = true;
+    } else {
+      // Animation ticks reuse historical projections. Only a newly settled run
+      // needs one canonical read; stable frames never scan or reread history.
+      const entries = new Map(
+        this.entries.map((entry) => [entry.runId, entry]),
+      );
+      const settledIds = new Set([
+        ...this.entries
+          .filter((entry) => entry.live && !active.has(entry.runId))
+          .map((entry) => entry.runId),
+        ...[...retained.keys()].filter(
+          (runId) =>
+            !this.seenRetainedRunIds.has(runId) &&
+            !entries.has(runId) &&
+            !active.has(runId),
+        ),
+      ]);
+      for (const runId of settledIds) {
+        const persisted = readPersistedWorkflowDetails(runId);
+        const details =
+          persisted ?? retained.get(runId) ?? entries.get(runId)?.details;
+        if (!details) continue;
+        if (
+          !matchesRunScope(
+            details,
+            runId,
+            this.sessionId,
+            this.referencedRunIds,
+            this.startedSince,
+            !persisted,
+          )
+        ) {
+          entries.delete(runId);
+          continue;
+        }
+        // Recovery operates on a projection, never on the former live owner.
+        const recovered = recoverStaleWorkflowDetails({
+          ...details,
+          agents: details.agents.map((agent) => ({ ...agent })),
+        });
+        entries.set(runId, { runId, details: recovered, live: false });
+        this.hydratedRunIds.delete(runId);
+      }
+      for (const [runId, details] of active) {
+        entries.set(runId, { runId, details, live: true });
+      }
+      this.entries = [...entries.values()].sort(
+        (a, b) => b.details.startedAt - a.details.startedAt,
+      );
+    }
+    for (const runId of retained.keys()) this.seenRetainedRunIds.add(runId);
     if (selected) {
       const index = this.entries.findIndex((e) => e.runId === selected);
       if (index >= 0) this.listIndex = index;
@@ -839,6 +955,7 @@ export class WorkflowDashboard {
       );
       if (refreshed) this.current = refreshed;
     }
+    if (this.view === "transcript") this.hydrateCurrent();
     if (this.notice && Date.now() - this.noticeAt > NOTICE_TTL_MS)
       this.notice = undefined;
   }
@@ -874,7 +991,15 @@ export class WorkflowDashboard {
     this.agentIndex = Math.min(this.agentIndex, Math.max(0, agents.length - 1));
   }
 
+  private hydrateCurrent() {
+    const entry = this.current;
+    if (!entry || entry.live || this.hydratedRunIds.has(entry.runId)) return;
+    hydrateRunArtifacts(entry.runId, entry.details);
+    this.hydratedRunIds.add(entry.runId);
+  }
+
   private saveReport() {
+    this.hydrateCurrent();
     const entry = this.current;
     if (!entry) return;
     const target = path.join(runsDir(), entry.runId, "report.md");
@@ -1015,6 +1140,7 @@ export class WorkflowDashboard {
   }
 
   private openTranscriptPage() {
+    this.hydrateCurrent();
     const transcriptAdapter = new WorkflowTranscriptAdapter();
     this.view = "transcript";
     this.transcriptPage = new AgentSessionPage(