@ian-pascoe/pi-codemode 0.1.0 → 0.3.0

package/src/codemode-session-coordinator.ts

@@ -2,6 +2,7 @@ import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import type { Usage } from "@earendil-works/pi-ai";
 import { truncateHead } from "@earendil-works/pi-coding-agent";
 import { transformCodeModeCell } from "./codemode-cell-transform.js";
+import type { CodeModeConsoleEntry } from "./codemode-console-output.js";
 import { CodeModeWorkerProcess } from "./codemode-deno-process.js";
 import { formatCodeModePresentationData } from "./codemode-presentation-output.js";
 import type { CodeModeRuntime, CodeModeTimerHandle } from "./codemode-runtime.js";
@@ -35,9 +36,6 @@ const CODEMODE_RESULT_PRESENTATION_MAX_LINES = 2_000;
 const CODEMODE_WATCHDOG_GRACE_MS = 100;
 const INVALID_CODEMODE_SESSION_ID = "invalid-session-id";
 
-/** Branded identifier for one retained CodeMode Session. */
-export type CodeModeSessionId = string & { readonly CodeModeSessionId: unique symbol };
-
 /** Observer state of one settled CodeMode Cell. */
 export type CodeModeObservedCellState = "completed" | "failed" | "cancelled" | "timed_out";
 
