@springbrand/agent-runtime 0.3.0-alpha.2 → 0.3.0-alpha.21

package/src/session/cloudflare/migration.ts

@@ -1,109 +1,30 @@
-import { isEqual } from "lodash-es";
 import {
-  decodePiToolRecoveryMilestone,
-  replayPiToolRecovery,
-} from "./legacy-tool-recovery";
-/** Versioned SQL data migration, called before the Runtime opens its transcript. */
-import {
-  branchTip,
-  entryLabel,
-  insertEntry,
-  insertUsage,
-  setValue,
-  deleteValue,
-  sessionName,
-  laneState,
-  operationMeta,
-  operationState,
-  pendingEntry,
-  sessionEntryToContextMessages,
-  value,
-  type Entry,
-  type JsonValue,
-  type Write,
-  type Value,
-  type LaneState,
-  type ToolExecution,
-} from "@earendil-works/pi-agent-core/harness/session";
-import type {
-  AgentToolResult,
-  AgentMessage,
-} from "@earendil-works/pi-agent-core";
-import type { Usage, ToolResultMessage } from "@earendil-works/pi-ai";
-import {
-  CloudflareSessionStorage,
-  CURRENT_PI_STORAGE_VERSION,
-} from "./storage";
+  AgentDoc, GenerationTask, LiveDoc,
+  defineDoc, type ConversationId, type EntryRecord,
+  type GenerationCheckpoint, type Session,
+} from "@earendil-works/pi-durable";
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import type { Message } from "@earendil-works/pi-ai";
+import { replayPiToolRecovery } from "./legacy-tool-recovery";
+import { RuntimeConversation } from "./storage";
 
-const RETIRED_SCHEDULE_CALLBACKS = [
-  "_cleanupStreamBuffers",
-  "_piPlannedContinuation",
-  "_piContinuationWatchdog",
-  "_piApprovalContinuation",
-  "_chatRecoveryRetry",
-] as const;
+const Migration = defineDoc({
+  kind: "springbrand.pi-upgrade", version: 1, scope: "session",
+  initial: (): { completed: boolean } => ({ completed: false }),
+});
 
