@yaag/extension 0.5.2 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yaag/extension",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "publishConfig": {
     "access": "public"
   },
@@ -24,9 +24,9 @@
   },
   "dependencies": {
     "@earendil-works/pi-tui": "^0.84.0",
-    "@yaag/cli": "0.5.2",
-    "@yaag/runtime": "0.5.2",
-    "@yaag/tui": "0.5.2",
+    "@yaag/cli": "0.6.0",
+    "@yaag/runtime": "0.6.0",
+    "@yaag/tui": "0.6.0",
     "nanoid": "^6.0.1"
   },
   "peerDependencies": {

package/src/index.ts

@@ -35,7 +35,6 @@ export default async function (pi: ExtensionAPI): Promise<void> {
   // One registry per session, mirrored to a durable store so a restart of this
   // Host Session keeps every Run id addressable (ticket 02).
   const registry = new RunRegistry({ store: new RunStore() });
-  await registry.restore();
   // The renderer projections and the background footer segment both live for
   // the session, beside the registry, so a background Run keeps a tree.
   const store = new RunTreeStore();
@@ -56,9 +55,13 @@ export default async function (pi: ExtensionAPI): Promise<void> {
   const appendYaagPrompt = createSystemPromptAppender(() => findProgramDirectories(process.cwd()));
   pi.on("before_agent_start", (event) => appendYaagPrompt(event));
 
-  pi.on("session_start", (_event, ctx) => {
+  pi.on("session_start", async (_event, ctx) => {
     if (bun === null) ctx.ui.notify(report, "error");
     if (ctx.hasUI) status.bind(ctx.ui);
+    // The pi session id is knowable only here, and `/resume` rebinds this
+    // extension and fires the same id, which is what re-adopts this session's
+    // Runs. A fork arrives with a new id and adopts nothing (ADR-0036).
+    await registry.restore(ctx.sessionManager.getSessionId());
   });
 
   // Commands and tools have separate namespaces: this CLI-resolution command

package/src/restored-run-text.ts

@@ -0,0 +1,77 @@
+/**
+ * The words a Run read back from its record gets, shared by `yaag_status` and
+ * the `/yaag` snapshot view (ADR-0036). A resumed session owns such a Run again
+ * when the record names it, but no session is attached to it: there is no event
+ * stream and no renderer projection, only the persisted Summary. Pure text, no
+ * I/O.
+ */
+import type { RunViewResult } from "@yaag/tui";
+import type { RunRecord } from "./run-record.ts";
+
+/**
+ * States the persisted verdict of a Run that no process is attached to.
+ *
+ * The folded Summary alone cannot say that the Run stopped without an owner
+ * process, or that a Checkpoint of it can be resumed (ticket 02), so the state,
+ * the surviving process, and the resume call are stated here.
+ */
+export function restoredStateText(record: RunRecord): string {
+  const state = `Run ${record.id} is ${record.state} (started ${record.startedAt}).`;
+  const alive =
+    record.state === "orphaned" && record.process !== null
+      ? ` Its process ${record.process.pid} is still running; stop it with yaag_stop.`
+      : "";
+  return `${state}${alive}${resumeHint(record)}`;
+}
+
+/**
+ * The frozen Result region of a restored Run, for the read-only `/yaag` view.
+ *
+ * Every restored Run states its persisted verdict first, whatever its outcome:
+ * the reader opened a snapshot of a record, which no live Run feeds any more,
+ * and the value or the error alone does not say so (ADR-0036).
+ */
+export function restoredViewResult(record: RunRecord): RunViewResult {
+  const state = restoredStateText(record);
+  const { outcome } = record;
+  if (outcome?.kind === "fulfilled")
+    return { kind: "fulfilled", result: joinText(state, outcome.result) };
+  if (outcome?.kind === "rejected")
+    return { kind: "failed", error: joinText(state, outcome.reason) };
+  return { kind: "failed", error: state };
+}
+
+function joinText(state: string, detail: string): string {
+  return detail.trim() === "" ? state : `${state}\n${detail}`;
+}
+
+/**
+ * Names the Checkpoint an unowned Run left behind (ADR-0031), and the call that
+ * resumes it. The Run republishes the Checkpoint at each Ask boundary, so it
+ * exists whenever the Run reached one, for a dead Run and for a still-running
+ * orphan alike.
+ *
+ * The hint names the Checkpoint path and never the stored program source: the
+ * path is enough, because yaag reads the source back from the Run record
+ * (ADR-0033). A whole source here would flood the transcript and repeat a
+ * private text the record already holds.
+ */
+function resumeHint(record: RunRecord): string {
+  const artifact = record.summary.artifact;
+  if (artifact === null || artifact === undefined) return "";
+  if (record.state !== "interrupted" && record.state !== "orphaned") return "";
+  // Each path becomes a JSON string literal: a path can hold a quote, a
+  // backslash, or a newline, and the hint must stay a call the model can copy.
+  const resume = JSON.stringify(artifact);
+  const { launch } = record;
+  switch (launch.kind) {
+    case "inline":
+      return ` Resume it with yaag_run({ resume: ${resume} }) and no file and no script; yaag reuses the program source it stored.`;
+    case "file":
+      return ` Resume it with yaag_run({ file: ${JSON.stringify(launch.file)}, resume: ${resume} }).`;
+    default: {
+      const never: never = launch;
+      return never;
+    }
+  }
+}

package/src/run-listing.ts

@@ -0,0 +1,33 @@
+/**
+ * The one bound both Run listings share: the `/yaag` picker and the
+ * `yaag_status` overview must agree on which Runs exist (ADR-0036).
+ */
+import type { DatedRun, RegisteredRun } from "./run-registry.ts";
+
+/** How many Runs the `/yaag` picker and the `yaag_status` overview list. */
+export const RUN_LISTING_CAP = 5;
+
+/**
+ * The newest `cap` Runs, newest first, plus every live Run whatever its age.
+ *
+ * A live Run is exempt from the cap: the session must always see and stop what
+ * it runs (ADR-0036). Runs that start at the same instant keep registration
+ * order.
+ */
+export function boundedRuns(
+  runs: readonly DatedRun[],
+  cap: number = RUN_LISTING_CAP,
+): readonly RegisteredRun[] {
+  const newestFirst = [...runs.entries()].sort(compareNewestFirst).map(([, run]) => run);
+  return newestFirst
+    .filter((run, rank) => rank < cap || run.entry.state === "live")
+    .map((run) => run.entry);
+}
+
+function compareNewestFirst(
+  left: readonly [number, DatedRun],
+  right: readonly [number, DatedRun],
+): number {
+  if (left[1].startedAt === right[1].startedAt) return left[0] - right[0];
+  return left[1].startedAt < right[1].startedAt ? 1 : -1;
+}

package/src/run-picker.ts

@@ -3,21 +3,28 @@
  * the list can be tested without a live UI.
  */
 import type { RunSummary } from "@yaag/runtime";
-import type { RegisteredRun } from "./run-registry.ts";
+import { boundedRuns } from "./run-listing.ts";
+import type { DatedRun } from "./run-registry.ts";
 
 /** One Run the picker can open: its id, latest Summary fold, and liveness. */
 export interface PickableRun {
   readonly id: string;
   readonly summary: RunSummary;
   readonly live: boolean;
+  /** A Run an earlier session started; the view of it is a frozen snapshot. */
+  readonly restored: boolean;
 }
 
-/** Every registered Run, live and finished, in registration order. */
-export function pickableRuns(runs: readonly RegisteredRun[]): readonly PickableRun[] {
-  return runs.map((run) => ({
+/**
+ * The Runs the picker lists: the bounded listing the `yaag_status` overview
+ * uses, so both surfaces agree on which Runs exist (ADR-0036).
+ */
+export function pickableRuns(runs: readonly DatedRun[]): readonly PickableRun[] {
+  return boundedRuns(runs).map((run) => ({
     id: run.run.id,
     summary: run.run.summary,
     live: run.state === "live",
+    restored: run.state === "restored",
   }));
 }
 

package/src/run-record.ts

@@ -40,6 +40,12 @@ export type RunLaunch =
 /** One Run as stored on disk, at `<runs dir>/<id>.json`. */
 export interface RunRecord {
   readonly id: string;
+  /**
+   * The pi session that started the Run. `null` for a record an older yaag
+   * wrote, or an unbound registry; such a record belongs to no session
+   * (ADR-0036).
+   */
+  readonly sessionId: string | null;
   readonly launch: RunLaunch;
   readonly process: ProcessIdentity | null;
   readonly startedAt: string;
@@ -81,6 +87,7 @@ export function parseRunRecord(value: unknown): RunRecord | null {
   // field a consumer reads has the type this parser proved (rule 0001 §3).
   return {
     id: candidate["id"],
+    sessionId: typeof candidate["sessionId"] === "string" ? candidate["sessionId"] : null,
     launch,
     process: identity,
     startedAt: candidate["startedAt"],
@@ -97,9 +104,11 @@ export function startedRecord(options: {
   readonly launch: RunLaunch;
   readonly process: ProcessIdentity | null;
   readonly now: string;
+  readonly sessionId?: string | null;
 }): RunRecord {
   return {
     id: options.id,
+    sessionId: options.sessionId ?? null,
     launch: options.launch,
     process: options.process,
     startedAt: options.now,

package/src/run-registry.ts

@@ -44,6 +44,12 @@ export type RegisteredRun =
 /** What the registry knows about an id. */
 export type RunStatus = RegisteredRun | { readonly state: "unknown" };
 
+/** A registered Run plus the start instant that orders a bounded listing. */
+export interface DatedRun {
+  readonly startedAt: string;
+  readonly entry: RegisteredRun;
+}
+
 /** How often a Run's latest Summary is persisted while it runs. */
 export const SUMMARY_WRITE_INTERVAL_MS = 2_000;
 
@@ -67,8 +73,11 @@ export class RunRegistry {
   readonly #records = new Map<string, RunRecord>();
   readonly #lastWrite = new Map<string, number>();
   readonly #trailing = new Map<string, ReturnType<typeof setTimeout>>();
+  readonly #startedAt = new Map<string, string>();
   readonly #store: RunStore | undefined;
   readonly #now: () => Date;
+  #sessionId: string | null = null;
+  #restoredFor: string | null | undefined = undefined;
 
   constructor(options: RunRegistryOptions = {}) {
     this.#store = options.store;
@@ -90,25 +99,72 @@ export class RunRegistry {
     return [...this.#runs.keys()];
   }
 
+  /** Every addressable Run with its start instant, in registration order. */
+  get datedRuns(): readonly DatedRun[] {
+    return [...this.#runs.entries()].map(([id, entry]) => ({
+      startedAt: this.#startedAt.get(id) ?? "",
+      entry,
+    }));
+  }
+
   /**
-   * Loads persisted Runs, settles the ones an earlier session left `live`, and
-   * seeds the still-unaccounted ones. Finished Runs of earlier sessions stay on
-   * disk and are reachable through {@link recall} by id.
+   * Binds this Host Session's pi session id, settles the Runs an earlier
+   * session left `live`, and adopts the ones this session owns (ADR-0036).
+   *
+   * Idempotent per session id: a second `session_start` with the same id (a
+   * `/reload`) adopts nothing again. A fork carries a new id and therefore
+   * adopts nothing; the parent's Runs stay reachable through {@link recall}.
    */
-  async restore(): Promise<void> {
+  async restore(sessionId?: string): Promise<void> {
+    const bound = sessionId ?? null;
+    if (this.#restoredFor === bound) return;
+    this.#sessionId = bound;
+    this.#restoredFor = bound;
     if (this.#store === undefined) return;
     const records = await restoreRecords({ store: this.#store, now: this.#now });
     for (const record of records) {
-      if (record.state !== "orphaned" && record.state !== "interrupted") continue;
+      // A Run of this process is never shadowed by its own persisted record.
+      if (this.#runs.has(record.id)) continue;
+      if (!this.#adoptable(record)) continue;
       this.#runs.set(record.id, { state: "restored", run: restored(record) });
+      this.#startedAt.set(record.id, record.startedAt);
     }
   }
 
+  /** Persisted Runs this overview does not list; addressable by id only. */
+  async unlistedRunCount(listed: readonly string[]): Promise<number> {
+    if (this.#store === undefined) return 0;
+    const shown = new Set(listed);
+    return (await this.#store.load()).filter((record) => !shown.has(record.id)).length;
+  }
+
+  /** Persisted finished Runs that another pi session owns. */
+  async finishedElsewhereCount(): Promise<number> {
+    if (this.#store === undefined) return 0;
+    return (await this.#store.load()).filter(
+      (record) =>
+        record.state === "finished" &&
+        (this.#sessionId === null || record.sessionId !== this.#sessionId),
+    ).length;
+  }
+
+  /**
+   * `restoreRecords` already settled every stale `live` record, so this check
+   * can never adopt a Run as live (ADR-0036).
+   */
+  #adoptable(record: RunRecord): boolean {
+    if (record.state === "orphaned" || record.state === "interrupted") return true;
+    return this.#sessionId !== null && record.sessionId === this.#sessionId;
+  }
+
   /** Registers a newly-started Run and synchronously observes its settlement. */
   add(run: LiveRun, launch?: RunLaunch, identity?: ProcessIdentity | null): void {
+    const startedAt = this.#now().toISOString();
+    this.#startedAt.set(run.id, startedAt);
     this.#live.set(run.id, run);
     this.#runs.set(run.id, { state: "live", run });
-    if (launch !== undefined) this.#persistStart(run.id, launch, identity ?? null);
+    if (launch !== undefined)
+      this.#persistStart({ id: run.id, launch, process: identity ?? null, now: startedAt });
     void run.outcome.then(
       (outcome) => this.finish(run.id, outcome),
       (reason: unknown) => this.reject(run.id, reason),
@@ -203,13 +259,16 @@ export class RunRegistry {
     this.#persistEnd(id, summary, outcome);
   }
 
-  #persistStart(id: string, launch: RunLaunch, identity: ProcessIdentity | null): void {
+  #persistStart(options: {
+    readonly id: string;
+    readonly launch: RunLaunch;
+    readonly process: ProcessIdentity | null;
+    readonly now: string;
+  }): void {
     if (this.#store === undefined) return;
     const store = this.#store;
-    this.#records.set(
-      id,
-      startedRecord({ id, launch, process: identity, now: this.#now().toISOString() }),
-    );
+    const id = options.id;
+    this.#records.set(id, startedRecord({ ...options, sessionId: this.#sessionId }));
     this.#persist(id);
     void store.prune();
   }

package/src/status-tool.ts

@@ -2,7 +2,8 @@ import type { AgentToolResult, ToolDefinition } from "@earendil-works/pi-coding-
 import type { RunSummary } from "@yaag/runtime";
 import { renderSnapshot, TreeState } from "@yaag/tui";
 import { Type } from "typebox";
-import type { RunRecord } from "./run-record.ts";
+import { restoredStateText } from "./restored-run-text.ts";
+import { boundedRuns, RUN_LISTING_CAP } from "./run-listing.ts";
 import type { RegisteredRun, RestoredRun, RunRegistry } from "./run-registry.ts";
 import { toUsage } from "./usage.ts";
 
@@ -33,18 +34,22 @@ const DESCRIPTION = [
   "resolves: a Run whose process died is reported as interrupted, and a Run whose",
   "process is still alive is reported as orphaned.",
   "",
-  "Without an id, lists this session's Runs plus every orphaned or interrupted",
-  "Run left by an earlier session.",
+  "Without an id, this tool lists the Runs of this session, and the orphaned or",
+  "interrupted Runs another session left. The list is bounded: it holds every",
+  `live Run, and then the newest Runs up to a total of ${RUN_LISTING_CAP}. An older Run stays`,
+  "on disk, and the last line of the list counts the Runs on disk. Give an id to",
+  "see one of them.",
   "",
   "An interrupted inline Run resumes with `resume` alone: yaag reads the program",
   "source from its own Run record.",
 ].join("\n");
 
 /**
- * The `yaag_status` tool renders session-local Run snapshots for the model.
+ * The `yaag_status` tool renders Run snapshots for the model.
  *
- * Throws if an id was not started in this session; finished Runs remain
- * queryable and are never restarted or controlled by this tool.
+ * An id resolves through {@link RunRegistry.recall}, so a Run of any session is
+ * queryable while its record is on disk; only an id no record holds throws.
+ * The tool never restarts or controls a Run.
  */
 export function createStatusTool(
   registry: RunRegistry,
@@ -58,7 +63,7 @@ export function createStatusTool(
     description: DESCRIPTION,
     parameters,
     async execute(_id, params) {
-      if (params.id === undefined) return overview(registry.runs, now, width);
+      if (params.id === undefined) return await overview(registry, now, width);
       const found = await registry.recall(params.id);
       if (found.state === "unknown") throw unknownId(params.id, registry.knownIds);
       const details = detailsFor(found);
@@ -71,25 +76,40 @@ export function createStatusTool(
   };
 }
 
-function overview(
-  runs: readonly RegisteredRun[],
+/**
+ * Lists the Runs of this session, bounded by {@link RUN_LISTING_CAP}.
+ *
+ * The disk counts are read on each call: the store holds dozens of small files
+ * and a stale count would name Runs that no longer exist (ADR-0036).
+ */
+async function overview(
+  registry: RunRegistry,
   now: () => number,
   width: number,
-): AgentToolResult<StatusDetails> {
-  if (runs.length === 0)
-    return {
-      content: [{ type: "text", text: "No Runs started this session." }],
-      details: { summary: undefined },
-    };
-  return {
-    content: [
-      {
-        type: "text",
-        text: runs.map((run) => snapshot(detailsFor(run), now, width, true)).join("\n"),
-      },
-    ],
-    details: { summary: undefined },
-  };
+): Promise<AgentToolResult<StatusDetails>> {
+  const shown = boundedRuns(registry.datedRuns);
+  if (shown.length === 0) return text(emptyOverview(await registry.finishedElsewhereCount()));
+  const lines = shown.map((run) => snapshot(detailsFor(run), now, width, true));
+  const unlisted = await registry.unlistedRunCount(shown.map((run) => run.run.id));
+  if (unlisted > 0) lines.push(overflowLine(shown.length, unlisted));
+  return text(lines.join("\n"));
+}
+
+function text(value: string): AgentToolResult<StatusDetails> {
+  return { content: [{ type: "text", text: value }], details: { summary: undefined } };
+}
+
+/** The confirmed empty-overview copy of the specification, with its count. */
+function emptyOverview(elsewhere: number): string {
+  if (elsewhere === 0) return "No Runs in this session.";
+  const runs = elsewhere === 1 ? "Run" : "Runs";
+  const verb = elsewhere === 1 ? "is" : "are";
+  return `No Runs in this session. ${elsewhere} finished ${runs} from other sessions ${verb} on disk; query one with yaag_status({ id }).`;
+}
+
+/** The confirmed overflow copy of the specification, with its two counts. */
+function overflowLine(shown: number, unlisted: number): string {
+  return `${shown} shown; ${unlisted} more on disk \u2014 query one with yaag_status({ id })`;
 }
 
 function detailsFor(run: RegisteredRun): SnapshotDetails {
@@ -106,51 +126,19 @@ function detailsFor(run: RegisteredRun): SnapshotDetails {
 }
 
 /**
- * A Run of an earlier Host Session. Its persisted state is stated in the
- * Result region, because the folded Summary alone cannot say that nobody owns
- * the Run any more (ticket 02).
+ * A Run read back from its record: this session may own it again, but nothing
+ * is attached to it. Its persisted state is stated in the Result region,
+ * because the folded Summary alone cannot say that the snapshot is final and
+ * that no process feeds it (ticket 02, ADR-0036).
  */
 function restoredDetails(run: RestoredRun): SnapshotDetails {
   const { record } = run;
-  const state = `Run ${record.id} is ${record.state} (started ${record.startedAt}).`;
-  const alive =
-    record.state === "orphaned" && record.process !== null
-      ? ` Its process ${record.process.pid} is still running; stop it with yaag_stop.`
-      : "";
-  const detail = `${alive}${resumeHint(record)}`;
   const result = record.outcome?.kind === "fulfilled" ? `\n${record.outcome.result}` : "";
-  return { id: record.id, summary: run.summary, result: `${state}${detail}${result}` };
-}
-
-/**
- * Names the Checkpoint an unowned Run left behind (ADR-0031), and the call that
- * resumes it. The Run republishes the Checkpoint at each Ask boundary, so it
- * exists whenever the Run reached one, for a dead Run and for a still-running
- * orphan alike.
- *
- * The hint names the Checkpoint path and never the stored program source: the
- * path is enough, because yaag reads the source back from the Run record
- * (ADR-0033). A whole source here would flood the transcript and repeat a
- * private text the record already holds.
- */
-function resumeHint(record: RunRecord): string {
-  const artifact = record.summary.artifact;
-  if (artifact === null || artifact === undefined) return "";
-  if (record.state !== "interrupted" && record.state !== "orphaned") return "";
-  // Each path becomes a JSON string literal: a path can hold a quote, a
-  // backslash, or a newline, and the hint must stay a call the model can copy.
-  const resume = JSON.stringify(artifact);
-  const { launch } = record;
-  switch (launch.kind) {
-    case "inline":
-      return ` Resume it with yaag_run({ resume: ${resume} }) and no file and no script; yaag reuses the program source it stored.`;
-    case "file":
-      return ` Resume it with yaag_run({ file: ${JSON.stringify(launch.file)}, resume: ${resume} }).`;
-    default: {
-      const never: never = launch;
-      return never;
-    }
-  }
+  return {
+    id: record.id,
+    summary: run.summary,
+    result: `${restoredStateText(record)}${result}`,
+  };
 }
 
 function snapshot(

package/src/stop-tool.ts

@@ -67,8 +67,8 @@ function agentStateReport(agent: RunSummary["agents"][string]): string {
 }
 
 /**
- * Ends a Run nobody owns any more. There is no reap ladder to run — its pipes
- * belong to a dead Host Session — so the process group is killed outright
+ * Ends a Run no process is attached to. There is no reap ladder to run — its
+ * pipes belong to a dead Host Session — so the process group is killed outright
  * (ADR-0008). The pid is re-probed first, because a record can name a pid that
  * a different process has since inherited (ticket 02).
  */

package/src/yaag-command.ts

@@ -14,6 +14,7 @@ import type {
   RegisteredCommand,
 } from "@earendil-works/pi-coding-agent";
 import { createRunTreeView, type RunTreeViewHost, type RunViewResult, TreeState } from "@yaag/tui";
+import { restoredViewResult } from "./restored-run-text.ts";
 import { type PickableRun, pickableRuns, runFromLabel, runPickerLabel } from "./run-picker.ts";
 import type { RunRegistry, RunSettlement } from "./run-registry.ts";
 import { observedSettlement, viewResult } from "./run-settlement.ts";
@@ -53,9 +54,9 @@ export function createYaagCommand(options: YaagCommandOptions): CommandOptions {
  * not the TUI, or when the reader cancels the picker.
  */
 export async function runYaagCommand(ctx: YaagContext, options: YaagCommandOptions): Promise<void> {
-  const runs = pickableRuns(options.registry.runs);
+  const runs = pickableRuns(options.registry.datedRuns);
   if (runs.length === 0) {
-    ctx.ui.notify("yaag: no Runs started this session.", "info");
+    ctx.ui.notify("yaag: no Runs in this session.", "info");
     return;
   }
   if (ctx.mode !== "tui") {
@@ -87,8 +88,13 @@ async function openRun(
   run: PickableRun,
   options: YaagCommandOptions,
 ): Promise<void> {
-  const state = options.store.get(run.id) ?? TreeState.fromSummary(run.summary);
   const found = options.registry.lookup(run.id);
+  // A Run of an earlier session has no projection here, so its view is built
+  // from the persisted Summary alone (ADR-0036).
+  const state =
+    found.state === "restored"
+      ? TreeState.fromSummary(run.summary)
+      : (options.store.get(run.id) ?? TreeState.fromSummary(run.summary));
   let unsubscribe: (() => void) | undefined;
   // The observer below outlives no more than the `ctx.ui.custom()` call: once
   // the view exits or the UI call rejects, a later settlement must touch
@@ -98,6 +104,8 @@ async function openRun(
     await ctx.ui.custom<void>((tui, _theme, keybindings, done) => {
       const host: RunTreeViewHost = {
         ...createRunTreeHost({ ui: ctx.ui, tui, keybindings, state }),
+        // A restored orphan is never re-attached, so there is nothing to stop
+        // from here; `yaag_stop` ends it (ADR-0036).
         stop: () => {
           if (found.state === "live") found.run.stop();
         },
@@ -105,8 +113,13 @@ async function openRun(
         // hand over, because a Run of this session is already addressable.
         done: () => done(),
       };
-      const view = createRunTreeView({ state, host, label: run.id });
-      if (found.state === "finished")
+      const view = createRunTreeView({
+        state,
+        host,
+        label: found.state === "restored" ? `${run.id} (restored)` : run.id,
+      });
+      if (found.state === "restored") view.settle(restoredViewResult(found.run.record));
+      else if (found.state === "finished")
         settle(state, view, found.run.outcome, options.registry, run.id);
       else if (found.state === "live") {
         unsubscribe = options.store.subscribe((id) => {