@visual-z/xeno 0.1.4 → 0.2.0

package/src/runtime/loop.ts

@@ -19,6 +19,8 @@
  */
 
 import type { LogEvent, AssistantBlock, NodeRef, CutReason } from "../core/events.ts";
+import { userInputData, submissionImages, type UserInput, type ImageRef } from "../core/images.ts";
+import { hydrateImages } from "./images.ts";
 import type { Handoff } from "../core/handoff.ts";
 import { boundHandoff, DEFAULT_HANDOFF_TOKENS } from "../core/history.ts";
 import { boundaryPreparation, continuationGuidance } from "../core/continuation.ts";
@@ -43,9 +45,10 @@ import { churnReview } from "../core/churn.ts";
 import { deadlineNotice } from "../core/deadline.ts";
 import { statusOf } from "./retry.ts";
 import { assertNever } from "../core/exhaustive.ts";
+import { isLogEvent } from "../core/event-validation.ts";
 import {
   initNode, appendEvent, readNode, closeNode, digestNode, handoffPath, nodePath, manifestPath,
-  listNodes, readCursor, writeCursor,
+  listNodes, readCursor, readCursorAt, writeCursor,
 } from "../store/log.ts";
 import { replayContext } from "../store/replay.ts";
 import { recoverCut } from "../store/recovery.ts";
@@ -66,8 +69,16 @@ import {
   type ToolContext, type Annotation, type ToolResult,
 } from "./tools.ts";
 import { diagnosePrefix, totalUsage, type UsageSample, type UsageTotals } from "./usage.ts";
-import { planResume } from "./resume.ts";
+import { planResume } from "../core/resume.ts";
 import type { Phase } from "../core/queue.ts";