@@ -70,7 +68,7 @@ export type CodeModeObservedLastCell = {
 
 /** Immutable read-only facts for one CodeMode Session with at least one Cell. */
 export type CodeModeObservedSession = {
-  readonly sessionId: CodeModeSessionId;
+  readonly sessionId: string;
   readonly lifecycle: "running" | "idle" | "terminal";
   /** Number of Cells started in this CodeMode Session. */
   readonly cell_count: number;
@@ -86,9 +84,18 @@ export type CodeModeObserverSnapshot = {
   readonly sessions: readonly CodeModeObservedSession[];
 };
 
+/** Read-only facts for one live CodeMode Session, ordered by admission priority. */
+export type CodeModeListedSession = {
+  readonly sessionId: string;
+  readonly state: "running" | "idle";
+  readonly cellCount: number;
+  /** Parent wall-clock time of the latest execution-visible transition in Unix-epoch milliseconds. */
+  readonly lastActivityAtMs: number;
+};
+
 /** One idle CodeMode worker failure not represented by an active Cell result. */
 export type CodeModeUnexpectedFailure = {
-  readonly sessionId: CodeModeSessionId;
+  readonly sessionId: string;
   readonly message: string;
 };
 
@@ -113,7 +120,7 @@ export type CodeModeNestedToolUpdate = AgentToolResult<unknown>;
 
 /** One complete guest batch plus its Cell-scoped cancellation and update capabilities. */
 export type CodeModeNestedToolBatch = {
-  readonly sessionId: CodeModeSessionId;
+  readonly sessionId: string;
   readonly batchId: string;
   readonly calls: readonly CodeModeNestedToolCall[];
   readonly signal: AbortSignal;
@@ -176,10 +183,16 @@ type MutableCodeModeOuterToolMetadata = {
   terminate?: boolean;
 };
 
+type CreateActiveCodeModeCellOptions = {
+  onUpdate?: (update: CodeModeNestedToolUpdate) => void;
+  reclaimedSessionId?: string;
+};
+
 type ActiveCodeModeCell = {
   readonly cellId: string;
   readonly ordinal: number;
   readonly startedAtMs: number;
+  readonly reclaimedSessionId?: string;
   readonly abortController: AbortController;
   readonly completion: Promise<CodeModeResult>;
   readonly resolveCompletion: (result: CodeModeResult) => void;
@@ -198,7 +211,7 @@ type ActiveCodeModeCell = {
 
 type LiveCodeModeSession = {
   readonly state: "live";
-  readonly sessionId: CodeModeSessionId;
+  readonly sessionId: string;
   readonly worker: CodeModeWorkerProcess;
   lastAccess: number;
   lastActivityAtMs: number;
@@ -212,7 +225,7 @@ type LiveCodeModeSession = {
 
 type TerminalCodeModeSession = {
   readonly state: "terminal";
-  readonly sessionId: CodeModeSessionId;
+  readonly sessionId: string;
   lastAccess: number;
   readonly lastActivityAtMs: number;
   readonly cellCount: number;
@@ -224,24 +237,53 @@ type TerminalCodeModeSession = {
 
 type CodeModeSessionRecord = LiveCodeModeSession | TerminalCodeModeSession;
 
-type LocateCodeModeSessionResult = {
-  readonly record?: CodeModeSessionRecord;
-  readonly failure: CodeModeResult;
-};
+type LocateCodeModeSessionResult =
+  | {
+      readonly record: CodeModeSessionRecord;
+      readonly reclaimedSessionId?: string;
+    }
+  | { readonly failure: CodeModeResult };
 
 type FatalCodeModeSessionFailure = {
   readonly code: Extract<CodeModeErrorCode, "timeout" | "cancellation" | "termination" | "runtime">;
   readonly message: string;
+  readonly console?: readonly CodeModeConsoleEntry[];
 };
 
-type ParseCodeModeSessionIdResult =
-  | { readonly ok: true; readonly value: CodeModeSessionId }
-  | { readonly ok: false };
+type ParsestringResult = { readonly ok: true; readonly value: string } | { readonly ok: false };
+
+function parsestring(value: string): ParsestringResult {
+  return value.length === 0 ? { ok: false } : { ok: true, value };
+}
+
+/** Return the shortest prefix of the identifier that no candidate shares. */
+export function shortestUniqueCodeModeSessionPrefix(
+  identifier: string,
+  candidates: readonly string[],
+): string {
+  let length = Math.min(8, identifier.length);
+  while (
+    length < identifier.length &&
+    candidates.some((candidate) => candidate.startsWith(identifier.slice(0, length)))
+  ) {
+    length += 1;
+  }
+  return identifier.slice(0, length);
+}
 
-function parseCodeModeSessionId(value: string): ParseCodeModeSessionIdResult {
-  if (value.length === 0) return { ok: false };
-  // SAFETY: This parser establishes the only CodeMode Session ID invariant (non-empty) before applying the domain brand.
-  return { ok: true, value: value as CodeModeSessionId };
+/** Render one elapsed duration as ms, seconds, or minutes + padded seconds. */
+export function formatCodeModeDuration(elapsedMs: number): string {
+  if (elapsedMs < 1_000) return `${elapsedMs}ms`;
+  if (elapsedMs < 60_000) return `${(elapsedMs / 1_000).toFixed(1)}s`;
+  const seconds = Math.floor(elapsedMs / 1_000);
+  return `${Math.floor(seconds / 60)}m ${String(seconds % 60).padStart(2, "0")}s`;
+}
+
+/** Round one elapsed measurement and clamp it to a safe non-negative integer. */
+export function boundedCodeModeElapsedMs(startedAtMs: number, observedAtMs: number): number {
+  const elapsed = Math.round(observedAtMs - startedAtMs);
+  if (!Number.isFinite(elapsed)) return 0;
+  return Math.min(Number.MAX_SAFE_INTEGER, Math.max(0, elapsed));
 }
 
 function invalidCodeModeSessionResult(): CodeModeSessionOperationResult {
@@ -258,12 +300,11 @@ function emptyMetadataAccumulator(): CodeModeMetadataAccumulator {
   return { addedToolNames: new Set(), terminate: false };
 }
 
-function combineCodeModeUsage(left: Usage | undefined, right: Usage): Usage {
+/** Sums two Usage values; optional fields appear only when either side carries them. */
+export function addCodeModeUsage(left: Usage | undefined, right: Usage | undefined): Usage {
+  if (right === undefined) throw new Error("Pi CodeMode usage: missing increment");
   if (left === undefined) {
-    return {
-      ...right,
-      cost: { ...right.cost },
-    };
+    return { ...right, cost: { ...right.cost } };
   }
   const combined: Usage = {
     input: left.input + right.input,
@@ -293,7 +334,7 @@ function mergeCodeModeOuterMetadata(
   metadata: CodeModeOuterToolMetadata,
 ): void {
   if (metadata.usage !== undefined) {
-    accumulator.usage = combineCodeModeUsage(accumulator.usage, metadata.usage);
+    accumulator.usage = addCodeModeUsage(accumulator.usage, metadata.usage);
   }
   for (const name of metadata.addedToolNames ?? []) accumulator.addedToolNames.add(name);
   if (metadata.terminate === true) accumulator.terminate = true;
@@ -314,7 +355,7 @@ function finalizeCodeModeMetadata(
 
 /** Owns bounded CodeMode Session records and one isolated Deno process per live Session. */
 export class CodeModeSessionCoordinator {
-  private readonly records = new Map<CodeModeSessionId, CodeModeSessionRecord>();
+  private readonly records = new Map<string, CodeModeSessionRecord>();
   private readonly runtime: CodeModeRuntime;
   private accessSequence = 0;
   private cellSequence = 0;
@@ -325,6 +366,7 @@ export class CodeModeSessionCoordinator {
     (update: CodeModeNestedToolUpdate) => void
   >();
   private readonly pendingProcessStops = new Set<Promise<void>>();
+  private admissionQueue: Promise<void> = Promise.resolve();
 
   /** Creates one coordinator from its Pi bridge, limits, and parent runtime capabilities. */
   constructor(private readonly options: CodeModeSessionCoordinatorOptions) {
@@ -339,7 +381,7 @@ export class CodeModeSessionCoordinator {
   ): Promise<CodeModeSessionOperationResult> {
     if (this.shuttingDown) {
       const candidateSessionId = input.sessionId ?? this.runtime.createSessionId();
-      const parsedSessionId = parseCodeModeSessionId(candidateSessionId);
+      const parsedSessionId = parsestring(candidateSessionId);
       if (!parsedSessionId.ok) return invalidCodeModeSessionResult();
       return {
         result: createCodeModeFailure(
@@ -349,76 +391,86 @@ export class CodeModeSessionCoordinator {
         ),
       };
     }
-    let located: LocateCodeModeSessionResult;
-    if (input.sessionId === undefined) located = this.createLiveSession();
-    else {
-      const parsedSessionId = parseCodeModeSessionId(input.sessionId);
-      if (!parsedSessionId.ok) return invalidCodeModeSessionResult();
-      located = this.findSession(parsedSessionId.value);
-    }
-    if (located.record === undefined) return { result: located.failure };
-    const record = located.record;
-    this.touch(record);
-    if (record.state === "terminal")
-      return this.operationResult(
-        record.latestResult,
-        this.takeMetadata(record),
-        record.latestPresentation,
-      );
-    if (record.currentCell !== undefined) {
-      return {
-        result: createCodeModeFailure(
-          record.sessionId,
-          "busy",
-          "CodeMode Session already has an active Cell",
-        ),
-      };
-    }
+    let releaseAdmission =
+      input.sessionId === undefined ? await this.acquireSessionAdmission() : undefined;
+    try {
+      let located: LocateCodeModeSessionResult;
+      if (input.sessionId === undefined) located = await this.createLiveSession();
+      else {
+        const parsedSessionId = parsestring(input.sessionId);
+        if (!parsedSessionId.ok) return invalidCodeModeSessionResult();
+        located = this.findSession(parsedSessionId.value);
+      }
+      if ("failure" in located) return { result: located.failure };
+      const record = located.record;
+      this.touch(record);
+      if (record.state === "terminal")
+        return this.operationResult(
+          record.latestResult,
+          this.takeMetadata(record),
+          record.latestPresentation,
+        );
+      if (record.currentCell !== undefined) {
+        return {
+          result: createCodeModeFailure(
+            record.sessionId,
+            "busy",
+            "CodeMode Session already has an active Cell",
+          ),
+        };
+      }
 
-    const shouldWait = input.wait !== false;
-    const cell = this.createActiveCell(
-      record,
-      shouldWait && onUpdate !== undefined ? { onUpdate } : {},
-    );
-    const priorMetadata = this.takeMetadata(record);
-    if (priorMetadata !== undefined) mergeCodeModeOuterMetadata(cell.metadata, priorMetadata);
-    record.currentCell = cell;
-    record.latestResult = createCodeModePending(record.sessionId);
-    record.lastActivityAtMs = cell.startedAtMs;
-    this.publishObserverSnapshot();
-    this.emitCellProgress(record, cell);
-    this.scheduleCellProgress(record, cell);
-    void this.startCell(record, cell, input);
+      const shouldWait = input.wait !== false;
+      const cellOptions: CreateActiveCodeModeCellOptions = {};
+      if (shouldWait && onUpdate !== undefined) cellOptions.onUpdate = onUpdate;
+      if (located.reclaimedSessionId !== undefined) {
+        cellOptions.reclaimedSessionId = located.reclaimedSessionId;
+      }
+      const cell = this.createActiveCell(record, cellOptions);
+      const priorMetadata = this.takeMetadata(record);
+      if (priorMetadata !== undefined) mergeCodeModeOuterMetadata(cell.metadata, priorMetadata);
+      record.currentCell = cell;
+      record.latestResult = createCodeModePending(record.sessionId);
+      record.lastActivityAtMs = cell.startedAtMs;
+      this.publishObserverSnapshot();
+      this.emitCellProgress(record, cell);
+      this.scheduleCellProgress(record, cell);
+      void this.startCell(record, cell, input);
+      releaseAdmission?.();
+      releaseAdmission = undefined;
 
-    const pending = createCodeModePending(record.sessionId);
-    if (!shouldWait) {
-      return this.operationResult(pending, undefined, this.runningCellPresentation(cell));
-    }
-    const abort = (): void => {
-      this.fatalizeSession(record, cell, {
-        code: "cancellation",
-        message: "CodeMode Cell was cancelled",
-      });
-    };
-    if (signal?.aborted === true) abort();
-    else signal?.addEventListener("abort", abort, { once: true });
-    try {
-      const result = await cell.completion;
-      const retainedRecord = this.records.get(record.sessionId) ?? record;
-      return this.operationResult(
-        result,
-        this.takeMetadata(retainedRecord),
-        retainedRecord.latestPresentation,
-      );
+      const pending = createCodeModePending(record.sessionId);
+      if (!shouldWait) {
+        return this.operationResult(pending, undefined, this.runningCellPresentation(cell));
+      }
+      const abort = (): void => {
+        this.fatalizeSession(record, cell, {
+          code: "cancellation",
+          message: "CodeMode Cell was cancelled",
+        });
+      };
+      if (signal?.aborted === true) abort();
+      else signal?.addEventListener("abort", abort, { once: true });
+      try {
+        const result = await cell.completion;
+        const retainedRecord = this.records.get(record.sessionId) ?? record;
+        return this.operationResult(
+          result,
+          this.takeMetadata(retainedRecord),
+          retainedRecord.latestPresentation,
+        );
+      } finally {
+        cell.acceptsUpdates = false;
+        signal?.removeEventListener("abort", abort);
+      }
     } finally {
-      cell.acceptsUpdates = false;
-      signal?.removeEventListener("abort", abort);
+      releaseAdmission?.();
     }
   }
 
   /** Polls the latest retained Cell result without consuming that public result. */
   result(sessionIdValue: string): CodeModeSessionOperationResult {
-    const parsedSessionId = parseCodeModeSessionId(sessionIdValue);
+    const parsedSessionId = parsestring(sessionIdValue);
     if (!parsedSessionId.ok) return invalidCodeModeSessionResult();
     const sessionId = parsedSessionId.value;
     const record = this.records.get(sessionId);
@@ -437,6 +489,26 @@ export class CodeModeSessionCoordinator {
     return this.operationResult(result, this.takeMetadata(record), record.latestPresentation);
   }
 
+  /** Lists all live Sessions with idle least-recently-used entries before running entries. */
+  listSessions(): readonly CodeModeListedSession[] {
+    const sessions = [...this.records.values()]
+      .filter((record): record is LiveCodeModeSession => record.state === "live")
+      .toSorted((left, right) => {
+        const stateOrder =
+          Number(left.currentCell !== undefined) - Number(right.currentCell !== undefined);
+        return stateOrder === 0 ? left.lastAccess - right.lastAccess : stateOrder;
+      })
+      .map((record) =>
+        Object.freeze({
+          sessionId: record.sessionId,
+          state: record.currentCell === undefined ? "idle" : "running",
+          cellCount: record.cellCount,
+          lastActivityAtMs: record.lastActivityAtMs,
+        } satisfies CodeModeListedSession),
+      );
+    return Object.freeze(sessions);
+  }
+
   /** Returns immutable, non-authoritative facts for the ephemeral CodeMode Observer UI. */
   inspectObserverSnapshot(): CodeModeObserverSnapshot {
     const sessions = [...this.records.values()]
@@ -447,25 +519,33 @@ export class CodeModeSessionCoordinator {
 
   /** Return the shortest currently unique Session prefix, or the full unknown historical ID. */
   formatSessionPrefix(sessionIdValue: string): string {
-    const parsed = parseCodeModeSessionId(sessionIdValue);
+    const parsed = parsestring(sessionIdValue);
     if (!parsed.ok || !this.records.has(parsed.value)) return sessionIdValue;
-    const sessionIds = [...this.records.keys()];
-    let length = Math.min(8, sessionIdValue.length);
-    while (
-      length < sessionIdValue.length &&
-      sessionIds.some(
-        (candidate) =>
-          candidate !== parsed.value && candidate.startsWith(sessionIdValue.slice(0, length)),
-      )
-    ) {
-      length += 1;
-    }
-    return sessionIdValue.slice(0, length);
+    const others = [...this.records.keys()].filter((candidate) => candidate !== parsed.value);
+    return shortestUniqueCodeModeSessionPrefix(sessionIdValue, others);
+  }
+
+  private closedCellPresentation(
+    cellState: CodeModePresentationSnapshot["cell_state"],
+  ): CodeModePresentationSnapshot {
+    return {
+      version: 1,
+      cell_state: cellState,
+      session_state: "closed",
+      elapsed_ms: 0,
+      active_tool_names: [],
+      active_tool_count: 0,
+      nested_tool_count: 0,
+      succeeded_nested_tool_count: 0,
+      failed_nested_tool_count: 0,
+      nested_tools: [],
+      omitted_nested_tool_count: 0,
+    };
   }
 
   /** Force-terminates one live CodeMode Session and retains its cancellation result. */
   async cancel(sessionIdValue: string): Promise<CodeModeSessionOperationResult> {
-    const parsedSessionId = parseCodeModeSessionId(sessionIdValue);
+    const parsedSessionId = parsestring(sessionIdValue);
     if (!parsedSessionId.ok) return invalidCodeModeSessionResult();
     const sessionId = parsedSessionId.value;
     const record = this.records.get(sessionId);
@@ -487,19 +567,7 @@ export class CodeModeSessionCoordinator {
       });
     } else {
       record.lastActivityAtMs = this.runtime.now();
-      record.latestPresentation = {
-        version: 1,
-        cell_state: "cancelled",
-        session_state: "closed",
-        elapsed_ms: 0,
-        active_tool_names: [],
-        active_tool_count: 0,
-        nested_tool_count: 0,
-        succeeded_nested_tool_count: 0,
-        failed_nested_tool_count: 0,
-        nested_tools: [],
-        omitted_nested_tool_count: 0,
-      };
+      record.latestPresentation = this.closedCellPresentation("cancelled");
       this.replaceWithTerminal(
         record,
         createCodeModeFailure(sessionId, "cancellation", "CodeMode Session was cancelled"),
@@ -516,7 +584,7 @@ export class CodeModeSessionCoordinator {
   }
 
   /** Releases every live Deno process; repeated shutdown calls share one completion. */
-  shutdown(_reason: string): Promise<void> {
+  shutdown(): Promise<void> {
     if (this.shutdownPromise !== undefined) return this.shutdownPromise;
     this.shuttingDown = true;
     this.shutdownPromise = this.shutdownAllSessions();
@@ -537,8 +605,16 @@ export class CodeModeSessionCoordinator {
     await Promise.all(this.pendingProcessStops);
   }
 
-  private createLiveSession(): LocateCodeModeSessionResult {
-    const parsedSessionId = parseCodeModeSessionId(this.runtime.createSessionId());
+  private async acquireSessionAdmission(): Promise<() => void> {
+    const previousAdmission = this.admissionQueue;
+    const admission = Promise.withResolvers<void>();
+    this.admissionQueue = previousAdmission.then(() => admission.promise);
+    await previousAdmission;
+    return admission.resolve;
+  }
+
+  private async createLiveSession(): Promise<LocateCodeModeSessionResult> {
+    const parsedSessionId = parsestring(this.runtime.createSessionId());
     if (!parsedSessionId.ok) {
       return {
         failure: createCodeModeFailure(
@@ -549,13 +625,67 @@ export class CodeModeSessionCoordinator {
       };
     }
     const sessionId = parsedSessionId.value;
+    if (this.shuttingDown) {
+      const failure = createCodeModeFailure(
+        sessionId,
+        "runtime",
+        "CodeMode coordinator is shutting down",
+      );
+      this.retainTerminalFailure(sessionId, failure);
+      return { failure };
+    }
     this.evictTerminalRecords();
-    const liveCount = [...this.records.values()].filter((record) => record.state === "live").length;
-    if (liveCount >= this.options.maxSessions) {
+    const liveRecords = [...this.records.values()].filter(
+      (record): record is LiveCodeModeSession => record.state === "live",
+    );
+    let reclaimedSessionId: string | undefined;
+    if (liveRecords.length >= this.options.maxSessions) {
+      const reclaimedRecord = liveRecords
+        .filter((record) => record.currentCell === undefined)
+        .toSorted((left, right) => left.lastAccess - right.lastAccess)[0];
+      if (reclaimedRecord === undefined) {
+        const failure = createCodeModeFailure(
+          sessionId,
+          "capacity",
+          "CodeMode Session capacity is exhausted",
+        );
+        this.retainTerminalFailure(sessionId, failure);
+        return { failure };
+      }
+      reclaimedSessionId = reclaimedRecord.sessionId;
+      reclaimedRecord.lastActivityAtMs = this.runtime.now();
+      this.touch(reclaimedRecord);
+      if (reclaimedRecord.latestPresentation !== undefined) {
+        reclaimedRecord.latestPresentation = {
+          ...reclaimedRecord.latestPresentation,
+          session_state: "closed",
+        };
+      }
+      this.replaceWithTerminal(
+        reclaimedRecord,
+        createCodeModeFailure(
+          reclaimedRecord.sessionId,
+          "eviction",
+          "CodeMode Session was reclaimed to free capacity.",
+        ),
+      );
+      try {
+        await this.stopWorker(reclaimedRecord.worker, "shutdown");
+      } catch (cause) {
+        const message =
+          cause instanceof Error
+            ? `CodeMode Session reclamation failed: ${cause.message}`
+            : "CodeMode Session reclamation failed: Deno process did not stop cleanly";
+        const failure = createCodeModeFailure(sessionId, "runtime", message);
+        this.retainTerminalFailure(sessionId, failure);
+        return { failure };
+      }
+    }
+    if (this.shuttingDown) {
       const failure = createCodeModeFailure(
         sessionId,
-        "capacity",
-        "CodeMode Session capacity is exhausted",
+        "runtime",
+        "CodeMode coordinator is shutting down",
       );
       this.retainTerminalFailure(sessionId, failure);
       return { failure };
@@ -585,22 +715,22 @@ export class CodeModeSessionCoordinator {
       cellCount: 0,
     };
     this.records.set(sessionId, record);
-    return { record, failure: createCodeModePending(sessionId) };
+    return reclaimedSessionId === undefined ? { record } : { record, reclaimedSessionId };
   }
 
-  private findSession(sessionId: CodeModeSessionId): LocateCodeModeSessionResult {
+  private findSession(sessionId: string): LocateCodeModeSessionResult {
     const record = this.records.get(sessionId);
     return record === undefined
       ? { failure: createCodeModeFailure(sessionId, "unknown", "Unknown CodeMode Session") }
-      : { record, failure: createCodeModePending(sessionId) };
+      : { record };
   }
 
   private createActiveCell(
     record: LiveCodeModeSession,
-    options: { readonly onUpdate?: (update: CodeModeNestedToolUpdate) => void },
+    options: CreateActiveCodeModeCellOptions,
   ): ActiveCodeModeCell {
     const completion = Promise.withResolvers<CodeModeResult>();
-    const cell: ActiveCodeModeCell = {
+    const cellBase: Omit<ActiveCodeModeCell, "reclaimedSessionId"> = {
       cellId: `cell-${++this.cellSequence}`,
       ordinal: ++record.cellCount,
       startedAtMs: this.runtime.now(),
@@ -617,6 +747,10 @@ export class CodeModeSessionCoordinator {
       acceptsUpdates: options.onUpdate !== undefined,
       settled: false,
     };
+    const cell: ActiveCodeModeCell =
+      options.reclaimedSessionId === undefined
+        ? cellBase
+        : { ...cellBase, reclaimedSessionId: options.reclaimedSessionId };
     if (options.onUpdate !== undefined) this.activeUpdateCallbacks.set(cell, options.onUpdate);
     return cell;
   }
@@ -680,10 +814,7 @@ export class CodeModeSessionCoordinator {
     }
   }
 
-  private handleWorkerResponse(
-    sessionId: CodeModeSessionId,
-    response: CodeModeWorkerResponse,
-  ): void {
+  private handleWorkerResponse(sessionId: string, response: CodeModeWorkerResponse): void {
     const record = this.records.get(sessionId);
     if (record?.state !== "live" || record.currentCell === undefined) return;
     const cell = record.currentCell;
@@ -696,7 +827,11 @@ export class CodeModeSessionCoordinator {
         return;
       }
       if (response.resultJson === undefined) {
-        this.settleReusableCell(record, cell, createCodeModeSuccess(sessionId));
+        this.settleReusableCell(
+          record,
+          cell,
+          createCodeModeSuccess(sessionId, undefined, response.console),
+        );
         return;
       }
       const data = this.parseJsonString(response.resultJson, { allowUndefined: true });
@@ -704,11 +839,15 @@ export class CodeModeSessionCoordinator {
         this.settleReusableCell(
           record,
           cell,
-          createCodeModeFailure(sessionId, "serialization", data.message),
+          createCodeModeFailure(sessionId, "serialization", data.message, response.console),
         );
         return;
       }
-      this.settleReusableCell(record, cell, createCodeModeSuccess(sessionId, data.value));
+      this.settleReusableCell(
+        record,
+        cell,
+        createCodeModeSuccess(sessionId, data.value, response.console),
+      );
       return;
     }
     if (response.type === "cell-error") {
@@ -720,15 +859,25 @@ export class CodeModeSessionCoordinator {
         return;
       }
       if (response.error.code === "runtime") {
-        this.fatalizeSession(record, cell, {
+        const failure = {
           code: response.error.code,
           message: response.error.message,
-        });
+        } as const;
+        this.fatalizeSession(
+          record,
+          cell,
+          response.console === undefined ? failure : { ...failure, console: response.console },
+        );
       } else {
         this.settleReusableCell(
           record,
           cell,
-          createCodeModeFailure(sessionId, response.error.code, response.error.message),
+          createCodeModeFailure(
+            sessionId,
+            response.error.code,
+            response.error.message,
+            response.console,
+          ),
         );
       }
       return;
@@ -1056,18 +1205,31 @@ export class CodeModeSessionCoordinator {
   ): void {
     if (!this.isCurrentCell(record, cell)) return;
     this.clearCellResources(cell);
-    const presentation = this.settledCellPresentation(cell, result, "live");
+    let retainedResult = result;
+    if (result.result === "success" && cell.reclaimedSessionId !== undefined) {
+      if (result.console === undefined) {
+        retainedResult = { ...result, reclaimedSessionId: cell.reclaimedSessionId };
+      } else {
+        const { console: consoleEntries, ...resultWithoutConsole } = result;
+        retainedResult = {
+          ...resultWithoutConsole,
+          reclaimedSessionId: cell.reclaimedSessionId,
+          console: consoleEntries,
+        };
+      }
+    }
+    const presentation = this.settledCellPresentation(cell, retainedResult, "live");
     const settledAtMs = this.runtime.now();
-    record.latestResult = result;
+    record.latestResult = retainedResult;
     record.latestPresentation = presentation;
-    record.lastCell = this.observeSettledCell(cell, result, settledAtMs);
+    record.lastCell = this.observeSettledCell(cell, retainedResult, settledAtMs);
     record.lastActivityAtMs = settledAtMs;
     const metadata = finalizeCodeModeMetadata(cell.metadata);
     if (metadata === undefined) delete record.availableMetadata;
     else record.availableMetadata = metadata;
     delete record.currentCell;
     cell.settled = true;
-    cell.resolveCompletion(result);
+    cell.resolveCompletion(retainedResult);
     this.touch(record);
     this.publishObserverSnapshot();
   }
@@ -1081,7 +1243,12 @@ export class CodeModeSessionCoordinator {
     if (failure.code === "termination") cell.metadata.terminate = true;
     cell.abortController.abort();
     this.clearCellResources(cell);
-    const result = createCodeModeFailure(record.sessionId, failure.code, failure.message);
+    const result = createCodeModeFailure(
+      record.sessionId,
+      failure.code,
+      failure.message,
+      failure.console,
+    );
     const settledAtMs = this.runtime.now();
     record.latestPresentation = this.cellPresentation(
       cell,
@@ -1129,26 +1296,14 @@ export class CodeModeSessionCoordinator {
     return stop;
   }
 
-  private handleWorkerFailure(sessionId: CodeModeSessionId, message: string): void {
+  private handleWorkerFailure(sessionId: string, message: string): void {
     const record = this.records.get(sessionId);
     if (record?.state !== "live") return;
     if (record.currentCell !== undefined) {
       this.fatalizeSession(record, record.currentCell, { code: "runtime", message });
     } else {
       record.lastActivityAtMs = this.runtime.now();
-      record.latestPresentation = {
-        version: 1,
-        cell_state: "failed",
-        session_state: "closed",
-        elapsed_ms: 0,
-        active_tool_names: [],
-        active_tool_count: 0,
-        nested_tool_count: 0,
-        succeeded_nested_tool_count: 0,
-        failed_nested_tool_count: 0,
-        nested_tools: [],
-        omitted_nested_tool_count: 0,
-      };
+      record.latestPresentation = this.closedCellPresentation("failed");
       this.replaceWithTerminal(record, createCodeModeFailure(sessionId, "runtime", message));
       try {
         this.options.onUnexpectedFailure?.(Object.freeze({ sessionId, message }));
@@ -1269,7 +1424,7 @@ export class CodeModeSessionCoordinator {
     }
   }
 
-  private retainTerminalFailure(sessionId: CodeModeSessionId, failure: CodeModeResult): void {
+  private retainTerminalFailure(sessionId: string, failure: CodeModeResult): void {
     this.records.set(sessionId, {
       state: "terminal",
       sessionId,