-type LegacyRecord = Record<string, unknown> & {
-  id: string;
-  parentId: string | null;
-  type: string;
-  timestamp: string;
+type LegacyEntry = {
+  id: string; parentId: string | null; type: string; timestamp: number | string;
+  message?: Message; summary?: string; firstKeptEntryId?: string;
+  retainedTail?: Message[]; [key: string]: unknown;
 };
-export interface PiSessionMigrationReport {
-  sourceEntries: number;
-  entries: number;
-  tip: string | null;
-  alreadyMigrated: boolean;
-}
-
-function object(input: unknown): Record<string, unknown> {
-  if (!input || typeof input !== "object" || Array.isArray(input))
-    throw new Error("Invalid legacy object");
-  return input as Record<string, unknown>;
-}
-function text(input: unknown): string {
-  if (typeof input !== "string") throw new Error("Invalid legacy string");
-  return input;
-}
-function time(input: unknown): number {
-  const timestamp = Date.parse(text(input));
-  if (!Number.isSafeInteger(timestamp) || timestamp < 0)
-    throw new Error("Invalid legacy timestamp");
-  return timestamp;
-}
-function finite(input: unknown): number {
-  if (typeof input !== "number" || !Number.isFinite(input) || input < 0)
-    throw new Error("Invalid legacy number");
-  return input;
-}
-function message(input: unknown): AgentMessage {
-  const record = object(input);
-  if (
-    ![
-      "user",
-      "assistant",
-      "toolResult",
-      "custom",
-      "bashExecution",
-      "branchSummary",
-      "compactionSummary",
-    ].includes(text(record.role))
-  )
-    throw new Error("Unknown legacy message role");
-  finite(record.timestamp);
-  if (record.role === "assistant" && record.stopReason === "pending")
-    throw new Error("Unsettled legacy assistant message");
-  return normalizeLegacyAskUserMessage(record) as AgentMessage;
-}
 function hasTable(sql: SqlStorage, name: string): boolean {
-  return (
-    sql
-      .exec(
-        "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?",
-        name,
-      )
-      .toArray().length > 0
-  );
+  return sql.exec("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?", name).toArray().length > 0;
+}
+function timestamp(entry: LegacyEntry): number {
+  const value = typeof entry.timestamp === "number" ? entry.timestamp : Date.parse(entry.timestamp);
+  if (!Number.isFinite(value)) throw new Error(`Invalid historical entry time: ${entry.id}`);
+  return value;
 }
 
 const ASK_USER_RESPONSE_TYPES = new Set([
@@ -171,802 +92,399 @@ function normalizeLegacyAskUserEntry(value: unknown): unknown {
   return value;
 }
 
-function migrateLegacyAskUserData(sql: SqlStorage): void {
-  if (hasTable(sql, "pi_entries")) {
-    for (const row of sql.exec<{ id: string; body: string }>(
-      "SELECT id, body FROM pi_entries",
-    ).toArray()) {
-      sql.exec(
-        "UPDATE pi_entries SET body = ? WHERE id = ?",
-        JSON.stringify(normalizeLegacyAskUserEntry(JSON.parse(row.body))),
-        row.id,
-      );
+const TERMINAL_HOST_STATUSES = new Set(["completed", "failed", "aborted", "skipped", "error"]);
+/** Legacy run phases whose state maps onto a native generation checkpoint without guessing. */
+const RESUMABLE_PHASES = new Set(["starting", "checkpoint", "assistant.ready", "assistant.effect_pending", "assistant.retry_wait"]);
+const MESSAGE_ROLES = new Set(["user", "assistant", "toolResult", "custom", "bashExecution", "branchSummary", "compactionSummary"]);
+const UNKNOWN_EFFECT = "Tool execution was interrupted and its external outcome is unknown. Do not repeat the effect without reconciling it.";
+const INTERRUPTED = "This request was interrupted by a runtime upgrade and did not finish. Send it again to continue.";
+
+type LegacyResult = { status?: string; error?: { code?: string; message?: string } };
+type ToolBatch = { assistantEntryId: string; turnId: string; calls: Array<{ status: string; sourceIndex: number; resultEntryId: string; replay?: string }> };
+
+function warn(message: string): void {
+  console.warn("[pi-session-migration]", message);
+}
+
+/** Custom messages reach the model as user context, matching `ConversationHistory.append` (e.g. turn-aborted markers). */
+function customModel(message: Message, createdAt: number): { model?: Message[] } {
+  const content = (message as unknown as { content?: unknown }).content;
+  if (typeof content === "string") return { model: [{ role: "user", content, timestamp: createdAt }] };
+  if (!Array.isArray(content) || !content.length) return {};
+  return { model: [{ role: "user", content: [...content] as Extract<Message, { role: "user" }>["content"], timestamp: createdAt }] };
+}
+
+function unknownOutcome(call: { id: string; name: string }, text = UNKNOWN_EFFECT): Message {
+  return { role: "toolResult", toolCallId: call.id, toolName: call.name, content: [{ type: "text", text }], isError: true, timestamp: Date.now() };
+}
+
+/**
+ * Normalizes historical records onto the native shapes and drops records that can never be valid model context.
+ * Dropped and branch-pointer records resolve to their nearest kept ancestor, so descendants stay on their branch.
+ */
+function repairLegacyEntries(raw: LegacyEntry[]): { entries: LegacyEntry[]; resolve: (id: string | null) => string | null } {
+  const kept = new Map<string, LegacyEntry>();
+  const alias = new Map<string, string | null>();
+  const resolve = (id: string | null): string | null => {
+    for (let seen = 0; id !== null && !kept.has(id) && alias.has(id); seen++) {
+      if (seen > alias.size) throw new Error(`Cyclic historical Pi reference: ${id}`);
+      id = alias.get(id)!;
     }
-  }
-  if (hasTable(sql, "pi_tool_interactions")) {
-    for (const row of sql.exec<{ interaction_id: string; input_json: string }>(
-      "SELECT interaction_id, input_json FROM pi_tool_interactions WHERE tool_name = 'ask_user'",
-    ).toArray()) {
-      sql.exec(
-        "UPDATE pi_tool_interactions SET input_json = ? WHERE interaction_id = ?",
-        JSON.stringify(normalizeLegacyAskUserInput(JSON.parse(row.input_json))),
-        row.interaction_id,
-      );
+    return id;
+  };
+  const entries: LegacyEntry[] = [];
+  for (const source of raw) {
+    const parentId = resolve(source.parentId);
+    const skip = (reason: string) => {
+      warn(`Skipped historical entry ${source.id}: ${reason}`);
+      alias.set(source.id, parentId);
+    };
+    if (source.type === "leaf") {
+      alias.set(source.id, resolve(typeof source.targetId === "string" ? source.targetId : source.targetId === null ? null : parentId));
+      continue;
     }
-  }
-  if (hasTable(sql, "pi_values")) {
-    for (const row of sql.exec<{ key: string; body: string }>(
-      "SELECT key, body FROM pi_values WHERE namespace = 'pi.op.state'",
-    ).toArray()) {
-      const state = JSON.parse(row.body) as {
-        batch?: {
-          assistantEntryId?: unknown;
-          turnId?: unknown;
-        };
+    let entry: LegacyEntry = { ...source, parentId };
+    if (source.type === "custom_message") {
+      if (typeof source.customType !== "string") { skip("custom message has no type"); continue; }
+      entry = {
+        id: source.id, parentId, type: "message", timestamp: source.timestamp,
+        message: { role: "custom", customType: source.customType, content: source.content, details: source.details, display: source.display, timestamp: timestamp(source) } as unknown as Message,
       };
-      const assistantEntryId = state.batch?.assistantEntryId;
-      const turnId = state.batch?.turnId;
-      if (typeof assistantEntryId !== "string" || typeof turnId !== "string") {
-        continue;
+    }
+    if (entry.type === "message") {
+      const message = entry.message as unknown as Record<string, unknown> | undefined;
+      if (!message || typeof message !== "object" || !MESSAGE_ROLES.has(message.role as string)) { skip("unknown message"); continue; }
+      if (message.role === "assistant" && message.stopReason === "pending") { skip("unsettled assistant"); continue; }
+      if (message.role === "toolResult") {
+        let call: { name: string } | undefined;
+        let duplicate = false;
+        for (let cursor = parentId; cursor && !call && !duplicate; cursor = kept.get(cursor)?.parentId ?? null) {
+          const ancestor = kept.get(cursor)?.message;
+          if (ancestor?.role === "toolResult" && ancestor.toolCallId === message.toolCallId) duplicate = true;
+          if (ancestor?.role === "assistant") {
+            call = ancestor.content.find((part) => part.type === "toolCall" && part.id === message.toolCallId) as { name: string } | undefined;
+          }
+        }
+        if (duplicate) { skip(`duplicate Tool result ${String(message.toolCallId)}`); continue; }
+        if (!call || call.name !== message.toolName) { skip(`orphan Tool result ${String(message.toolCallId)}`); continue; }
       }
-      const entryRow = sql.exec<{ body: string }>(
-        "SELECT body FROM pi_entries WHERE id = ?",
-        assistantEntryId,
-      ).toArray()[0];
-      if (!entryRow) continue;
-      const entry = JSON.parse(entryRow.body) as {
-        type?: unknown;
-        message?: { role?: unknown; content?: unknown };
-      };
-      if (
-        entry.type !== "message" || entry.message?.role !== "assistant" ||
-        !Array.isArray(entry.message.content)
-      ) continue;
-      entry.message.content.forEach((part, sourceIndex) => {
-        if (!part || typeof part !== "object" || Array.isArray(part)) return;
-        const block = part as Record<string, unknown>;
-        if (block.type !== "toolCall" || block.name !== "ask_user") return;
-        const key = `${row.key}:${turnId}:${sourceIndex}`;
-        const args = sql.exec<{ body: string }>(
-          "SELECT body FROM pi_values WHERE namespace = 'pi.op.tool_args' AND key = ?",
-          key,
-        ).toArray()[0];
-        if (!args) return;
-        sql.exec(
-          "UPDATE pi_values SET body = ? WHERE namespace = 'pi.op.tool_args' AND key = ?",
-          JSON.stringify(normalizeLegacyAskUserInput(JSON.parse(args.body))),
-          key,
-        );
-      });
     }
+    kept.set(entry.id, entry);
+    entries.push(entry);
   }
+  return { entries, resolve };
 }
 
-function removeRetiredRuntimeArtifacts(sql: SqlStorage): void {
-  sql.exec(
-    "CREATE TABLE IF NOT EXISTS pi_session_entry_submission (entry_id TEXT PRIMARY KEY, submission_id TEXT NOT NULL)",
-  );
-  if (hasTable(sql, "pi_session_message_submission")) {
-    sql.exec(`
-      INSERT OR IGNORE INTO pi_session_entry_submission (entry_id, submission_id)
-        SELECT message_id, submission_id FROM pi_session_message_submission;
-      DROP TABLE pi_session_message_submission;
-    `);
+/** Converts records once; historical tables are retained until the upgrade is accepted. */
+export async function migratePiSession(storage: DurableObjectStorage, session: Session): Promise<void> {
+  if ((await session.snapshot(Migration, BACKGROUND_CONTEXT))?.completed) return;
+  const sql = storage.sql;
+  if (hasTable(sql, "pi_storage_state")) {
+    const version = sql.exec<{ storage_version: number }>("SELECT storage_version FROM pi_storage_state WHERE singleton=1").one().storage_version;
+    if (![1, 2, 3].includes(version)) throw new Error(`Unsupported historical Pi storage version: ${version}`);
   }
-  if (hasTable(sql, "cf_agents_schedules")) {
-    const placeholders = RETIRED_SCHEDULE_CALLBACKS.map(() => "?").join(", ");
-    sql.exec(
-      `DELETE FROM cf_agents_schedules WHERE callback IN (${placeholders})`,
-      ...RETIRED_SCHEDULE_CALLBACKS,
-    );
+  const current = hasTable(sql, "pi_entries");
+  const older = hasTable(sql, "pi_session_entries");
+  const rows = current || older
+    ? sql.exec<{ body: string }>(`SELECT body FROM ${current ? "pi_entries" : "pi_session_entries"} ORDER BY seq`).toArray()
+    : [];
+  const raw = rows.map(({ body }) => normalizeLegacyAskUserEntry(JSON.parse(body)) as LegacyEntry);
+  if (new Set(raw.map((entry) => entry.id)).size !== raw.length) throw new Error("Historical Pi entry IDs are not unique");
+  const repaired = repairLegacyEntries(raw);
+  const entries = repaired.entries;
+  const byId = new Map(entries.map((entry) => [entry.id, entry]));
+  const values = current && hasTable(sql, "pi_values")
+    ? sql.exec<{ namespace: string; key: string; body: string }>("SELECT namespace,key,body FROM pi_values").toArray()
+    : [];
+  const read = <T>(namespace: string, key: string): T | undefined => {
+    const row = values.find((row) => row.namespace === namespace && row.key === key);
+    return row ? JSON.parse(row.body) as T : undefined;
+  };
+  const tipValue = values.find((row) => row.namespace === "pi.branch.tip" && row.key === "main");
+  let oldTip: string | null = repaired.resolve(tipValue ? JSON.parse(tipValue.body) as string | null : raw.at(-1)?.id ?? null);
+  const hostRows = hasTable(sql, "pi_submissions")
+    ? sql.exec<{ submission_id: string; status: string }>("SELECT submission_id,status FROM pi_submissions").toArray()
+    : [];
+  const hostStatus = new Map(hostRows.map((row) => [row.submission_id, row.status]));
+  const lane = read<{ currentOperationId?: string | null }>("pi.lane.state", "main");
+  const operationId = lane?.currentOperationId;
+  const legacyRunning = older ? hostRows.filter((row) => row.status === "running") : [];
+  if (legacyRunning.length > 1) throw new Error("Multiple legacy operations are active in one conversation");
+  let active: string | undefined = operationId && read<LegacyResult>("pi.result", operationId) === undefined && !TERMINAL_HOST_STATUSES.has(hostStatus.get(operationId) ?? "")
+    ? operationId
+    : legacyRunning[0]?.submission_id;
+  // Navigation and standalone compaction never committed their target. The Host re-admits the owning
+  // Submission from its queued input, so the native runtime performs the whole step itself.
+  const intent = active ? read<{ intent?: { kind?: string } }>("pi.op.meta", active)?.intent?.kind ?? (active.endsWith(":regenerate") ? "navigation" : "run") : undefined;
+  if (active && intent !== "run") {
+    warn(`Dropped unfinished legacy ${intent} operation ${active}`);
+    active = undefined;
   }
-  migrateLegacyAskUserData(sql);
-}
-
-/** Older Harness adapters copied the initial user sidecar onto consumed Steers. */
-function repairDuplicatedUserSidecars(sql: SqlStorage): void {
-  if (!hasTable(sql, "pi_message_ui") || !hasTable(sql, "pi_submissions")) return;
-  const entries = new Map(sql.exec<{
-    id: string;
-    parent_id: string | null;
-    body: string;
-    submission_id: string | null;
-  }>(`
-    SELECT entry.id, entry.parent_id, entry.body, link.submission_id
-    FROM pi_entries AS entry
-    LEFT JOIN pi_session_entry_submission AS link ON link.entry_id = entry.id
-  `).toArray().map((row) => [row.id, { ...row, entry: JSON.parse(row.body) as Entry }]));
-  const candidates = sql.exec<{ message_id: string }>(`
-    SELECT ui.message_id
-    FROM pi_message_ui AS ui
-    JOIN pi_session_entry_submission AS link ON link.entry_id = ui.message_id
-    JOIN pi_submissions AS submission ON submission.submission_id = link.submission_id
-    WHERE json_extract(ui.body, '$.id') = submission.user_message_id
-  `).toArray();
-  for (const candidate of candidates) {
-    const current = entries.get(candidate.message_id);
-    if (current?.entry.type !== "message" || current.entry.message.role !== "user") continue;
-    let parentId = current.parent_id;
-    const visited = new Set<string>();
-    while (parentId !== null) {
-      if (visited.has(parentId)) throw new Error(`Cyclic Pi ancestry: ${parentId}`);
-      visited.add(parentId);
-      const parent = entries.get(parentId);
-      if (!parent) throw new Error(`Missing Pi ancestor: ${parentId}`);
-      if (parent.submission_id === current.submission_id &&
-        parent.entry.type === "message" && parent.entry.message.role === "user") {
-        // The copied parts are also wrong: canonical Steer content is authoritative.
-        sql.exec("DELETE FROM pi_message_ui WHERE message_id = ?", candidate.message_id);
-        break;
+  const links = hasTable(sql, "pi_session_entry_submission")
+    ? sql.exec<{ entry_id: string; submission_id: string }>("SELECT entry_id,submission_id FROM pi_session_entry_submission").toArray()
+    : hasTable(sql, "pi_session_message_submission") ? sql.exec<{ entry_id: string; submission_id: string }>("SELECT message_id AS entry_id,submission_id FROM pi_session_message_submission").toArray() : [];
+  const owners = new Map(links.map((row) => [row.entry_id, row.submission_id]));
+  const sidecars = hasTable(sql, "pi_message_ui")
+    ? sql.exec<{ entry_id: string; body: string }>("SELECT message_id AS entry_id,body FROM pi_message_ui").toArray()
+    : [];
+  const ui = new Map(sidecars.map((row) => [row.entry_id, row.body]));
+  // Older versions copied the initial user's view onto later Steers. Keep their canonical input instead.
+  if (current && hasTable(sql, "pi_submissions")) {
+    const initialUsers = new Map(sql.exec<{ submission_id: string; user_message_id: string | null }>(
+      "SELECT submission_id,user_message_id FROM pi_submissions",
+    ).toArray().map((row) => [row.submission_id, row.user_message_id]));
+    for (const [id, body] of ui) {
+      const owner = owners.get(id);
+      const entry = byId.get(id);
+      if (!owner || entry?.message?.role !== "user" || JSON.parse(body).id !== initialUsers.get(owner)) continue;
+      const visited = new Set<string>();
+      for (let parent = entry.parentId; parent; parent = byId.get(parent)?.parentId ?? null) {
+        if (visited.has(parent)) throw new Error(`Cyclic historical Pi ancestry: ${parent}`);
+        visited.add(parent);
+        if (owners.get(parent) === owner && byId.get(parent)?.message?.role === "user") {
+          ui.delete(id);
+          break;
+        }
       }
-      parentId = parent.parent_id;
     }
   }
-}
-
-function hasToolExecution(value: ToolExecution | undefined): boolean {
-  return value?.status === "blocked" ||
-    (value?.status === "executed" && value.args !== null &&
-      typeof value.args === "object" && !Array.isArray(value.args));
-}
-
-/** Old active tool outcomes cannot be reconstructed from error text or approval facts. */
-function assertActiveToolProvenance(sql: SqlStorage): void {
-  const read = <T>(address: Value<T>): T | undefined => {
-    const row = sql.exec<{ body: string }>(
-      "SELECT body FROM pi_values WHERE namespace = ? AND key = ?",
-      address.namespace, address.key,
-    ).toArray()[0];
-    return row ? JSON.parse(row.body) as T : undefined;
+  const commitResult = (id: string, outcome: Message) => {
+    const entry: LegacyEntry = { id, parentId: oldTip, type: "message", message: outcome, timestamp: outcome.timestamp };
+    entries.push(entry); byId.set(entry.id, entry); owners.set(entry.id, active!); oldTip = entry.id;
   };
-  const lanes = sql.exec<{ key: string; body: string }>(
-    "SELECT key, body FROM pi_values WHERE namespace = ?",
-    laneState("").namespace,
-  ).toArray();
-  for (const lane of lanes) {
-    const operationId = (JSON.parse(lane.body) as LaneState).currentOperationId;
-    if (operationId === null) continue;
-    const reject: (reason: string) => never = (reason) => {
-      throw new Error(
-        `Cannot upgrade Pi storage while operation ${operationId} is active: ${reason}. ` +
-        "Complete this operation with the previous runtime version, then retry the upgrade.",
-      );
-    };
-    const meta = read(operationMeta(operationId));
-    const state = read(operationState(operationId));
-    if (!meta || !state) reject("its durable operation metadata is incomplete");
-    let tip = read(branchTip(lane.key));
-    if (tip === undefined) reject("its lane branch tip is missing");
-    const visited = new Set<string>();
-    while (tip !== meta.sourceTipId) {
-      if (tip === null || visited.has(tip)) reject("its operation branch cannot be verified");
-      visited.add(tip);
-      const row = sql.exec<{ body: string }>("SELECT body FROM pi_entries WHERE id = ?", tip).toArray()[0];
-      if (!row) reject(`its canonical entry ${tip} is missing`);
-      const entry = JSON.parse(row.body) as Entry;
-      if (entry.type === "message" && entry.message.role === "toolResult" &&
-        !hasToolExecution(entry.toolExecution)) {
-        reject(`ToolResult ${entry.id} has no reliable execution provenance`);
-      }
-      tip = entry.parentId;
+  if (older && active && hasTable(sql, "pi_recovery_milestones")) {
+    const milestones = sql.exec<{ body: string }>("SELECT body FROM pi_recovery_milestones WHERE submission_id=? ORDER BY seq", active).toArray();
+    const recovered = replayPiToolRecovery(milestones.map((row) => row.body));
+    const existing = new Set(entries.flatMap((entry) => entry.message?.role === "toolResult" ? [entry.message.toolCallId] : []));
+    for (const call of Object.values(recovered.toolCalls)) {
+      if (existing.has(call.toolCallId)) continue;
+      const pending = Object.values(recovered.approvals).some((row) => row.toolCallId === call.toolCallId && row.status === "pending") || Object.values(recovered.interactions).some((row) => row.toolCallId === call.toolCallId && row.status === "pending");
+      const outcome = call.result ?? (!pending && call.retry === "non-idempotent" ? unknownOutcome({ id: call.toolCallId, name: call.toolName }, "Interrupted legacy effect; its outcome is unknown. Reconcile it before repeating it.") : undefined);
+      if (outcome) commitResult(`legacy-result:${active}:${call.toolCallId}`, outcome);
     }
-    if (state.at !== "tools") continue;
-    for (const call of state.batch.calls) {
-      if (call.status === "planned" || call.status === "completed") continue;
-      if (call.status === "effect_pending") {
-        reject(`Tool invocation ${call.resultEntryId} has an unresolved execution outcome`);
+  }
+  // An operation that cannot be resumed is settled as interrupted. It never replays an uncertain effect.
+  let interrupted: string | undefined;
+  const operation = active ? read<{ at: string; batch?: ToolBatch }>("pi.op.state", active) : undefined;
+  if (active && operation?.at === "tools") {
+    const message = operation.batch ? byId.get(operation.batch.assistantEntryId)?.message : undefined;
+    const assistant = message?.role === "assistant" ? message : undefined;
+    if (!assistant) interrupted = "Historical Tool batch has no canonical assistant";
+    for (const call of assistant ? operation.batch!.calls : []) {
+      const part = assistant!.content[call.sourceIndex];
+      if (typeof part !== "object" || part?.type !== "toolCall") { interrupted = "Historical Tool batch index is invalid"; continue; }
+      const tool = part;
+      if (call.status === "completed") continue;
+      let outcome = read<{ type?: string; payload?: Message }>("pi.pending.entry", call.resultEntryId)?.payload;
+      if (outcome && (outcome.role !== "toolResult" || outcome.toolCallId !== tool.id || outcome.toolName !== tool.name)) {
+        warn(`Historical Tool outcome ${call.resultEntryId} conflicts with its call`);
+        outcome = unknownOutcome(tool);
       }
-      const pending = read(pendingEntry(call.resultEntryId));
-      if (pending?.type !== "message" || pending.payload.role !== "toolResult" ||
-        !hasToolExecution(pending.toolExecution)) {
-        reject(`pending ToolResult ${call.resultEntryId} has no reliable execution provenance`);
+      if (call.status === "outcome_ready" && outcome?.role !== "toolResult") {
+        warn(`Historical Tool outcome ${call.resultEntryId} is missing`);
+        outcome = unknownOutcome(tool);
       }
+      if (call.status === "effect_pending" && call.replay !== "safe") outcome = unknownOutcome(tool);
+      if (outcome) commitResult(call.resultEntryId, outcome);
     }
+  } else if (active && operation && !RESUMABLE_PHASES.has(operation.at)) {
+    interrupted = `Historical operation ${operation.at} cannot resume natively`;
   }
-}
-
-/** Upgrade an already-Harness-backed Session before normal reads begin. */
-export function migrateCurrentPiSession(
-  storage: DurableObjectStorage,
-): boolean {
-  return storage.transactionSync(() => {
-    const sql = storage.sql;
-    if (!hasTable(sql, "pi_storage_state")) return false;
-    const version = sql.exec<{ storage_version: number }>(
-      "SELECT storage_version FROM pi_storage_state WHERE singleton = 1",
-    ).one().storage_version;
-    if (version === CURRENT_PI_STORAGE_VERSION) return false;
-    if (version !== 1 && version !== 2) {
-      throw new Error(`Unsupported Cloudflare Pi storage version: ${version}`);
+  const branch = (tip: string | null): LegacyEntry[] => {
+    const chain: LegacyEntry[] = [];
+    for (let id = tip; id; id = byId.get(id)?.parentId ?? null) {
+      const entry = byId.get(id);
+      if (!entry) throw new Error("Historical branch is invalid");
+      chain.unshift(entry);
     }
-    assertActiveToolProvenance(sql);
-    if (version === 1) removeRetiredRuntimeArtifacts(sql);
-    repairDuplicatedUserSidecars(sql);
-    sql.exec(
-      "UPDATE pi_storage_state SET storage_version = ? WHERE singleton = 1",
-      CURRENT_PI_STORAGE_VERSION,
-    );
-    return true;
-  });
-}
-
-function assertSameToolResult(
-  left: ToolResultMessage,
-  right: ToolResultMessage,
-): void {
-  for (const key of [
-    "toolCallId",
-    "toolName",
-    "content",
-    "details",
-    "usage",
-    "addedToolNames",
-    "isError",
-  ] as const) {
-    if (!isEqual(left[key], right[key]))
-      throw new Error(`Conflicting legacy Tool result: ${left.toolCallId}`);
-  }
-}
-
-function legacyToolResultMessage(input: {
-  toolCallId: string;
-  toolName: string;
-  result: AgentToolResult<unknown>;
-  isError: boolean;
-  timestamp: number;
-}): ToolResultMessage {
-  return {
-    role: "toolResult",
-    toolCallId: input.toolCallId,
-    toolName: input.toolName,
-    content: input.result.content ?? [],
-    details: input.result.details,
-    ...(input.result.usage ? { usage: input.result.usage } : {}),
-    ...(input.result.addedToolNames?.length
-      ? { addedToolNames: input.result.addedToolNames }
-      : {}),
-    isError: input.isError,
-    timestamp: input.timestamp,
+    return chain;
   };
-}
+  let owned = active ? branch(oldTip).filter((entry) => owners.get(entry.id) === active) : [];
+  let prompt = owned.find((entry) => entry.message?.role === "user");
+  if (active && !prompt) interrupted ??= "Active historical operation has no canonical user input";
+  if (active && interrupted) {
+    warn(`Settled legacy operation ${active} as interrupted: ${interrupted}`);
+    const assistant = [...owned].reverse().find((entry) => entry.message?.role === "assistant")?.message;
+    const settled = new Set(owned.flatMap((entry) => entry.message?.role === "toolResult" ? [entry.message.toolCallId] : []));
+    for (const part of assistant?.role === "assistant" ? assistant.content : []) {
+      if (part.type === "toolCall" && !settled.has(part.id)) commitResult(`legacy-interrupted:${active}:${part.id}`, unknownOutcome(part));
+    }
+    owned = branch(oldTip).filter((entry) => owners.get(entry.id) === active);
+    prompt = owned.find((entry) => entry.message?.role === "user");
+  }
+  // Pi finished these operations before the Host recorded their terminal; settle them instead of rerunning input.
+  const finished = hostRows.flatMap((row) => {
+    if (row.submission_id === active || !["pending", "running"].includes(row.status)) return [];
+    const result = read<LegacyResult>("pi.result", row.submission_id);
+    return result ? [{ id: row.submission_id, result }] : [];
+  });
+  const converted = new Map<string, EntryRecord>();
+  // Where a child continues; a compaction's retained context belongs to every branch through it.
+  const anchors = new Map<string, EntryRecord>();
+  const conversationByEntry = new Map<string, ConversationId>();
+  const tips = new Map<ConversationId, string>();
+  const copiedUi: Array<{ id: string; body: string }> = [];
+  const copiedLinks: Array<{ id: string; submissionId: string }> = [];
 
-/**
- * Called synchronously during DO startup, before admission or recovery can execute.
- * Durable pending work keeps its IDs and state; no old executor runs across this boundary.
- * A dry run exercises the real import then rolls back DDL, records, and the format switch together.
- */
-export function migrateLegacyPiSession(
-  storage: DurableObjectStorage,
-  options: { dryRun: boolean },
-): PiSessionMigrationReport {
-  const sql = storage.sql;
-  let report!: PiSessionMigrationReport;
-  const rollbackDryRun = new Error("rollback migration dry run");
-  try {
-    storage.transactionSync(() => {
-      if (hasTable(sql, "pi_storage_state")) {
-        migrateCurrentPiSession(storage);
-        const store = new CloudflareSessionStorage(storage);
-        report = {
-          sourceEntries: 0,
-          entries: store.entries().length,
-          tip: store.branch().at(-1)?.id ?? null,
-          alreadyMigrated: true,
-        };
-        return;
-      }
-      if (
-        !hasTable(sql, "pi_session_entries") ||
-        !hasTable(sql, "pi_session_metadata")
-      )
-        throw new Error("Missing legacy session snapshot");
-      const metadata = sql
-        .exec<{
-          id: string;
-          created_at: string;
-        }>("SELECT id, created_at FROM pi_session_metadata WHERE singleton = 1")
-        .one();
-      const createdAt = time(metadata.created_at);
-      const rows = sql
-        .exec<{
-          seq: number;
-          id: string;
-          body: string;
-        }>("SELECT seq, id, body FROM pi_session_entries ORDER BY seq")
-        .toArray();
-      const records = new Map<string, LegacyRecord>();
-      for (const row of rows) {
-        const raw = object(JSON.parse(row.body));
-        if (raw.id !== row.id || !row.id || records.has(row.id))
-          throw new Error("Invalid or duplicate legacy entry ID");
-        if (
-          raw.parentId !== null &&
-          (typeof raw.parentId !== "string" || !records.has(raw.parentId))
-        )
-          throw new Error(`Missing or forward legacy parent: ${row.id}`);
-        time(raw.timestamp);
-        text(raw.type);
-        records.set(row.id, raw as LegacyRecord);
-      }
-      const converted = new Map<string, Entry>();
-      const resolved = new Map<string, string | null>();
-      const values: Write[] = [];
-      const resolve = (id: unknown): string | null => {
-        if (id === null) return null;
-        const key = text(id);
-        if (converted.has(key)) return key;
-        if (!resolved.has(key))
-          throw new Error(`Unknown legacy reference: ${key}`);
-        return resolved.get(key)!;
-      };
-      for (const [index, row] of rows.entries()) {
-        const raw = records.get(row.id)!;
-        const parentId = resolve(raw.parentId);
-        const timestamp = time(raw.timestamp);
-        const base = { id: raw.id, parentId, timestamp, seq: index + 1 };
-        let entry: Entry | undefined;
-        switch (raw.type) {
-          case "message":
-            entry = { ...base, type: "message", message: message(raw.message) };
-            break;
-          case "custom_message":
-            entry = {
-              ...base,
-              type: "message",
-              message: {
-                role: "custom",
-                customType: text(raw.customType),
-                content: raw.content,
-                details: raw.details,
-                display: raw.display,
-                timestamp,
-              } as AgentMessage,
-            };
-            break;
-          case "custom":
-            entry = {
-              ...base,
-              type: "custom",
-              customType: text(raw.customType),
-              ...(raw.data === undefined
-                ? {}
-                : { data: raw.data as JsonValue }),
-            };
-            break;
-          case "branch_summary":
-            entry = {
-              ...base,
-              type: "branch_summary",
-              fromId: raw.fromId === "root" ? null : resolve(raw.fromId),
-              summary: text(raw.summary),
-              fromHook: raw.fromHook === true,
-              ...(raw.details === undefined
-                ? {}
-                : { details: raw.details as JsonValue }),
-              ...(raw.usage === undefined ? {} : { usage: raw.usage as Usage }),
-            };
-            break;
-          case "compaction": {
-            let retainedTail: AgentMessage[];
-            if (Array.isArray(raw.retainedTail))
-              retainedTail = raw.retainedTail.map(message);
-            else {
-              const kept = text(raw.firstKeptEntryId);
-              const tail: Entry[] = [];
-              let cursor = raw.parentId;
-              let found = false;
-              while (cursor !== null) {
-                const ancestor = records.get(cursor);
-                if (!ancestor)
-                  throw new Error(`Missing compaction ancestor: ${cursor}`);
-                const convertedEntry = converted.get(cursor);
-                if (convertedEntry) tail.unshift(convertedEntry);
-                if (cursor === kept) {
-                  found = true;
-                  break;
-                }
-                cursor = ancestor.parentId;
-              }
-              if (!found)
-                throw new Error(
-                  `Compaction retained tail is not on its historical branch: ${raw.id}`,
-                );
-              retainedTail = tail.flatMap(sessionEntryToContextMessages);
-            }
-            entry = {
-              ...base,
-              type: "compaction",
-              summary: text(raw.summary),
-              retainedTail,
-              tokensBefore: finite(raw.tokensBefore),
-              fromHook: raw.fromHook === true,
-              ...(raw.details === undefined
-                ? {}
-                : { details: raw.details as JsonValue }),
-              ...(raw.usage === undefined ? {} : { usage: raw.usage as Usage }),
-            };
-            break;
-          }
-          case "leaf":
-            resolved.set(raw.id, resolve(raw.targetId));
-            break;
-          case "label": {
-            const target = resolve(raw.targetId);
-            if (!target)
-              throw new Error(`Label has no content target: ${raw.id}`);
-            values.push(
-              raw.label === undefined
-                ? deleteValue(entryLabel(target))
-                : setValue(entryLabel(target), text(raw.label)),
-            );
-            resolved.set(raw.id, parentId);
-            break;
-          }
-          case "session_info":
-            if (raw.name !== undefined)
-              values.push(setValue(sessionName, text(raw.name)));
-            resolved.set(raw.id, parentId);
-            break;
-          case "model_change":
-          case "thinking_level_change":
-          case "active_tools_change": {
-            // Historical settings are values, not conversation entries or a second execution lane.
-            const setting =
-              raw.type === "model_change"
-                ? { provider: text(raw.provider), modelId: text(raw.modelId) }
-                : raw.type === "thinking_level_change"
-                  ? text(raw.thinkingLevel)
-                  : raw.activeToolNames;
-            if (setting === undefined)
-              throw new Error(`Missing legacy configuration: ${raw.id}`);
-            values.push(
-              setValue(value(`springbrand.history.${raw.type}`, raw.id), {
-                at: parentId,
-                timestamp,
-                setting,
-              }),
-            );
-            resolved.set(raw.id, parentId);
-            break;
-          }
-          default:
-            throw new Error(`Unsupported legacy entry type: ${raw.type}`);
-        }
-        if (entry) converted.set(raw.id, entry);
-      }
-      const tip = rows.length ? resolve(rows.at(-1)!.id) : null;
-      if (hasTable(sql, "pi_session_message_submission")) {
-        for (const link of sql
-          .exec<{
-            message_id: string;
-            submission_id: string;
-          }>(
-            "SELECT message_id, submission_id FROM pi_session_message_submission",
-          )
-          .toArray()) {
-          if (converted.get(link.message_id)?.type !== "message")
-            throw new Error(`Dangling message association: ${link.message_id}`);
-          const persistedSubmission =
-            hasTable(sql, "pi_submissions") &&
-            sql
-              .exec(
-                "SELECT 1 FROM pi_submissions WHERE submission_id = ?",
-                link.submission_id,
-              )
-              .toArray().length > 0;
-          if (!persistedSubmission) {
-            let ancestor = converted.get(link.message_id);
-            while (
-              ancestor &&
-              !(ancestor.type === "message" && ancestor.message.role === "user")
-            )
-              ancestor = ancestor.parentId
-                ? converted.get(ancestor.parentId)
-                : undefined;
-            if (!ancestor || link.submission_id !== `import:${ancestor.id}`)
-              throw new Error(
-                `Dangling submission association: ${link.submission_id}`,
-              );
-          }
-        }
-      }
-      const messageOwners = new Map(
-        hasTable(sql, "pi_session_message_submission")
-          ? sql
-              .exec<{ message_id: string; submission_id: string }>(
-                "SELECT message_id, submission_id FROM pi_session_message_submission",
-              )
-              .toArray()
-              .map((row) => [row.message_id, row.submission_id] as const)
-          : [],
-      );
-      const results = new Map<string, ToolResultMessage>();
-      for (const entry of converted.values()) {
-        if (entry.type !== "message" || entry.message.role !== "toolResult")
-          continue;
-        const result = entry.message;
-        let ancestor = entry.parentId
-          ? converted.get(entry.parentId)
-          : undefined;
-        let found = false;
-        while (ancestor) {
-          if (
-            ancestor.type === "message" &&
-            ancestor.message.role === "assistant"
-          ) {
-            const call = ancestor.message.content.find(
-              (block) =>
-                block.type === "toolCall" && block.id === result.toolCallId,
-            );
-            if (call?.type === "toolCall") {
-              if (call.name !== result.toolName)
-                throw new Error("Mismatched legacy Tool name");
-              found = true;
-              break;
-            }
-          }
-          ancestor = ancestor.parentId
-            ? converted.get(ancestor.parentId)
-            : undefined;
-        }
-        if (!found)
-          throw new Error(`Orphan legacy Tool result: ${result.toolCallId}`);
-        const owner = messageOwners.get(entry.id);
-        if (owner) {
-          const key = `${owner}:${result.toolCallId}`;
-          const previous = results.get(key);
-          if (previous) assertSameToolResult(previous, result);
-          results.set(key, result);
-        }
-      }
-      if (hasTable(sql, "pi_pending_steers")) {
-        for (const steer of sql
-          .exec<{
-            submission_id: string;
-            message_id: string;
-            canonical_json: string;
-          }>(
-            "SELECT submission_id, message_id, canonical_json FROM pi_pending_steers",
-          )
-          .toArray()) {
-          if (
-            !hasTable(sql, "pi_submissions") ||
-            !sql
-              .exec(
-                "SELECT 1 FROM pi_submissions WHERE submission_id = ?",
-                steer.submission_id,
-              )
-              .toArray().length
-          ) {
-            throw new Error("Dangling pending steer submission");
-          }
-          const pending = message(JSON.parse(steer.canonical_json));
-          if (pending.role !== "user" || converted.has(steer.message_id)) {
-            throw new Error("Invalid or already committed pending steer");
-          }
-        }
-      }
-      // Business records keep their stable IDs and payloads. Validate ownership before switching.
-      if (hasTable(sql, "pi_submissions")) {
-        const submissions = sql
-          .exec<{
-            submission_id: string;
-            status: string;
-            queued_input_json: string | null;
-            queued_ui_message_json: string | null;
-            user_message_id: string | null;
-            regenerate_message_id: string | null;
-          }>("SELECT * FROM pi_submissions")
-          .toArray();
-        const knownSubmissions = new Set(
-          submissions.map((row) => row.submission_id),
-        );
-        for (const submission of submissions) {
-          if (submission.status !== "pending" || !submission.queued_input_json)
-            continue;
-          const queued = message(JSON.parse(submission.queued_input_json));
-          if (queued.role !== "user" || !submission.user_message_id) {
-            throw new Error("Invalid queued user message");
-          }
-          if (
-            submission.queued_ui_message_json &&
-            object(JSON.parse(submission.queued_ui_message_json)).role !==
-              "user"
-          ) {
-            throw new Error("Invalid queued UI user message");
-          }
-          if (submission.regenerate_message_id) {
-            const target = converted.get(submission.regenerate_message_id);
-            if (
-              target?.type !== "message" ||
-              target.message.role !== "user" ||
-              !isEqual(
-                typeof target.message.content === "string"
-                  ? [{ type: "text", text: target.message.content }]
-                  : target.message.content,
-                typeof queued.content === "string"
-                  ? [{ type: "text", text: queued.content }]
-                  : queued.content,
-              )
-            ) {
-              throw new Error("Invalid queued regeneration target");
-            }
-          } else if (converted.has(submission.user_message_id)) {
-            throw new Error("Queued user message is already committed");
-          }
+  await storage.transaction(async () => {
+    const initial = await session.commit((tx) => tx.createConversation({ ownership: { kind: "ownerless" } }), BACKGROUND_CONTEXT);
+    let selected = initial.id;
+    for (const entry of entries) {
+      await session.commit(async (tx) => {
+        if (!entry.id || (entry.parentId !== null && !byId.has(entry.parentId))) {
+          throw new Error(`Historical Pi entry has a missing parent: ${entry.id}`);
         }
-        const toolInputs = new Set<string>();
-        if (hasTable(sql, "pi_recovery_milestones")) {
-          const bySubmission = new Map<string, string[]>();
-          for (const row of sql
-            .exec<{
-              submission_id: string;
-              body: string;
-            }>(
-              "SELECT submission_id, body FROM pi_recovery_milestones ORDER BY submission_id, seq",
-            )
-            .toArray()) {
-            if (!knownSubmissions.has(row.submission_id))
-              throw new Error("Dangling recovery submission");
-            const record = decodePiToolRecoveryMilestone(row.body);
-            if (!record || record.turnId !== row.submission_id)
-              throw new Error("Invalid legacy recovery milestone");
-            const bodies = bySubmission.get(row.submission_id) ?? [];
-            bodies.push(row.body);
-            bySubmission.set(row.submission_id, bodies);
-            if (record.type === "tool-result" || record.type === "tool-error") {
-              for (const result of replayPiToolRecovery([row.body])
-                .canonicalToolResults) {
-                const key = `${row.submission_id}:${result.toolCallId}`;
-                const previous = results.get(key);
-                if (previous) assertSameToolResult(previous, result);
-                results.set(key, result);
-              }
-            }
-          }
-          for (const [submissionId, bodies] of bySubmission) {
-            const recovered = replayPiToolRecovery(bodies);
-            for (const call of Object.values(recovered.toolCalls)) {
-              if (call.input !== undefined || call.retry !== undefined)
-                toolInputs.add(`${submissionId}:${call.toolCallId}`);
-              if (call.result) {
-                const key = `${submissionId}:${call.toolCallId}`;
-                const previous = results.get(key);
-                if (previous) assertSameToolResult(previous, call.result);
-                results.set(key, call.result);
-              }
-            }
-          }
+        const parent = entry.parentId ? anchors.get(entry.parentId) : undefined;
+        if (entry.parentId && !parent) throw new Error(`Historical Pi entry is out of order: ${entry.id}`);
+        let conversationId = parent ? conversationByEntry.get(entry.parentId!)! : initial.id;
+        if (parent && tips.get(conversationId) !== entry.parentId) {
+          conversationId = (await tx.forkConversation(conversationId, parent.id, { ownership: { kind: "ownerless" } })).id;
         }
-        if (hasTable(sql, "pi_session_message_submission")) {
-          for (const row of sql
-            .exec<{
-              message_id: string;
-              submission_id: string;
-            }>(
-              "SELECT message_id, submission_id FROM pi_session_message_submission",
-            )
-            .toArray()) {
-            const entry = converted.get(row.message_id);
-            if (
-              entry?.type === "message" &&
-              entry.message.role === "assistant"
-            ) {
-              for (const block of entry.message.content)
-                if (block.type === "toolCall")
-                  toolInputs.add(`${row.submission_id}:${block.id}`);
+        const message = entry.message;
+        let record: EntryRecord;
+        let anchor: EntryRecord;
+        if (entry.type === "message" && message) {
+          const role = (message as { role: string }).role;
+          record = anchor = await tx.appendEntry(conversationId, {
+            kind: role === "toolResult" ? "pi.tool-result" : role === "custom" ? "springbrand.custom" : `pi.${role}`,
+            ...(role === "custom" ? customModel(message, timestamp(entry)) : { model: [message] }),
+            data: JSON.parse(JSON.stringify({ displayId: entry.id, createdAt: timestamp(entry), ...(role === "custom" ? { message } : {}), ...(role === "toolResult" ? { diagnostics: [] } : {}) })),
+          });
+        } else if (entry.type === "compaction" || entry.type === "branch_summary") {
+          record = anchor = await tx.appendEntry(conversationId, {
+            kind: "pi.compaction", model: [{ role: "user", content: `<summary>\n${entry.summary ?? ""}\n</summary>`, timestamp: timestamp(entry) }],
+            head: "self", data: { reason: "manual", displayId: entry.id, createdAt: timestamp(entry) },
+          });
+          let retainedTail = entry.retainedTail;
+          if (!retainedTail && entry.firstKeptEntryId) {
+            const tail: Message[] = [];
+            let cursor = entry.parentId;
+            while (cursor) {
+              const ancestor = byId.get(cursor);
+              if (!ancestor) throw new Error("Historical compaction has a missing ancestor");
+              if (ancestor.message) tail.unshift(ancestor.message);
+              if (cursor === entry.firstKeptEntryId) break;
+              cursor = ancestor.parentId;
             }
+            if (!cursor) throw new Error("Historical compaction tail is outside its branch");
+            retainedTail = tail;
           }
-        }
-        for (const table of [
-          "pi_tool_settlements",
-          "pi_approvals",
-          "pi_tool_interactions",
-        ]) {
-          if (!hasTable(sql, table)) continue;
-          for (const row of sql
-            .exec<{
-              submission_id: string;
-              tool_call_id: string;
-            }>(`SELECT submission_id, tool_call_id FROM ${table}`)
-            .toArray()) {
-            if (
-              !knownSubmissions.has(row.submission_id) ||
-              !toolInputs.has(`${row.submission_id}:${row.tool_call_id}`)
-            )
-              throw new Error(`Dangling Tool association in ${table}`);
+          for (const retained of retainedTail ?? []) {
+            anchor = await tx.appendEntry(conversationId, { kind: "springbrand.retained-context", model: [retained] });
           }
+        } else {
+          record = anchor = await tx.appendEntry(conversationId, { kind: "springbrand.history", data: { displayId: entry.id, createdAt: timestamp(entry), record: entry as unknown as Record<string, never> } });
         }
+        converted.set(entry.id, record);
+        anchors.set(entry.id, anchor);
+        conversationByEntry.set(entry.id, conversationId);
+        tips.set(conversationId, entry.id);
+        if (entry.id === oldTip) selected = conversationId;
+        if (owners.has(entry.id)) copiedLinks.push({ id: String(record.id), submissionId: owners.get(entry.id)! });
+        if (ui.has(entry.id)) copiedUi.push({ id: String(record.id), body: ui.get(entry.id)! });
+      }, BACKGROUND_CONTEXT);
+    }
+    if (oldTip === null && entries.length) {
+      selected = (await session.commit((tx) => tx.createConversation({ ownership: { kind: "ownerless" } }), BACKGROUND_CONTEXT)).id;
+    } else if (oldTip && tips.get(selected) !== oldTip) {
+      const tip = anchors.get(oldTip);
+      if (!tip) throw new Error("Historical branch tip is missing");
+      selected = (await session.commit((tx) => tx.forkConversation(tip.conversationId, tip.id, { ownership: { kind: "ownerless" } }), BACKGROUND_CONTEXT)).id;
+    }
+    await session.commit(async (tx) => {
+      const pointer = await tx.doc(RuntimeConversation);
+      pointer.id = selected;
+      const config = read<Record<string, unknown>>("pi.lane.config", "main");
+      if (config) {
+        const agent = await tx.doc(AgentDoc, selected);
+        if (config.model) agent.model = config.model as { provider: string; modelId: string };
+        if (typeof config.thinkingLevel === "string") agent.thinkingLevel = config.thinkingLevel as typeof agent.thinkingLevel;
+        if (Array.isArray(config.activeToolNames)) agent.tools = config.activeToolNames as string[];
       }
-      if (hasTable(sql, "pi_tool_settlements")) {
-        for (const row of sql
-          .exec<{
-            submission_id: string;
-            tool_call_id: string;
-            tool_name: string;
-            result: string;
-            is_error: number;
-            created_at: number;
-          }>(
-            "SELECT submission_id, tool_call_id, tool_name, result, is_error, created_at FROM pi_tool_settlements",
-          )
-          .toArray()) {
-          const expected = legacyToolResultMessage({
-            toolCallId: row.tool_call_id,
-            toolName: row.tool_name,
-            result: JSON.parse(row.result) as AgentToolResult<unknown>,
-            isError: row.is_error === 1,
-            timestamp: row.created_at,
+      const selectedBranch = branch(oldTip);
+      for (const { id, result } of finished) {
+        const ownedBySubmission = selectedBranch.filter((entry) => owners.get(entry.id) === id);
+        const input = ownedBySubmission.find((entry) => entry.message?.role === "user");
+        const reply = [...ownedBySubmission].reverse().find((entry) => entry.message?.role === "assistant");
+        const entry = input ? converted.get(input.id)!.id : undefined;
+        if ((result.status === "completed" || result.status === "declined") && entry !== undefined && reply) {
+          await tx.createSubmission({ conversationId: selected, requestId: id, type: "input", status: "done", entry, answer: converted.get(reply.id)!.id });
+        } else {
+          await tx.createSubmission({
+            conversationId: selected, requestId: id, type: "input", status: "unanswered",
+            reason: result.status === "aborted" ? "aborted" : result.status ?? "failed",
+            detail: result.error?.message ?? (result.status === "aborted" ? "Cancelled" : "The legacy request ended without an answer."),
+            ...(entry !== undefined ? { entry } : {}),
           });
-          const recorded = results.get(
-            `${row.submission_id}:${row.tool_call_id}`,
-          );
-          if (recorded) assertSameToolResult(recorded, expected);
         }
       }
-      // The old table remains an inert backup. Failure rolls back DDL, data and the version together.
-      sql.exec(
-        "ALTER TABLE pi_session_entries RENAME TO pi_legacy_entries_backup",
-      );
-      const store = new CloudflareSessionStorage(storage);
-      removeRetiredRuntimeArtifacts(sql);
-      for (const entry of converted.values()) {
-        const { seq: _seq, timestamp, ...next } = entry;
-        const writes: Write[] = [insertEntry(next)];
-        const usage =
-          entry.type === "message" &&
-          (entry.message.role === "assistant" ||
-            entry.message.role === "toolResult")
-            ? entry.message.usage
-            : entry.type === "compaction" || entry.type === "branch_summary"
-              ? entry.usage
-              : undefined;
-        if (usage) {
-          let usageId = `migration:usage:${entry.id}`;
-          while (records.has(usageId)) usageId = `migration:${usageId}`;
-          writes.push(
-            insertUsage({
-              id: usageId,
-              entryId: entry.id,
-              usage,
-              adjustment: false,
-            }),
-          );
+      if (active && interrupted) {
+        await tx.createSubmission({
+          conversationId: selected, requestId: active, type: "input", status: "unanswered", reason: "interrupted", detail: INTERRUPTED,
+          ...(prompt ? { entry: converted.get(prompt.id)!.id } : {}),
+        });
+      } else if (active && prompt) {
+        const promptEntry = converted.get(prompt.id)!;
+        const submission = await tx.createSubmission({ conversationId: selected, requestId: active, type: "input", status: "placed", entry: promptEntry.id });
+        const assistant = [...owned].reverse().find((entry) => entry.message?.role === "assistant");
+        const settledCalls = new Set(owned.flatMap((entry) => entry.message?.role === "toolResult" ? [entry.message.toolCallId] : []));
+        const calls = assistant?.message?.role === "assistant"
+          ? assistant.message.content.filter((part): part is import("@earendil-works/pi-ai").ToolCall => part.type === "toolCall").filter((part) => !settledCalls.has(part.id))
+          : [];
+        // Initialize the official generation checkpoint; only unfinished calls enter its pending list.
+        const checkpoint: GenerationCheckpoint = assistant && calls.length
+          ? { phase: "tools", assistant: converted.get(assistant.id)!.id, tools: [], pending: calls.map((call) => call.id) }
+          : { phase: "prepare", attempt: 0 };
+        const generation = await tx.createTask({ definition: { ...GenerationTask.definition, initial: () => checkpoint } }, {}, { conversationId: selected, ownership: { kind: "conversation" } });
+        const live = await tx.doc(LiveDoc, selected);
+        live.run = { taskId: generation, inputs: [submission.id] };
+        if (calls.length) live.tools = calls.map((call) => ({ callId: call.id, name: call.name, status: "pending" }));
+      }
+      (await tx.doc(Migration)).completed = true;
+    }, BACKGROUND_CONTEXT);
+    sql.exec("CREATE TABLE IF NOT EXISTS pi_session_entry_submission (entry_id TEXT PRIMARY KEY, submission_id TEXT NOT NULL)");
+    for (const link of copiedLinks) sql.exec("INSERT OR IGNORE INTO pi_session_entry_submission VALUES (?,?)", link.id, link.submissionId);
+    for (const sidecar of copiedUi) sql.exec("INSERT OR IGNORE INTO pi_message_ui VALUES (?,?)", sidecar.id, sidecar.body);
+    if (hasTable(sql, "pi_pending_steers")) {
+      // Old Pi committed these Steers but the Host receipt survived; a native requeue would duplicate them.
+      const steers = sql.exec<{ message_id: string; harness_entry_id: string | null; ui_message_json: string | null }>("SELECT message_id,harness_entry_id,ui_message_json FROM pi_pending_steers").toArray();
+      for (const steer of steers) {
+        const record = converted.get(steer.harness_entry_id ?? "") ?? converted.get(steer.message_id);
+        if (!record) continue;
+        if (steer.ui_message_json) {
+          sql.exec("CREATE TABLE IF NOT EXISTS pi_message_ui (message_id TEXT PRIMARY KEY, body TEXT NOT NULL)");
+          sql.exec("INSERT OR IGNORE INTO pi_message_ui VALUES (?,?)", String(record.id), steer.ui_message_json);
         }
-        const result = store.commitSync(writes);
-        // Import timestamps belong to the historical snapshot, not the time of the migration.
-        sql.exec(
-          "UPDATE pi_entries SET timestamp = ?, body = json_set(body, '$.timestamp', ?) WHERE id = ?",
-          timestamp,
-          timestamp,
-          entry.id,
-        );
-        entry.seq = result.firstSeq;
+        sql.exec("DELETE FROM pi_pending_steers WHERE message_id=?", steer.message_id);
       }
-      const parents = new Set(
-        [...converted.values()].map((entry) => entry.parentId),
-      );
-      for (const entry of converted.values()) {
-        if (entry.id !== tip && !parents.has(entry.id))
-          values.push(setValue(branchTip(`history:${entry.id}`), entry.id));
+    }
+    for (const table of ["pi_approvals", "pi_tool_interactions"]) {
+      if (!hasTable(sql, table)) continue;
+      const rows = sql.exec<{ rowid: number; input_json: string }>(`SELECT rowid,input_json FROM ${table} WHERE tool_name='ask_user'`).toArray();
+      for (const row of rows) sql.exec(`UPDATE ${table} SET input_json=? WHERE rowid=?`, JSON.stringify(normalizeLegacyAskUserInput(JSON.parse(row.input_json))), row.rowid);
+      // An interrupted operation can no longer continue its parked call, so its decision must not park Host recovery.
+      if (active && interrupted && hasColumns(sql, table, ["submission_id", "status"])) {
+        sql.exec(`UPDATE ${table} SET status=? WHERE submission_id=? AND status='pending'`, table === "pi_approvals" ? "rejected" : "cancelled", active);
       }
-      store.commitSync([...values, setValue(branchTip("main"), tip)]);
-      repairDuplicatedUserSidecars(sql);
-      sql.exec(
-        "UPDATE pi_storage_state SET session_id = ?, created_at = ? WHERE singleton = 1",
-        metadata.id,
-        createdAt,
-      );
-      report = {
-        sourceEntries: rows.length,
-        entries: converted.size,
-        tip,
-        alreadyMigrated: false,
-      };
-      if (options.dryRun) throw rollbackDryRun;
-    });
-  } catch (error) {
-    if (error !== rollbackDryRun) throw error;
-  }
-  return report;
+    }
+    if (hasTable(sql, "cf_agents_schedules")) {
+      for (const callback of ["_cleanupStreamBuffers", "_piPlannedContinuation", "_piContinuationWatchdog", "_piApprovalContinuation", "_chatRecoveryRetry"]) sql.exec("DELETE FROM cf_agents_schedules WHERE callback=?", callback);
+    }
+  });
+}
+
+function hasColumns(sql: SqlStorage, table: string, names: string[]): boolean {
+  const columns = new Set(sql.exec<{ name: string }>(`PRAGMA table_info(${table})`).toArray().map((row) => row.name));
+  return names.every((name) => columns.has(name));
+}
+
+const LEGACY_TABLES = [
+  "pi_entries", "pi_values", "pi_lists", "pi_usage", "pi_storage_state", "pi_session_entries", "pi_session_metadata",
+  "pi_legacy_entries_backup", "pi_recovery_milestones", "pi_session_message_submission", "pi_tool_settlements",
+];
+
+/** Drops the inert pre-upgrade baseline once the migrated history it backs up is deleted. */
+export async function dropLegacyPiTables(storage: DurableObjectStorage, session: Session): Promise<void> {
+  if (!(await session.snapshot(Migration, BACKGROUND_CONTEXT))?.completed) throw new Error("Legacy Pi tables are still the migration source");
+  for (const table of LEGACY_TABLES) storage.sql.exec(`DROP TABLE IF EXISTS ${table}`);
 }