@opencode-ai/core 0.0.0-next-17293

package/dist/database/v1-migration.bun.js

@@ -0,0 +1,739 @@
+import {
+  exports_v1_migration
+} from "../chunks/permission-byab506k.js";
+import {
+  KVTable
+} from "../chunks/permission-wmxdh12w.js";
+import {
+  exports_message
+} from "../chunks/permission-25pxtba7.js";
+import {
+  SessionMessageTable,
+  SessionTable
+} from "../chunks/permission-zvvp2xr4.js";
+import {
+  exports_schema
+} from "../chunks/permission-y8rs54ne.js";
+import {
+  EventSequenceTable
+} from "../chunks/permission-zsf8rs93.js";
+import"../chunks/permission-88jbfw8z.js";
+import"../chunks/permission-zbqqnp0n.js";
+import"../chunks/permission-sem2g21k.js";
+import {
+  exports_database
+} from "../chunks/permission-8w2n8x74.js";
+import"../chunks/permission-4szcs9x3.js";
+import"../chunks/permission-hy0hzg1s.js";
+import"../chunks/permission-707etsmq.js";
+import"../chunks/permission-906y0b6d.js";
+import"../chunks/permission-8nn8kqcn.js";
+import"../chunks/permission-z47nswr2.js";
+import"../chunks/permission-ghwjy7my.js";
+import"../chunks/permission-faypg4r1.js";
+import"../chunks/permission-3g3rpp2x.js";
+import"../chunks/permission-wwntjmk1.js";
+import"../chunks/permission-f4cp4g4a.js";
+import"../chunks/permission-5va1yh78.js";
+import"../chunks/permission-47ty4mvs.js";
+import"../chunks/permission-tmb1f636.js";
+import"../chunks/permission-ghm4673n.js";
+import"../chunks/permission-se76j685.js";
+import"../chunks/permission-9dct5xhx.js";
+import"../chunks/permission-6yt963b8.js";
+import"../chunks/permission-8sj3ajy5.js";
+import"../chunks/permission-x4q807cx.js";
+import"../chunks/permission-ayevdmef.js";
+import"../chunks/permission-wyqjaaa5.js";
+import"../chunks/permission-kxy11nzk.js";
+import"../chunks/permission-wx89ywv3.js";
+import"../chunks/permission-3w3ybtfd.js";
+import"../chunks/permission-qp95y4jb.js";
+import"../chunks/permission-b02txbh8.js";
+import"../chunks/permission-nsc0c3zb.js";
+import"../chunks/permission-kyyqvx4s.js";
+import"../chunks/permission-1fb7bmpf.js";
+import"../chunks/permission-n3m50c2t.js";
+import"../chunks/permission-v2adqbbe.js";
+import"../chunks/permission-9sdtsapf.js";
+import"../chunks/permission-cm67rqy2.js";
+import"../chunks/permission-qc167nrn.js";
+import"../chunks/permission-69qrqpw0.js";
+import"../chunks/permission-kpdbz7gn.js";
+import"../chunks/permission-dppgrtwb.js";
+import"../chunks/permission-ma60vzgv.js";
+import"../chunks/permission-dht5baf0.js";
+import"../chunks/permission-2qdx6zz3.js";
+import"../chunks/permission-dhcq6c44.js";
+import"../chunks/permission-nkm1m8dz.js";
+import"../chunks/permission-gd5xeqc2.js";
+import"../chunks/permission-yrqrg4vp.js";
+import"../chunks/permission-ttxf0gsy.js";
+import"../chunks/permission-yjjxtbjv.js";
+import"../chunks/permission-wwdwn09j.js";
+import"../chunks/permission-s7jy4mh3.js";
+import"../chunks/permission-ezvn03y4.js";
+import"../chunks/permission-s27a5c5r.js";
+import"../chunks/permission-4zfy2va0.js";
+import"../chunks/permission-zfxc0ze5.js";
+import"../chunks/permission-bxdhjb3y.js";
+import"../chunks/permission-nv7zjdpe.js";
+import"../chunks/permission-6sc9h3ca.js";
+import"../chunks/permission-f84sxdqn.js";
+import"../chunks/permission-mwceq5am.js";
+import"../chunks/permission-erj4j75s.js";
+import"../chunks/permission-g9yygpzr.js";
+import"../chunks/permission-ma07p6tt.js";
+import"../chunks/permission-0f48qthw.js";
+import"../chunks/permission-s7whb9gt.js";
+import"../chunks/permission-j07kk359.js";
+import {
+  __require
+} from "../chunks/permission-rvfvac9x.js";
+
+// src/database/v1-migration.bun.ts
+import { Cause, Effect, Layer, Option, Schema, Semaphore } from "effect";
+import { SessionV1 } from "@opencode-ai/schema/session-v1";
+import { eq, sql } from "drizzle-orm";
+import { Global } from "@opencode-ai/util/global";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { Project } from "@opencode-ai/schema/project";
+var lock = Semaphore.makeUnsafe(1);
+var MIGRATION_STATE_KEY = "migration.v1-v2";
+var EVENT_DELETE_BATCH_SIZE = 1000;
+var decodeJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString);
+var decodeMessage = Schema.decodeUnknownOption(SessionV1.Info);
+var decodePart = Schema.decodeUnknownOption(SessionV1.Part);
+var runtimeState = { status: "idle" };
+function transformSession(input) {
+  const warnings = [];
+  const messages = input.messages.map((row) => {
+    const value = Option.getOrUndefined(decodeJson(row.data));
+    const decoded = value && typeof value === "object" ? Option.getOrUndefined(decodeMessage({ ...value, id: row.id, sessionID: row.session_id })) : undefined;
+    if (decoded)
+      return { row, value: decoded };
+    warnings.push({ reason: "invalid-message", sessionID: input.session.id, messageID: row.id });
+    return;
+  }).filter((item) => item !== undefined).sort((a, b) => a.row.time_created - b.row.time_created || a.row.id.localeCompare(b.row.id));
+  const messageIDs = new Set(input.messages.map((row) => row.id));
+  const parts = input.parts.map((row) => {
+    const value = Option.getOrUndefined(decodeJson(row.data));
+    const observedType = value && typeof value === "object" && "type" in value ? String(value.type) : undefined;
+    if (!messageIDs.has(row.message_id)) {
+      warnings.push({
+        reason: "orphan-part",
+        sessionID: input.session.id,
+        messageID: row.message_id,
+        partID: row.id,
+        observedType
+      });
+      return;
+    }
+    const decoded = value && typeof value === "object" ? Option.getOrUndefined(decodePart({ ...value, id: row.id, messageID: row.message_id, sessionID: row.session_id })) : undefined;
+    if (decoded)
+      return { row, value: decoded };
+    warnings.push({
+      reason: "invalid-part",
+      sessionID: input.session.id,
+      messageID: row.message_id,
+      partID: row.id,
+      observedType
+    });
+    return;
+  }).filter((item) => item !== undefined).sort((a, b) => a.row.id.localeCompare(b.row.id));
+  const byMessage = Map.groupBy(parts, (item) => item.row.message_id);
+  const paired = new Set;
+  const used = new Set(messages.map((item) => item.row.id));
+  const projected = messages.flatMap((item) => {
+    if (paired.has(item.row.id))
+      return [];
+    const owned = byMessage.get(item.row.id)?.map((part) => part.value) ?? [];
+    if (item.value.role === "user") {
+      const compaction = owned.find((part) => part.type === "compaction");
+      if (compaction?.type === "compaction") {
+        const pairedSummary = messages.find((candidate) => candidate.value.role === "assistant" && candidate.value.parentID === item.row.id && candidate.value.summary);
+        if (!pairedSummary || pairedSummary.value.role !== "assistant")
+          return [];
+        paired.add(pairedSummary.row.id);
+        if (pairedSummary.value.error || pairedSummary.value.time.completed === undefined)
+          return [];
+        const summary = pairedSummary;
+        const summaryText = (byMessage.get(summary.row.id) ?? []).map((part) => part.value).filter((part) => part.type === "text" && part.text.length > 0).map((part) => part.type === "text" ? part.text : "").join(`
+
+`);
+        const tailIndex = compaction.tail_start_id ? messages.findIndex((candidate) => candidate.row.id === compaction.tail_start_id) : -1;
+        const compactionIndex = messages.findIndex((candidate) => candidate.row.id === item.row.id);
+        const tail = tailIndex < 0 ? [] : messages.slice(tailIndex, compactionIndex);
+        return [
+          row({ ...item.row, time_updated: Math.max(item.row.time_updated, summary.row.time_updated) }, {
+            id: item.row.id,
+            type: "compaction",
+            status: "completed",
+            reason: compaction.auto ? "auto" : "manual",
+            summary: summaryText,
+            recent: serializeRecent(tail, byMessage),
+            time: { created: item.row.time_created }
+          })
+        ];
+      }
+      const subtasks = owned.filter((part) => part.type === "subtask");
+      const visible = owned.filter((part) => part.type === "text" && !part.ignored);
+      const files = owned.filter((part) => part.type === "file");
+      const agents = owned.filter((part) => part.type === "agent");
+      if (subtasks.length > 0 && visible.length === 0 && files.length === 0 && agents.length === 0)
+        return [];
+      const ordinary = visible.filter((part) => part.type === "text" && !part.synthetic);
+      const synthetic = visible.filter((part) => part.type === "text" && part.synthetic);
+      const attachments = files.flatMap((part) => part.type === "file" ? migrateFile(part) : []);
+      const unavailable = files.flatMap((part) => part.type === "file" && !part.url.startsWith("data:") ? [unavailableFile(part)] : []);
+      const text = owned.flatMap((part) => {
+        if (part.type === "text" && !part.ignored && !part.synthetic)
+          return [part.text];
+        if (part.type === "file" && !part.url.startsWith("data:"))
+          return [unavailableFile(part)];
+        return [];
+      }).join(`
+
+`);
+      const agentAttachments = agents.map((part) => part.type === "agent" ? {
+        name: part.name,
+        ...part.source ? { mention: { text: part.source.value, start: part.source.start, end: part.source.end } } : {}
+      } : { name: "" });
+      if (ordinary.length === 0 && unavailable.length === 0 && synthetic.length > 0 && attachments.length === 0 && agentAttachments.length === 0)
+        return [
+          row(item.row, {
+            id: item.row.id,
+            type: "synthetic",
+            text: synthetic.map((part) => part.type === "text" ? part.text : "").join(`
+
+`),
+            time: { created: item.row.time_created }
+          })
+        ];
+      const user = row(item.row, {
+        id: item.row.id,
+        type: "user",
+        text,
+        ...attachments.length ? { files: attachments } : {},
+        ...agentAttachments.length ? { agents: agentAttachments } : {},
+        time: { created: item.row.time_created }
+      });
+      if (synthetic.length === 0)
+        return [user];
+      return [
+        user,
+        row(item.row, {
+          id: syntheticID(item.row.id, used),
+          type: "synthetic",
+          text: synthetic.map((part) => part.type === "text" ? part.text : "").join(`
+
+`),
+          time: { created: item.row.time_created }
+        })
+      ];
+    }
+    if (item.value.role !== "assistant")
+      return [];
+    const assistant = item.value;
+    const parent = messages.find((candidate) => candidate.row.id === assistant.parentID);
+    const parentParts = parent ? byMessage.get(parent.row.id)?.map((part) => part.value) ?? [] : [];
+    if (parentParts.some((part) => part.type === "subtask") && owned.some((part) => part.type === "tool" && part.tool === "task"))
+      return [];
+    const content = owned.flatMap((part) => {
+      if (part.type === "text")
+        return [{ type: "text", text: part.text, ...part.metadata ? { state: part.metadata } : {} }];
+      if (part.type === "reasoning")
+        return [
+          {
+            type: "reasoning",
+            text: part.text,
+            ...part.metadata ? { state: part.metadata } : {},
+            time: { created: part.time.start, ...part.time.end === undefined ? {} : { completed: part.time.end } }
+          }
+        ];
+      if (part.type !== "tool")
+        return [];
+      return [migrateTool(part, item.row.time_created)];
+    });
+    const start = owned.flatMap((part) => part.type === "step-start" && part.snapshot ? [part.snapshot] : [])[0] ?? owned.flatMap((part) => part.type === "snapshot" ? [part.snapshot] : [])[0] ?? owned.flatMap((part) => part.type === "patch" ? [part.hash] : [])[0];
+    const end = owned.flatMap((part) => part.type === "step-finish" && part.snapshot ? [part.snapshot] : []).at(-1);
+    const snapshotFiles = Array.from(new Set(owned.flatMap((part) => part.type === "patch" ? part.files : [])));
+    const finish = normalizeFinish(assistant.finish);
+    return [
+      row(item.row, {
+        id: item.row.id,
+        type: "assistant",
+        agent: assistant.agent,
+        model: {
+          providerID: assistant.providerID,
+          id: assistant.modelID,
+          variant: assistant.variant ?? "default"
+        },
+        content,
+        ...start || end || snapshotFiles.length ? {
+          snapshot: {
+            ...start ? { start } : {},
+            ...end ? { end } : {},
+            ...snapshotFiles.length ? { files: snapshotFiles } : {}
+          }
+        } : {},
+        ...finish ? { finish } : {},
+        cost: assistant.cost,
+        tokens: {
+          input: assistant.tokens.input,
+          output: assistant.tokens.output,
+          reasoning: assistant.tokens.reasoning,
+          cache: assistant.tokens.cache
+        },
+        ...assistant.error ? { error: migrateError(assistant.error) } : {},
+        time: {
+          created: item.row.time_created,
+          ...assistant.time.completed === undefined ? {} : { completed: item.row.time_updated }
+        }
+      })
+    ];
+  }).map((item, seq) => ({ ...item, seq }));
+  const assistants = messages.filter((item) => item.value.role === "assistant").map((item) => item.value).filter((item) => item.role === "assistant");
+  const latestUser = messages.findLast((item) => {
+    if (item.value.role !== "user")
+      return false;
+    const owned = byMessage.get(item.row.id) ?? [];
+    if (owned.some((part) => part.value.type === "compaction"))
+      return false;
+    return !owned.some((part) => part.value.type === "subtask") || !owned.every((part) => part.value.type === "subtask");
+  });
+  return {
+    messages: projected,
+    session: {
+      agent: input.session.agent ?? (latestUser?.value.role === "user" ? latestUser.value.agent : null),
+      model: input.session.model ?? (latestUser?.value.role === "user" ? {
+        id: latestUser.value.model.modelID,
+        providerID: latestUser.value.model.providerID,
+        variant: latestUser.value.model.variant ?? "default"
+      } : null),
+      cost: assistants.reduce((total, item) => total + item.cost, 0),
+      tokens_input: assistants.reduce((total, item) => total + item.tokens.input, 0),
+      tokens_output: assistants.reduce((total, item) => total + item.tokens.output, 0),
+      tokens_reasoning: assistants.reduce((total, item) => total + item.tokens.reasoning, 0),
+      tokens_cache_read: assistants.reduce((total, item) => total + item.tokens.cache.read, 0),
+      tokens_cache_write: assistants.reduce((total, item) => total + item.tokens.cache.write, 0),
+      revert: null,
+      time_compacting: null
+    },
+    watermark: projected.length - 1,
+    warnings
+  };
+}
+function status() {
+  return Effect.gen(function* () {
+    const { db } = yield* exports_database.Service;
+    if (!(yield* hasLegacySessions(db)))
+      return { status: "completed" };
+    const state = yield* readState(db);
+    if (runtimeState.status === "running")
+      return runtimeState;
+    if (runtimeState.status === "error")
+      return runtimeState;
+    if (state?.phase === "completed")
+      return { status: "completed" };
+    return { status: "required" };
+  }).pipe(Effect.orDie);
+}
+var layer = Layer.effectDiscard(Effect.gen(function* () {
+  runtimeState = { status: "running", progress: { label: "Clearing old events" } };
+  yield* run().pipe(Effect.matchCauseEffect({
+    onFailure: (cause) => Effect.sync(() => {
+      runtimeState = { status: "error", error: errorText(Cause.squash(cause)) };
+    }).pipe(Effect.andThen(Effect.logError("V1 migration failed", { cause }))),
+    onSuccess: () => Effect.sync(() => {
+      runtimeState = { status: "idle" };
+    })
+  }), Effect.forkScoped({ startImmediately: true }));
+}));
+function errorText(input) {
+  if (!(input instanceof Error))
+    return String(input);
+  const cause = input.cause;
+  return cause === undefined ? input.message : `${input.message}
+Caused by: ${errorText(cause)}`;
+}
+function updateProgress(progress) {
+  if (runtimeState.status === "running")
+    runtimeState = { status: "running", progress };
+}
+function run(options = {}) {
+  return lock.withPermit(Effect.gen(function* () {
+    const { db } = yield* exports_database.Service;
+    const global = yield* Global.Service;
+    const state = yield* readState(db);
+    if (state?.phase === "completed")
+      return { status: "completed" };
+    if (!(yield* hasLegacySessions(db)))
+      return { status: "completed" };
+    const migrate = Effect.gen(function* () {
+      const now = Date.now();
+      yield* db.run(sql`
+          INSERT OR IGNORE INTO project (id, worktree, time_created, time_updated, sandboxes)
+          VALUES (${Project.ID.global}, ${path.parse(global.data).root}, ${now}, ${now}, '[]')
+        `);
+      if (state === undefined)
+        yield* db.transaction((tx) => Effect.gen(function* () {
+          while (true) {
+            yield* tx.run(sql`
+                    DELETE FROM event
+                    WHERE rowid IN (SELECT rowid FROM event LIMIT ${EVENT_DELETE_BATCH_SIZE})
+                  `);
+            const deleted = (yield* tx.get(sql`SELECT changes() AS value`))?.value ?? 0;
+            if (deleted < EVENT_DELETE_BATCH_SIZE)
+              break;
+            yield* Effect.yieldNow;
+          }
+          yield* tx.insert(KVTable).values({ key: MIGRATION_STATE_KEY, value: { phase: "sessions" } }).run();
+        })).pipe(Effect.orDie);
+      const sourceTotal = yield* countNextSessions(nextPath(options, global.data));
+      const legacyTotal = (yield* db.get(sql`SELECT COUNT(*) AS value FROM session`))?.value ?? 0;
+      const cursor = state?.phase === "sessions" ? state.cursor : undefined;
+      const migrated = cursor !== undefined ? (yield* db.get(sql`SELECT COUNT(*) AS value FROM session WHERE id >= ${cursor}`))?.value ?? 0 : 0;
+      const denominator = sourceTotal + legacyTotal;
+      updateProgress({ label: "Migrating sessions", numerator: migrated, denominator });
+      yield* importNextDatabase(db, nextPath(options, global.data), (completed) => {
+        updateProgress({ label: "Migrating sessions", numerator: migrated + completed, denominator });
+      });
+      updateProgress({ label: "Migrating sessions", numerator: migrated + sourceTotal, denominator });
+      const projects = new Set((yield* db.all(sql`SELECT id FROM project`)).map((project) => project.id));
+      while (true) {
+        const state2 = yield* readState(db);
+        const cursorValue = state2?.phase === "sessions" ? state2.cursor : undefined;
+        const nextID = yield* db.get(cursorValue === undefined ? sql`SELECT id, project_id FROM session ORDER BY id DESC LIMIT 1` : sql`SELECT id, project_id FROM session WHERE id < ${cursorValue} ORDER BY id DESC LIMIT 1`);
+        if (!nextID)
+          break;
+        yield* db.transaction((tx) => Effect.gen(function* () {
+          yield* tx.insert(KVTable).values({ key: MIGRATION_STATE_KEY, value: { phase: "sessions", cursor: nextID.id } }).onConflictDoUpdate({
+            target: KVTable.key,
+            set: { value: { phase: "sessions", cursor: nextID.id }, time_updated: Date.now() }
+          }).run();
+          const projectID = projects.has(nextID.project_id) ? nextID.project_id : Project.ID.global;
+          if (projectID !== nextID.project_id)
+            yield* Effect.logWarning("Reassigned V1 session with missing project", {
+              sessionID: nextID.id,
+              projectID: nextID.project_id
+            });
+          yield* tx.run(sql`
+                  INSERT OR IGNORE INTO session_v2 (
+                    id, project_id, workspace_id, parent_id, slug, directory, path, title, version, share_url,
+                    summary_additions, summary_deletions, summary_files, summary_diffs, metadata, cost,
+                    tokens_input, tokens_output, tokens_reasoning, tokens_cache_read, tokens_cache_write,
+                    revert, permission, agent, model, time_created, time_updated, time_compacting, time_archived
+                  )
+                  SELECT
+                    id, ${projectID}, workspace_id, parent_id, slug, directory, path, title, version, share_url,
+                    summary_additions, summary_deletions, summary_files, summary_diffs, metadata, cost,
+                    tokens_input, tokens_output, tokens_reasoning, tokens_cache_read, tokens_cache_write,
+                    revert, permission, agent, model, time_created, time_updated, time_compacting, time_archived
+                  FROM session
+                  WHERE id = ${nextID.id}
+                `);
+          const next = yield* tx.select().from(SessionTable).where(eq(SessionTable.id, exports_schema.ID.make(nextID.id))).get();
+          if (!next)
+            return yield* Effect.die(new Error(`Failed to copy V1 session ${nextID.id}`));
+          const sourceMessages = yield* tx.all(sql`SELECT id, session_id, time_created, time_updated, data FROM message WHERE session_id = ${next.id}`);
+          const sourceParts = yield* tx.all(sql`SELECT id, message_id, session_id, time_created, time_updated, data FROM part WHERE session_id = ${next.id}`);
+          const transformed = transformSession({ session: next, messages: sourceMessages, parts: sourceParts });
+          yield* Effect.forEach(transformed.warnings, (warning) => Effect.logWarning("Skipped V1 migration row", warning));
+          yield* tx.delete(SessionMessageTable).where(eq(SessionMessageTable.session_id, next.id)).run();
+          yield* Effect.forEach(transformed.messages, (message) => tx.insert(SessionMessageTable).values({
+            id: exports_message.ID.make(message.id),
+            session_id: exports_schema.ID.make(message.session_id),
+            type: message.type,
+            seq: message.seq,
+            time_created: message.time_created,
+            time_updated: message.time_updated,
+            data: sql`${JSON.stringify(message.data)}`
+          }).run());
+          yield* tx.update(SessionTable).set({ ...transformed.session, time_updated: next.time_updated }).where(eq(SessionTable.id, next.id)).run();
+          yield* tx.insert(EventSequenceTable).values({ aggregate_id: next.id, seq: transformed.watermark }).onConflictDoUpdate({
+            target: EventSequenceTable.aggregate_id,
+            set: { seq: transformed.watermark, owner_id: null }
+          }).run();
+        })).pipe(Effect.orDie);
+        if (runtimeState.status === "running")
+          runtimeState = {
+            status: "running",
+            progress: {
+              label: "Migrating sessions",
+              numerator: (runtimeState.progress.numerator ?? 0) + 1,
+              denominator
+            }
+          };
+        yield* Effect.yieldNow;
+      }
+      yield* db.transaction((tx) => Effect.gen(function* () {
+        yield* tx.insert(KVTable).values({ key: MIGRATION_STATE_KEY, value: { phase: "completed" } }).onConflictDoUpdate({
+          target: KVTable.key,
+          set: { value: { phase: "completed" }, time_updated: Date.now() }
+        }).run();
+      })).pipe(Effect.orDie);
+      return { status: "completed" };
+    });
+    return yield* migrate;
+  }).pipe(Effect.orDie));
+}
+function nextPath(options, data) {
+  if (options.nextDatabasePath)
+    return options.nextDatabasePath;
+  if (process.env.OPENCODE_DB === ":memory:")
+    return;
+  return path.join(data, "opencode-next.db");
+}
+function openNextDatabase(sourcePath) {
+  return Effect.acquireRelease(Effect.gen(function* () {
+    const sqlite = yield* Effect.promise(() => import("bun:sqlite"));
+    return new sqlite.Database(sourcePath, { readonly: true, strict: true });
+  }), (source) => Effect.sync(() => source.close()));
+}
+function countNextSessions(sourcePath) {
+  if (!sourcePath || !existsSync(sourcePath))
+    return Effect.succeed(0);
+  return Effect.scoped(Effect.gen(function* () {
+    const source = yield* openNextDatabase(sourcePath);
+    if (!isNextDatabase(source))
+      return 0;
+    return source.query("SELECT COUNT(*) AS value FROM session").get()?.value ?? 0;
+  })).pipe(Effect.orElseSucceed(() => 0));
+}
+function importNextDatabase(db, sourcePath, onProgress) {
+  if (!sourcePath || !existsSync(sourcePath))
+    return Effect.void;
+  return Effect.scoped(Effect.gen(function* () {
+    const source = yield* openNextDatabase(sourcePath);
+    if (!isNextDatabase(source)) {
+      yield* Effect.logWarning("Skipped incompatible opencode-next.db", { path: sourcePath });
+      return;
+    }
+    source.run("BEGIN");
+    yield* Effect.addFinalizer(() => Effect.sync(() => {
+      if (source.inTransaction)
+        source.run("ROLLBACK");
+    }));
+    const projects = new Map(source.query("SELECT * FROM project").all().map((project) => [project.id, project]));
+    const sessions = source.query("SELECT * FROM session ORDER BY id DESC").all();
+    for (const [index, session] of sessions.entries()) {
+      const project = projects.get(session.project_id);
+      const projectID = project ? session.project_id : Project.ID.global;
+      if (!project) {
+        yield* Effect.logWarning("Reassigned previous V2 session with missing project", {
+          sessionID: session.id,
+          projectID: session.project_id
+        });
+      }
+      const messages = source.query("SELECT id, session_id, type, seq, time_created, time_updated, data FROM session_message WHERE session_id = ? ORDER BY seq").all(session.id);
+      yield* db.transaction((tx) => Effect.gen(function* () {
+        if (project)
+          yield* tx.run(sql`
+                  INSERT OR IGNORE INTO project (
+                    id, worktree, vcs, name, icon_url, icon_url_override, icon_color,
+                    time_created, time_updated, time_initialized, sandboxes, commands
+                  ) VALUES (
+                    ${project.id}, ${project.worktree}, ${project.vcs}, ${project.name}, ${project.icon_url},
+                    ${project.icon_url_override}, ${project.icon_color}, ${project.time_created}, ${project.time_updated},
+                    ${project.time_initialized}, ${project.sandboxes}, ${project.commands}
+                  )
+                `);
+        const existing = yield* tx.select({ id: SessionTable.id }).from(SessionTable).where(eq(SessionTable.id, exports_schema.ID.make(session.id))).get();
+        if (existing)
+          return;
+        yield* tx.run(sql`
+                INSERT INTO session_v2 (
+                  id, project_id, workspace_id, parent_id, fork_session_id, fork_boundary, slug, directory,
+                  path, title, version, share_url, summary_additions, summary_deletions, summary_files,
+                  summary_diffs, metadata, cost, tokens_input, tokens_output, tokens_reasoning, tokens_cache_read,
+                  tokens_cache_write, revert, permission, agent, model, time_created, time_updated, time_compacting,
+                  time_archived, time_suspended
+                ) VALUES (
+                  ${session.id}, ${projectID}, ${session.workspace_id}, ${session.parent_id},
+                  ${session.fork_session_id}, ${session.fork_boundary}, ${session.slug}, ${session.directory},
+                  ${session.path}, ${session.title}, ${session.version}, ${session.share_url},
+                  ${session.summary_additions}, ${session.summary_deletions}, ${session.summary_files},
+                  ${session.summary_diffs}, ${session.metadata}, ${session.cost}, ${session.tokens_input},
+                  ${session.tokens_output}, ${session.tokens_reasoning}, ${session.tokens_cache_read},
+                  ${session.tokens_cache_write}, ${session.revert}, ${session.permission}, ${session.agent},
+                  ${session.model}, ${session.time_created}, ${session.time_updated}, ${session.time_compacting},
+                  ${session.time_archived}, ${session.time_suspended}
+                )
+              `);
+        yield* Effect.forEach(messages, (message) => tx.insert(SessionMessageTable).values({
+          id: exports_message.ID.make(message.id),
+          session_id: exports_schema.ID.make(message.session_id),
+          type: message.type,
+          seq: message.seq,
+          time_created: message.time_created,
+          time_updated: message.time_updated,
+          data: sql`${message.data}`
+        }).run());
+        yield* tx.insert(EventSequenceTable).values({ aggregate_id: session.id, seq: messages.at(-1)?.seq ?? -1 }).onConflictDoUpdate({
+          target: EventSequenceTable.aggregate_id,
+          set: { seq: messages.at(-1)?.seq ?? -1, owner_id: null }
+        }).run();
+      })).pipe(Effect.orDie);
+      onProgress(index + 1);
+      yield* Effect.yieldNow;
+    }
+    source.run("COMMIT");
+  }));
+}
+function isNextDatabase(source) {
+  const tables = new Set(source.query("SELECT name FROM sqlite_master WHERE type = 'table'").all().map((table) => table.name));
+  return tables.has("project") && tables.has("session") && tables.has("session_message");
+}
+function row(source, message) {
+  const { id, type, ...data } = message;
+  return {
+    id,
+    session_id: source.session_id,
+    type,
+    seq: 0,
+    time_created: source.time_created,
+    time_updated: source.time_updated,
+    data
+  };
+}
+function migrateTool(part, fallback) {
+  const base = {
+    type: "tool",
+    id: part.callID,
+    name: part.tool,
+    ...part.metadata ? { providerState: part.metadata } : {}
+  };
+  if (part.state.status === "completed")
+    return {
+      ...base,
+      state: {
+        status: "completed",
+        input: part.state.input,
+        content: part.state.time.compacted === undefined ? [
+          { type: "text", text: part.state.output },
+          ...(part.state.attachments ?? []).map((file) => ({
+            type: "file",
+            uri: file.url,
+            mime: file.mime,
+            ...file.filename ? { name: file.filename } : {}
+          }))
+        ] : [{ type: "text", text: "[Old tool result content cleared]" }],
+        metadata: part.state.metadata
+      },
+      time: { created: part.state.time.start, completed: part.state.time.end }
+    };
+  if (part.state.status === "error")
+    return {
+      ...base,
+      state: {
+        status: "error",
+        input: part.state.input,
+        error: { type: "tool.execution", message: part.state.error },
+        ...typeof part.state.metadata?.output === "string" ? { content: [{ type: "text", text: part.state.metadata.output }] } : {},
+        ...part.state.metadata ? { metadata: part.state.metadata } : {}
+      },
+      time: { created: part.state.time.start, completed: part.state.time.end }
+    };
+  return {
+    ...base,
+    state: {
+      status: "error",
+      input: part.state.input,
+      error: { type: "tool.interrupted", message: "Tool execution was interrupted before V2 migration" },
+      ...part.state.status === "running" && part.state.metadata ? { metadata: part.state.metadata } : {}
+    },
+    time: { created: part.state.status === "running" ? part.state.time.start : fallback }
+  };
+}
+function migrateError(error) {
+  const message = "message" in error.data ? error.data.message : error.name === "MessageOutputLengthError" ? "The model exceeded its output limit" : error.name;
+  const type = error.name === "ProviderAuthError" ? "provider.auth" : error.name === "ContentFilterError" ? "provider.content-filter" : error.name === "ContextOverflowError" ? "provider.invalid-request" : error.name === "StructuredOutputError" || error.name === "MessageOutputLengthError" ? "provider.invalid-output" : error.name === "MessageAbortedError" ? "aborted" : error.name === "APIError" ? "provider.error" : "unknown";
+  return { type, message };
+}
+function normalizeFinish(finish) {
+  if (!finish)
+    return;
+  return ["stop", "length", "tool-calls", "content-filter", "error", "unknown"].find((value) => value === finish) ?? "unknown";
+}
+function migrateFile(part) {
+  if (!part.url.startsWith("data:"))
+    return [];
+  const comma = part.url.indexOf(",");
+  if (comma < 0)
+    return [];
+  const header = part.url.slice(0, comma);
+  const payload = part.url.slice(comma + 1);
+  const data = header.endsWith(";base64") ? Buffer.from(payload, "base64").toString("base64") : Buffer.from(decodeURIComponent(payload)).toString("base64");
+  return [
+    {
+      data,
+      mime: part.mime,
+      source: part.source?.type === "resource" ? { type: "uri", uri: part.source.uri } : { type: "inline" },
+      ...part.filename ? { name: part.filename } : {},
+      ...part.source ? { mention: { text: part.source.text.value, start: part.source.text.start, end: part.source.text.end } } : {}
+    }
+  ];
+}
+function unavailableFile(part) {
+  const label = part.filename ?? (part.source?.type === "resource" ? part.source.uri : part.url);
+  return `[Attachment unavailable after migration: ${label} (${part.mime})]`;
+}
+function syntheticID(source, used) {
+  const prefix = source.slice(0, 16);
+  const alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+  for (let salt = 0;; salt++) {
+    const hex = new Bun.CryptoHasher("sha256").update(`v1-synthetic:${source}${salt ? `:${salt}` : ""}`).digest("hex");
+    let value = BigInt(`0x${hex}`);
+    let suffix = "";
+    while (suffix.length < 14) {
+      suffix = alphabet[Number(value % 62n)] + suffix;
+      value /= 62n;
+    }
+    const id = prefix + suffix;
+    if (used.has(id))
+      continue;
+    used.add(id);
+    return id;
+  }
+}
+function serializeRecent(messages, parts) {
+  return messages.flatMap((message) => {
+    const owned = parts.get(message.row.id)?.map((part) => part.value) ?? [];
+    if (message.value.role === "user")
+      return [
+        `[User]: ${owned.filter((part) => part.type === "text" && !part.ignored).map((part) => part.type === "text" ? part.text : "").join(`
+
+`)}`
+      ];
+    return owned.flatMap((part) => part.type === "text" ? [`[Assistant]: ${part.text}`] : part.type === "reasoning" && part.text ? [`[Assistant reasoning]: ${part.text}`] : []);
+  }).join(`
+
+`);
+}
+function readState(db) {
+  return db.select({ value: KVTable.value }).from(KVTable).where(eq(KVTable.key, MIGRATION_STATE_KEY)).get().pipe(Effect.map((row2) => parseState(row2?.value)), Effect.orDie);
+}
+function parseState(input) {
+  if (!input || typeof input !== "object" || !("phase" in input))
+    return;
+  if (input.phase === "completed")
+    return { phase: "completed" };
+  if (input.phase !== "sessions")
+    return;
+  if (!("cursor" in input) || input.cursor === undefined)
+    return { phase: "sessions" };
+  if (typeof input.cursor === "string")
+    return { phase: "sessions", cursor: input.cursor };
+}
+function hasLegacySessions(db) {
+  return db.get(sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'session'`).pipe(Effect.map((row2) => row2 !== undefined), Effect.orDie);
+}
+export {
+  transformSession,
+  status,
+  run,
+  layer,
+  exports_v1_migration as V1Migration
+};