+import { sameModel } from "../core/session-position.ts";
+import type { Effort } from "./model.ts";
+import { providerReplayKey, nativeReplay } from "./model-replay.ts";
+import { needsReplayCheckpoint } from "../core/model-replay.ts";
+import { resolveHistoryPosition } from "../store/session-position.ts";
+import { observeCommand } from "../store/command.ts";
+import { headTailView } from "../core/observation-view.ts";
+import { withProgress } from "./progress.ts";
 
 /** Ids and timestamps come from here so the loop stays the only impure part. */
 export interface Clock {
@@ -90,6 +101,7 @@ export interface LoopEvent {
     | "text_delta"
     | "thinking_delta"
     | "discard"
+    | "progress"
     | "tool_call"
     | "tool_result"
     | "usage"
@@ -110,6 +122,7 @@ export interface LoopEvent {
   /** branch_start: wall-clock milliseconds, for asserting the stagger. */
   at?: number;
   outcome?: ExecutionOutcome;
+  progress?: Extract<StreamDelta, { kind: "tool" | "retry" }> | { kind: "output"; text: string; name: string };
 }
 
 /**
@@ -191,6 +204,7 @@ export interface SessionConfig {
    * usable without the store -- a read-only branch has nothing to snapshot.
    */
   blobDir?: string;
+  imageOptions?: { readonly autoResize?: boolean; readonly blockImages?: boolean };
   /** Directory names the scan skips, relative to the workspace root. */
   snapshotIgnore?: readonly string[];
 }
@@ -236,6 +250,8 @@ async function digestedRef(dir: string, node: number): Promise<NodeRef> {
  */
 export interface RestorePoint {
   node: number;
+  /** The user message is the editable navigation target; idle snapshots have none. */
+  userId?: string;
   /** Last event of the exchange. Inclusive: the exchange itself is kept. */
   atEvent: string;
   /** The prompt that opened the exchange, for a caller that has to show it. */
@@ -335,7 +351,7 @@ export class Session {
     const existing = await listNodes(dir);
     const recordedCursor = await readCursor(dir);
     const cursor = recordedCursor === null ? null : await recoverCut(dir, recordedCursor);
-    const plan = planResume(cursor, model, existing.length > 0);
+    const plan = planResume(cursor, model, existing.length > 0, this.provider.config.spec.provider);
 
     switch (plan.kind) {
       case "refuse":
@@ -383,6 +399,7 @@ export class Session {
           else delete this.config.snapshotIgnore;
         }
         if (plan.cursor.workspace !== undefined) this.config.tools.root = plan.cursor.workspace;
+        if (plan.cursor.blob_dir !== undefined) this.config.blobDir = plan.cursor.blob_dir;
         for (const id of existing) {
           for (const event of (await readNode(dir, id)).events) {
             this.allocatedEventIds.add(event.id);
@@ -430,6 +447,9 @@ export class Session {
         return assertNever(plan, "Session.start");
     }
 
+    if (cursor?.needs_model_checkpoint || needsReplayCheckpoint(this.state.events, providerReplayKey(this.provider.config.spec), nativeReplay(this.provider.config.spec))) {
+      await this.performCut("model_checkpoint", model);
+    }
     await this.saveCursor();
   }
 
@@ -439,8 +459,76 @@ export class Session {
    * a fork that rewrote the original would leave the user with one line
    * when they thought they had two.
    */
-  async fork(destLogDir: string, untilEvent?: string): Promise<void> {
-    await copyAncestryTo(this.config.logDir, destLogDir, this.clock.now(), untilEvent);
+  async fork(destLogDir: string, untilEvent?: string, position: "at" | "before" = "at"): Promise<void> {
+    await copyAncestryTo(this.config.logDir, destLogDir, this.clock.now(), untilEvent, position);
+  }
+
+  async setThinking(effort: Effort): Promise<void> {
+    this.provider.config.effort = effort;
+    await this.saveCursor();
+  }
+
+  /** Pi user bash shares process ownership and archival with tools, never their authority or model dispatch. */
+  async runUserBash(command: string, excludeFromContext: boolean, signal?: AbortSignal,
+    onOutput?: (chunk: Uint8Array) => void): Promise<Extract<LogEvent, { t: "user_bash" }>> {
+    const owned = this.execution.begin(signal);
+    try {
+      if (!command.trim()) throw new Error("empty user command");
+      for await (const event of this.snapshotTurn([], false, "idle")) {
+        if (event.kind === "snapshot_failed") throw new Error(event.reason);
+      }
+      const captured = await observeCommand({ command, cwd: this.config.tools.root,
+        outputStore: join(this.config.logDir, "artifacts"), maxOutputBytes: this.config.tools.maxOutputBytes,
+        timeoutMs: this.config.tools.timeoutMs, signal: owned.signal, ...(onOutput ? { onOutput } : {}) });
+      const outcome = executionOutcome(captured.stopped === "cancelled" ? "cancelled" : captured.stopped === "timeout" ? "timeout"
+        : captured.exit === 0 ? "tool_completed" : "tool_failed");
+      const preview = headTailView(captured.head, captured.tail, captured.ref.bytes, this.config.tools.maxOutputBytes,
+        omitted => `\n[${omitted} bytes omitted; complete output: ${captured.ref.path}]\n`);
+      const content = `${preview}\nexit ${captured.exit} · ${outcome.status} · ${outcome.reason}`;
+      const event: Extract<LogEvent, { t: "user_bash" }> = { t: "user_bash", id: this.clock.nextId(), at: this.clock.now(),
+        command, content, exit: captured.exit, excludeFromContext, outcome, content_ref: captured.ref };
+      await this.record(event);
+      for await (const snapshot of this.snapshotTurn([])) {
+        if (snapshot.kind === "snapshot_failed") throw new Error(snapshot.reason);
+      }
+      await this.saveCursor();
+      return event;
+    } catch (error) {
+      await this.record({ t: "outcome", id: this.clock.nextId(), at: this.clock.now(),
+        reason: "user command failed before completion; inspect the workspace before retrying", outcome: executionOutcome("execution_error") });
+      throw error;
+    } finally { owned.finish(); }
+  }
+
+  async userMessages(): Promise<{ id: string; node: number; text: string; images?: readonly ImageRef[] }[]> {
+    const messages: Awaited<ReturnType<Session["userMessages"]>> = [];
+    for (const node of await listNodes(this.config.logDir)) {
+      for (const event of (await readNode(this.config.logDir, node)).events) {
+        if (event.t === "user") messages.push({ id: event.id, node, ...userInputData(event) });
+      }
+    }
+    return messages;
+  }
+
+  /** Pi keeps the selected runtime model when navigating; N.8 checkpoints incompatible context. */
+  async navigateTo(eventId: string): Promise<{ editorText?: string; images?: readonly ImageRef[] }> {
+    const dir = this.config.logDir;
+    const users = await this.userMessages();
+    const target = await resolveHistoryPosition(dir, eventId, users.some(user => user.id === eventId) ? "before" : "at");
+    for await (const event of this.snapshotTurn([], false, "idle")) {
+      if (event.kind === "snapshot_failed") throw new Error(event.reason);
+    }
+    const node = this.state.nextNode++;
+    await initNode(dir, node, target.parent, this.clock.now(), target.basis);
+    const cursor = await readCursor(dir);
+    if (!cursor) throw new Error("missing current session cursor");
+    const next = { ...cursor, node, next_node: this.state.nextNode, updated_at: this.clock.now(),
+      needs_model_checkpoint: target.parent !== null && (target.selection === null || !sameModel(target.selection, cursor)) };
+    delete next.at_event;
+    await writeCursor(dir, next);
+    await this.start();
+    const images = users.find(user => user.id === eventId)?.images;
+    return target.editorText === undefined ? {} : { editorText: target.editorText, ...(images?.length ? { images } : {}) };
   }
 
   /**
@@ -470,18 +558,31 @@ export class Session {
    * set; switchModel is the other caller that wants it.
    */
   async switchModel(next: Provider): Promise<void> {
-    if (this.isHalfRound()) {
+    if (this.running || this.isHalfRound()) {
       throw new Error(
         "cannot switch models mid-turn: a tool_use is still unpaired. " +
           "Wait for the turn to finish so every call has a result",
       );
     }
 
-    await this.performCut("model_checkpoint", next.config.spec.id);
+    await this.performCut("model_checkpoint", next.config.spec.id, undefined, next.config.spec.provider, next.config.effort);
     this.provider = next;
     await this.saveCursor();
   }
 
+  /** D6: changing the frozen prefix is an explicit checkpoint, never in-place prompt surgery. */
+  async reloadResources(frozen: FrozenPrefix): Promise<boolean> {
+    if (JSON.stringify(frozen) === JSON.stringify(this.config.frozen)) return false;
+    if (this.running || this.isHalfRound()) throw new Error("cannot reload resources while a turn is active or a tool call is unpaired");
+    const contextRef = await this.persistContext(frozen);
+    await this.performCut("model_checkpoint", this.provider.config.spec.id, undefined,
+      this.provider.config.spec.provider, this.provider.config.effort, contextRef);
+    this.config.frozen = frozen;
+    this.config.tools.allow = frozen.tools.flatMap(tool => tool !== null && typeof tool === "object" && "name" in tool && typeof tool.name === "string" ? [tool.name] : []);
+    await this.saveCursor();
+    return true;
+  }
+
   /**
    * The same pairing check switchModel already used. A user message
    * between tool_use and tool_result is the same unpairable request a
@@ -503,11 +604,11 @@ export class Session {
    * offered a line — writing it would be the pairing bug this guards.
    */
   private async pullSteering(
-    pull?: (phase: Phase) => Promise<string | null>,
-  ): Promise<string | null> {
+    pull?: (phase: Phase) => Promise<UserInput | null>,
+  ): Promise<UserInput | null> {
     if (pull === undefined || this.isHalfRound()) return null;
     const text = await pull("after_tools");
-    if (text === null || text.length === 0) return null;
+    if (text === null || typeof text === "string" && text.length === 0) return null;
     return text;
   }
 
@@ -518,11 +619,9 @@ export class Session {
    * resuming from -- a crash, a kill, a closed laptop -- do not run exit
    * handlers.
    */
-  private async saveCursor(): Promise<void> {
-    // Branches share storage but never own the parent's active cursor.
-    if ((this.config.branchDepth ?? 0) > 0) return;
-    const contextRef = await putBlob(join(this.config.logDir, "artifacts"), JSON.stringify({
-      frozen: this.config.frozen, gates: this.config.tools.gates,
+  private async persistContext(frozen = this.config.frozen): Promise<string> {
+    return putBlob(join(this.config.logDir, "artifacts"), JSON.stringify({
+      frozen, gates: this.config.tools.gates,
       workNamespace: this.config.workNamespace ?? "main",
       maxParallelTools: this.config.maxParallelTools ?? 3,
       ...(this.config.boundary ? { boundary: this.config.boundary } : {}),
@@ -532,13 +631,24 @@ export class Session {
       ...(this.config.guidance === undefined ? {} : { guidance: this.config.guidance }),
       ...(this.config.snapshotIgnore ? { snapshotIgnore: this.config.snapshotIgnore } : {}),
     }));
+  }
+
+  private async saveCursor(model = this.provider.config.spec.id, provider = this.provider.config.spec.provider,
+    thinking = this.provider.config.effort, contextRef?: string): Promise<void> {
+    // Branches share storage but never own the parent's active cursor.
+    if ((this.config.branchDepth ?? 0) > 0) return;
+    const last = (await readNode(this.config.logDir, this.state.node)).events.at(-1);
     await writeCursor(this.config.logDir, {
       node: this.state.node,
       next_node: this.state.nextNode,
-      model: this.provider.config.spec.id,
+      model,
+      provider,
+      thinking,
+      ...(last ? { at_event: last.id } : {}),
+      ...(this.config.blobDir === undefined ? {} : { blob_dir: this.config.blobDir }),
       updated_at: this.clock.now(),
       workspace: this.config.tools.root,
-      context_ref: contextRef,
+      context_ref: contextRef ?? await this.persistContext(),
     });
   }
 
@@ -548,6 +658,15 @@ export class Session {
     if (this.stall !== null) this.stall = advanceStall(this.stall, [{ node: this.state.node, event }]);
   }
 
+  async appendExtension(entry: Omit<Extract<LogEvent, { t: "extension" }>, "t" | "id" | "at">): Promise<void> {
+    // Messages are only pairable between tools. Private extension state may
+    // be recorded during execution because it never enters model context.
+    if (entry.inContext && (this.running || this.isHalfRound())) throw new Error("Custom messages must be queued until the active turn finishes");
+    const event = { ...entry, t: "extension" as const, id: this.clock.nextId(), at: this.clock.now() };
+    if (!isLogEvent(event)) throw new Error("Invalid extension entry");
+    await this.record(event);
+  }
+
   get totals(): UsageTotals {
     return totalUsage(this.state.usage);
   }
@@ -568,9 +687,9 @@ export class Session {
    * available, and would also lie about a call that may have had effects).
    */
   async *send(
-    userText: string,
+    userText: UserInput,
     signal?: AbortSignal,
-    pull?: (phase: Phase) => Promise<string | null>,
+    pull?: (phase: Phase) => Promise<UserInput | null>,
   ): AsyncGenerator<LoopEvent> {
     const owned = this.execution.begin(signal);
     const events = this.run(userText, owned.signal, pull);
@@ -580,10 +699,25 @@ export class Session {
       for (;;) {
         const item = await events.next();
         if (item.done) { exhausted = true; break; }
-        if (item.value.kind === "done") terminal = true;
+        if (item.value.kind === "done") {
+          terminal = true;
+          if (item.value.outcome && item.value.outcome.reason !== "model_end") await this.record({
+            t: "outcome", id: this.clock.nextId(), at: this.clock.now(),
+            reason: item.value.reason ?? item.value.outcome.reason, outcome: item.value.outcome,
+          });
+        }
         yield item.value;
       }
-      if (!terminal) yield { kind: "done", reason: "stopped: workspace snapshot failed", outcome: executionOutcome("snapshot_failed") };
+      if (!terminal) {
+        const outcome = executionOutcome("snapshot_failed");
+        await this.record({ t: "outcome", id: this.clock.nextId(), at: this.clock.now(), reason: "workspace snapshot failed", outcome });
+        yield { kind: "done", reason: "stopped: workspace snapshot failed", outcome };
+      }
+    } catch (error) {
+      // Raw provider exceptions can contain credentials; persist only the execution fact.
+      await this.record({ t: "outcome", id: this.clock.nextId(), at: this.clock.now(),
+        reason: "request failed before completion; no complete response was committed", outcome: executionOutcome("provider_error") });
+      throw error;
     } finally {
       // Closing a consumer is not a user cancellation. Preserve the existing
       // crash/recovery points; only an explicit signal can claim cancellation.
@@ -596,12 +730,22 @@ export class Session {
   }
 
   private async *run(
-    userText: string,
+    userText: UserInput,
     signal?: AbortSignal,
-    pull?: (phase: Phase) => Promise<string | null>,
+    pull?: (phase: Phase) => Promise<UserInput | null>,
   ): AsyncGenerator<LoopEvent> {
+    if (needsReplayCheckpoint(this.state.events, providerReplayKey(this.provider.config.spec), nativeReplay(this.provider.config.spec))) {
+      if (this.isHalfRound()) throw new Error("Cannot change a wire profile while tool results are pending");
+      await this.performCut("model_checkpoint");
+    }
+    const blocked = this.config.imageOptions?.blockImages ?? false;
+    // A privacy change uses the existing mechanical checkpoint (D5/D8); it never edits old messages.
+    if (blocked && this.state.events.some(e => (e.t === "user" || e.t === "tool_result") && e.images?.some(image => !image.blocked))) {
+      if (this.isHalfRound()) throw new Error("Cannot change image transmission while tool results are pending");
+      await this.performCut("model_checkpoint");
+    }
     await this.record({
-      t: "user", id: this.clock.nextId(), at: this.clock.now(), text: userText,
+      t: "user", id: this.clock.nextId(), at: this.clock.now(), ...userInputData(userText, blocked),
     });
     // Idle changes belong to the new prompt. Recording them before `user`
     // would silently move the preceding exchange's restore point forward.
@@ -748,6 +892,7 @@ export class Session {
 
         await this.record({
           t: "assistant", id: this.clock.nextId(), at: this.clock.now(), blocks: result.blocks, stop_reason: result.stopReason,
+          replay_key: providerReplayKey(this.provider.config.spec),
         });
 
         for (const b of result.blocks) {
@@ -767,7 +912,7 @@ export class Session {
           }
           const extra = await this.pullSteering(pull);
           if (extra !== null) {
-            await this.record({ t: "user", id: this.clock.nextId(), at: this.clock.now(), text: extra });
+            await this.record({ t: "user", id: this.clock.nextId(), at: this.clock.now(), ...userInputData(extra, blocked) });
             continue;
           }
           const history = await readNodeHistory(this.config.logDir, this.state.node, undefined, "context");
@@ -790,7 +935,7 @@ export class Session {
           const extra = await this.pullSteering(pull);
           if (extra !== null) {
             await this.record({
-              t: "user", id: this.clock.nextId(), at: this.clock.now(), text: extra,
+              t: "user", id: this.clock.nextId(), at: this.clock.now(), ...userInputData(extra, blocked),
             });
             continue;
           }
@@ -861,7 +1006,7 @@ export class Session {
             // `branch`/`resolve` act on the tree. Each still produces an ordinary
             // tool_result so the turn stays pairable. They go through the same
             // gate as read/write/edit/bash, which runTool applies itself.
-            const toolContext = { ...this.config.tools, ...(signal ? { signal } : {}) };
+            const toolContext = { ...this.config.tools, imageStore: this.config.blobDir ?? join(this.config.logDir, "blobs"), imageAutoResize: this.config.imageOptions?.autoResize ?? true, ...(signal ? { signal } : {}) };
             if (call.name === "note" || call.name === "branch" || call.name === "resolve" || call.name === "history") {
               const gated = await gateTool(toolContext, call.name, call.input);
               if (gated) {
@@ -879,7 +1024,10 @@ export class Session {
                 out = await this.runResolve(call.input);
               }
             } else {
-              out = await runTool(toolContext, call.name, call.input);
+              const decoder = new TextDecoder();
+              out = yield* withProgress<ToolResult, LoopEvent>(emit => runTool({ ...toolContext, callId: call.call_id,
+                onOutput: chunk => emit({ kind: "progress", progress: { kind: "output", name: call.name, text: decoder.decode(chunk, { stream: true }) } }),
+              }, call.name, call.input));
             }
           }
           if (out.accept) for (const event of await out.accept()) yield event;
@@ -906,6 +1054,7 @@ export class Session {
             ...(out.diagnostic !== undefined ? { diagnostic: out.diagnostic } : {}),
             ...(out.content_sha256 ? { content_sha256: out.content_sha256 } : {}),
             ...(out.content_ref ? { content_ref: out.content_ref } : {}),
+            ...(out.images?.length ? { images: submissionImages(out.images, blocked) } : {}),
             ...(out.effect ? { effect: out.effect } : {}),
           });
           completedThisTurn.push(call.call_id);
@@ -930,7 +1079,7 @@ export class Session {
         const extra = await this.pullSteering(pull);
         if (extra !== null) {
           await this.record({
-            t: "user", id: this.clock.nextId(), at: this.clock.now(), text: extra,
+            t: "user", id: this.clock.nextId(), at: this.clock.now(), ...userInputData(extra, blocked),
           });
         }
       }
@@ -1014,62 +1163,27 @@ export class Session {
     messages: readonly Message[],
     signal?: AbortSignal,
   ): AsyncGenerator<LoopEvent, Turn> {
-    const queue: LoopEvent[] = [];
-    let notify: (() => void) | null = null;
-    const box: { settled: { ok: true; turn: Turn } | { ok: false; error: unknown } | null } = {
-      settled: null,
-    };
-
-    const onDelta = (delta: StreamDelta): void => {
+    const hydrated = await hydrateImages(messages, this.config.blobDir ?? join(this.config.logDir, "blobs"),
+      this.provider.config.spec.input?.includes("image") ?? false);
+    return yield* withProgress<Turn, LoopEvent>(emit => this.provider.send(
+      this.config.frozen, hydrated, this.state.node, signal, (delta: StreamDelta): void => {
       switch (delta.kind) {
         case "text":
-          queue.push({ kind: "text_delta", text: delta.text });
+          emit({ kind: "text_delta", text: delta.text });
           break;
         case "thinking":
-          queue.push({ kind: "thinking_delta", text: delta.text });
+          emit({ kind: "thinking_delta", text: delta.text });
           break;
         case "discard":
-          queue.push({ kind: "discard" });
+          emit({ kind: "discard" });
+          break;
+        case "tool": case "retry":
+          emit({ kind: "progress", progress: delta });
           break;
         default:
           return assertNever(delta, "onDelta");
       }
-      notify?.();
-    };
-
-    const pending = this.provider
-      .send(this.config.frozen, messages, this.state.node, signal, onDelta)
-      .then(
-        (turn) => {
-          box.settled = { ok: true, turn };
-          notify?.();
-        },
-        (error: unknown) => {
-          box.settled = { ok: false, error };
-          notify?.();
-        },
-      );
-
-    while (box.settled === null || queue.length > 0) {
-      if (queue.length > 0) {
-        yield queue.shift()!;
-        continue;
-      }
-      await new Promise<void>((resolve) => {
-        if (box.settled !== null || queue.length > 0) {
-          resolve();
-          return;
-        }
-        notify = resolve;
-      });
-      notify = null;
-    }
-
-    await pending;
-    const end = box.settled;
-    if (end === null) throw new Error("provider send settled without a result");
-    if (!end.ok) throw end.error;
-    return end.turn;
+    }));
   }
 
   /**
@@ -1166,11 +1280,11 @@ export class Session {
   private executionMode(call: ToolCall): "parallel" | "exclusive" {
     if (call.name === "branch" && typeof call.input === "object" && call.input !== null &&
         (call.input as Record<string, unknown>)["writes"] !== true) return "parallel";
-    return toolDefinition(call.name)?.execution ?? "exclusive";
+    return toolDefinition(call.name, this.config.tools)?.execution ?? "exclusive";
   }
 
   private async *prepareConcurrentCall(call: ToolCall, branchIndex: number, signal?: AbortSignal): AsyncGenerator<LoopEvent, () => Promise<DeferredToolResult>> {
-    const ctx = { ...this.config.tools, ...(signal ? { signal } : {}) };
+    const ctx = { ...this.config.tools, callId: call.call_id, imageStore: this.config.blobDir ?? join(this.config.logDir, "blobs"), imageAutoResize: this.config.imageOptions?.autoResize ?? true, ...(signal ? { signal } : {}) };
     if (call.name !== "branch") {
       const prepared = await prepareTool(ctx, call.name, call.input);
       return typeof prepared === "function" ? prepared : async () => prepared;
@@ -1544,11 +1658,11 @@ export class Session {
 
     const points: RestorePoint[] = [];
     for (const n of all) {
-      let open: { prompt: string; changed: number; last: string } | null = null;
+      let open: { prompt: string; changed: number; last: string; userId: string } | null = null;
       const close = () => {
         if (open) {
           points.push({
-            node: n.node, atEvent: open.last, prompt: open.prompt,
+            node: n.node, atEvent: open.last, prompt: open.prompt, userId: open.userId,
             changed: open.changed, onPath: onPath.has(open.last),
           });
         }
@@ -1564,7 +1678,7 @@ export class Session {
         }
         if (e.t === "user") {
           close();
-          open = { prompt: e.text, changed: 0, last: e.id };
+          open = { prompt: e.text, changed: 0, last: e.id, userId: e.id };
           continue;
         }
         if (!open) continue;
@@ -1637,6 +1751,7 @@ export class Session {
     // what every mode needs -- to apply, or to say what it is NOT applying.
     const plan = await planRestoreToNode(dir, target, undefined, root, this.ignore);
     if (!plan.ok) return { ok: false, error: plan.error };
+    const historical = await readCursorAt(dir, point.node, point.atEvent);
     // Preserve idle edits before moving away from them. An unobserved file is
     // not disposable just because the target predates it (D8/appendix H).
     for await (const event of this.snapshotTurn([], false, "idle")) {
@@ -1723,9 +1838,18 @@ export class Session {
     for await (const result of this.snapshotTurn([], true)) {
       if (result.kind === "snapshot_failed") throw new Error(result.reason);
     }
+    const incompatible = historical === null || !sameModel(historical, {
+      model: this.provider.config.spec.id, provider: this.provider.config.spec.provider,
+    });
+    if (incompatible) {
+      // Persist the guard before opening the new model context, including on crash recovery.
+      const current = await readCursor(dir);
+      if (current) await writeCursor(dir, { ...current, node, next_node: this.state.nextNode, needs_model_checkpoint: true });
+      await this.performCut("model_checkpoint", this.provider.config.spec.id);
+    }
     await this.saveCursor();
 
-    return { ok: true, node, ...moved };
+    return { ok: true, node: this.state.node, ...moved };
   }
 
   /**
@@ -1932,7 +2056,8 @@ export class Session {
    * would make a model switch wait for minNodeWorkTokens, and the new model
    * would see the old thinking blocks in the meantime.
    */
-  private async performCut(reason: CutReason, nextModel = this.provider.config.spec.id, retainedFrom?: string): Promise<void> {
+  private async performCut(reason: CutReason, nextModel = this.provider.config.spec.id, retainedFrom?: string,
+    nextProvider = this.provider.config.spec.provider, nextThinking = this.provider.config.effort, nextContextRef?: string): Promise<void> {
     const dir = this.config.logDir;
     const node = this.state.node;
 
@@ -1951,6 +2076,9 @@ export class Session {
       reason,
       next_node: this.state.nextNode,
       next_model: nextModel,
+      next_provider: nextProvider,
+      next_thinking: nextThinking,
+      ...(nextContextRef === undefined ? {} : { next_context_ref: nextContextRef }),
       handoff_tokens: DEFAULT_HANDOFF_TOKENS,
       ...(retainedFrom === undefined ? {} : { retained_from: retainedFrom }),
     });
@@ -1978,6 +2106,8 @@ export class Session {
     // its derived state does. Relying on the default here would silently make
     // every boundary a fork and replay the whole history.
     await initNode(dir, this.state.node, self, this.clock.now(), "handoff");
-    await this.saveCursor();
+    // The durable successor already belongs to the target provider, even if
+    // the process exits before switchModel installs its in-memory adapter.
+    await this.saveCursor(nextModel, nextProvider, nextThinking, nextContextRef);
   }
 }