@vantran-se/openchamber-web 1.24.3 → 2.0.1

package/server/lib/opencode/skills.js

@@ -28,10 +28,6 @@ function ensureProjectSkillDir(workingDirectory) {
   if (!fs.existsSync(projectSkillDir)) {
     fs.mkdirSync(projectSkillDir, { recursive: true });
   }
-  const legacyProjectSkillDir = path.join(workingDirectory, '.opencode', 'skill');
-  if (!fs.existsSync(legacyProjectSkillDir)) {
-    fs.mkdirSync(legacyProjectSkillDir, { recursive: true });
-  }
   return projectSkillDir;
 }
 
@@ -199,12 +195,18 @@ function discoverSkills(workingDirectory) {
   let configuredPaths = [];
   try {
     const config = readConfig(workingDirectory);
-    configuredPaths = Array.isArray(config?.skills?.paths) ? config.skills.paths : [];
+    // OpenCode 2 stores extra skill sources as one ordered `skills` array; v1
+    // split them into `skills.paths` and `skills.urls`. URLs are not scanned
+    // from disk either way.
+    configuredPaths = Array.isArray(config?.skills)
+      ? config.skills
+      : (Array.isArray(config?.skills?.paths) ? config.skills.paths : []);
   } catch {
     configuredPaths = [];
   }
   for (const skillPath of configuredPaths) {
     if (typeof skillPath !== 'string' || !skillPath.trim()) continue;
+    if (/^https?:\/\//i.test(skillPath.trim())) continue;
     const expanded = skillPath.startsWith('~/')
       ? path.join(os.homedir(), skillPath.slice(2))
       : skillPath;

package/server/lib/opencode/tunnel-wiring-runtime.js

@@ -32,7 +32,7 @@ export const createTunnelWiringRuntime = (dependencies) => {
     setRuntimeManagedRemoteTunnelToken,
   } = dependencies;
 
-  const initialize = (app, initialPort) => {
+  const initialize = (app, initialPort, hasUiPassword) => {
     let activePort = initialPort;
 
     const tunnelService = createTunnelService({
@@ -51,6 +51,7 @@ export const createTunnelWiringRuntime = (dependencies) => {
       tunnelService,
       tunnelProviderRegistry,
       tunnelAuthController,
+      hasUiPassword,
       readSettingsFromDiskMigrated,
       readManagedRemoteTunnelConfigFromDisk,
       normalizeTunnelProvider,

package/server/lib/opencode/upgrade-capability.test.js

@@ -42,7 +42,7 @@ describe('OpenCode upgrade capability', () => {
     });
   });
 
-  it('allows OpenCode to upgrade a managed non-bundled binary', () => {
+  it('offers CLI upgrades for a managed non-bundled binary', () => {
     expect(resolveOpenCodeUpgradeCapability({
       isExternal: false,
       hasManagedProcess: true,

package/server/lib/opencode/v1-migration-topup.js

@@ -0,0 +1,288 @@
+/**
+ * Re-arms OpenCode's own V1 -> V2 session migration for sessions that were
+ * created after it already finished.
+ *
+ * OpenCode 2.x migrates the legacy `session`/`message`/`part` tables into
+ * `session_v2`/`session_message` once and then writes `{"phase":"completed"}`
+ * under `migration.v1-v2` in `kv`. Users who kept running OpenChamber's
+ * bundled OpenCode 1.x beside a v2 install created more V1 sessions after that
+ * point, and OpenCode never looks at them again: they are simply invisible in
+ * v2. This module hands OpenCode a resume cursor before OpenChamber spawns the
+ * MANAGED OpenCode, so OpenCode's own `run()` imports them on startup with its
+ * own transform. OpenChamber never writes session rows itself.
+ *
+ * Two hard rules, both verified against v2.0.8
+ * `packages/core/src/database/v1-migration.bun.ts`:
+ *
+ * 1. NEVER delete or clear the `migration.v1-v2` row. With no row at all,
+ *    OpenCode treats the database as pre-migration and DELETEs the whole
+ *    `event` table — v2's durable event log — before starting over.
+ * 2. NEVER schedule a cursor that makes OpenCode revisit a session which has
+ *    seen v2 activity. Every visited session gets its `session_message` rows
+ *    deleted and replaced by the V1 transform, so a migrated session that was
+ *    continued in v2 would lose that conversation.
+ * 3. A session deleted in v2 comes back. A v2 delete removes the `session_v2`
+ *    row but leaves the legacy `session` row behind, so the loop imports it
+ *    again. Decided by the maintainer (2026-09-22): people run 1.x and 2.x
+ *    side by side while switching, and OpenChamber's own time-based cleanup
+ *    may have deleted sessions the user never touched, so importing again is
+ *    better than importing nothing. Deleting again is cheap; a lost 1.x
+ *    session is not. This holds until OpenCode ships an import route that
+ *    takes an explicit list of sessions.
+ *
+ * The loop OpenCode runs is `SELECT id FROM session WHERE id < cursor ORDER BY
+ * id DESC LIMIT 1`, one session at a time, so the cursor has to be strictly
+ * greater than the largest id we want imported. Session ids encode time
+ * descending in a fixed-width field that wraps, so id order is NOT time order:
+ * a 2026-08 session can sort far below a newer one. Everything here compares
+ * ids the way SQLite does (BINARY / memcmp — neither `session.id` nor
+ * `session_v2.id` declares a collation) and never assumes id order means age.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { z } from 'zod';
+
+import { resolveCredentialDbPath } from './credential-db.js';
+import { OPENCODE_DATA_DIR } from './auth.js';
+
+/** OpenCode's key for the migration state row in `kv`. */
+const MIGRATION_STATE_KEY = 'migration.v1-v2';
+
+/**
+ * The `session_message.type` values OpenCode's V1 transform can produce
+ * (`transformSession` emits only these four). Any other type on a session is
+ * proof the session was used in v2 after it was migrated.
+ */
+const V1_IMPORT_MESSAGE_TYPES = ['user', 'assistant', 'synthetic', 'compaction'];
+
+/**
+ * Appended to the largest missing id to build the cursor. SQLite compares TEXT
+ * byte by byte, so `<id><anything>` sorts immediately after `<id>`, and since
+ * every session id has the same length no real id can fall between the two.
+ * The cursor therefore selects exactly "this id and everything below it".
+ */
+const CURSOR_SUFFIX = '￿';
+
+/**
+ * The smallest cursor that still makes OpenCode's `id < cursor` loop visit
+ * `maxMissingId` itself.
+ * @param {string} maxMissingId
+ */
+export const computeResumeCursor = (maxMissingId) => `${maxMissingId}${CURSOR_SUFFIX}`;
+
+const kvRowSchema = z.object({ value: z.string(), time_updated: z.number() });
+const idRowSchema = z.object({ id: z.string() });
+const nameRowSchema = z.object({ name: z.string() });
+const countRowSchema = z.object({ value: z.number() });
+const nullableIdRowSchema = z.object({ id: z.string().nullable() });
+const migrationStateSchema = z.object({ phase: z.string() });
+
+/**
+ * A minimal read-write connection: `all(sql, params)`, `run(sql, params)` and
+ * `close()`. Node provides it through `node:sqlite`, Bun through `bun:sqlite`;
+ * both are built in and no dependency is added. Neither being available
+ * yields null and the top-up is skipped.
+ */
+let openConnection;
+const loadSqlite = () => {
+  if (openConnection !== undefined) return openConnection;
+  const require = createRequire(import.meta.url);
+  openConnection = null;
+  try {
+    const { DatabaseSync } = process.getBuiltinModule?.('node:sqlite') ?? require('node:sqlite');
+    // Opening an in-memory database proves the builtin is usable before we
+    // commit to it; a Node without `node:sqlite` throws here and Bun is tried.
+    new DatabaseSync(':memory:').close();
+    openConnection = (dbPath) => {
+      const db = new DatabaseSync(dbPath);
+      return {
+        all: (sql, params = []) => db.prepare(sql).all(...params),
+        run: (sql, params = []) => {
+          db.prepare(sql).run(...params);
+        },
+        close: () => db.close(),
+      };
+    };
+    return openConnection;
+  } catch {
+    // Not Node, or a Node without node:sqlite; try Bun next.
+  }
+  try {
+    const { Database } = require('bun:sqlite');
+    new Database(':memory:').close();
+    openConnection = (dbPath) => {
+      const db = new Database(dbPath);
+      return {
+        all: (sql, params = []) => db.query(sql).all(...params),
+        run: (sql, params = []) => {
+          db.query(sql).run(...params);
+        },
+        close: () => db.close(),
+      };
+    };
+  } catch {
+    // No sqlite runtime at all.
+  }
+  return openConnection;
+};
+
+const outcome = (status, reason, missing = 0, revisited = 0) =>
+  reason === undefined ? { status, missing, revisited } : { status, missing, revisited, reason };
+
+const firstRow = (schema, rows) => {
+  const parsed = schema.safeParse(rows[0]);
+  return parsed.success ? parsed.data : null;
+};
+
+const hasTables = (db, names) => {
+  const rows = db.all(
+    `SELECT name FROM sqlite_master WHERE type = 'table' AND name IN (${names.map(() => '?').join(', ')})`,
+    names,
+  );
+  const found = new Set(
+    rows.flatMap((row) => {
+      const parsed = nameRowSchema.safeParse(row);
+      return parsed.success ? [parsed.data.name] : [];
+    }),
+  );
+  return names.every((name) => found.has(name));
+};
+
+/**
+ * The completion timestamp of a `{"phase":"completed"}` migration row, or null
+ * when the row is missing, unreadable, or the migration is not finished.
+ */
+const readCompletedMigration = (db) => {
+  const row = firstRow(kvRowSchema, db.all('SELECT value, time_updated FROM kv WHERE key = ?', [MIGRATION_STATE_KEY]));
+  if (!row) return null;
+  let decoded;
+  try {
+    decoded = JSON.parse(row.value);
+  } catch {
+    return null;
+  }
+  const state = migrationStateSchema.safeParse(decoded);
+  if (!state.success || state.data.phase !== 'completed') return null;
+  return { completedAt: row.time_updated };
+};
+
+/**
+ * Sessions OpenCode will revisit at this cursor that carry evidence of v2 use
+ * after the migration finished: a message created after completion, a session
+ * row touched after completion, or a message type the V1 transform never
+ * emits. Any hit means the top-up must not run.
+ */
+const findRevisitedSessionsWithV2Activity = (db, cursor, completedAt) =>
+  db
+    .all(
+      `SELECT s.id AS id FROM session s
+       WHERE s.id < ?
+         AND s.id IN (SELECT id FROM session_v2)
+         AND (
+           EXISTS (SELECT 1 FROM session_v2 v WHERE v.id = s.id AND v.time_updated > ?)
+           OR EXISTS (
+             SELECT 1 FROM session_message m
+             WHERE m.session_id = s.id
+               AND (m.time_created > ? OR m.type NOT IN (${V1_IMPORT_MESSAGE_TYPES.map(() => '?').join(', ')}))
+           )
+         )
+       ORDER BY s.id DESC`,
+      [cursor, completedAt, completedAt, ...V1_IMPORT_MESSAGE_TYPES],
+    )
+    .flatMap((row) => {
+      const parsed = idRowSchema.safeParse(row);
+      return parsed.success ? [parsed.data.id] : [];
+    });
+
+/** A legacy session with no `session_v2` twin, whether never imported or deleted in v2 (see rule 3). */
+const MISSING_CONDITION = 'id NOT IN (SELECT id FROM session_v2)';
+
+const countMissingSessions = (db) =>
+  firstRow(countRowSchema, db.all(`SELECT COUNT(*) AS value FROM session WHERE ${MISSING_CONDITION}`))?.value ?? 0;
+
+const countRevisitedSessions = (db, cursor) =>
+  firstRow(
+    countRowSchema,
+    db.all('SELECT COUNT(*) AS value FROM session WHERE id < ? AND id IN (SELECT id FROM session_v2)', [cursor]),
+  )?.value ?? 0;
+
+/**
+ * Schedule OpenCode's own V1 migration to pick up the V1 sessions that are
+ * missing from v2, when that can be done without touching a session that has
+ * v2 activity.
+ *
+ * Call this only for a MANAGED OpenCode, before it is spawned: writing the
+ * migration state under a running OpenCode would race its own loop, and an
+ * external OpenCode is not OpenChamber's to steer.
+ *
+ * @param {{ dbPath?: string, fileSystem?: typeof fs, logger?: Pick<Console, 'log' | 'warn'>, now?: () => number }} [options]
+ * `unsafe` names the one refusal, `revisited-sessions-have-v2-activity`: an
+ * already-migrated session under the cursor was used in v2 since.
+ *
+ * @returns {{ status: 'skipped' | 'scheduled' | 'unsafe' | 'unavailable', missing: number, revisited: number, reason?: string }}
+ */
+export const topUpV1Migration = (options = {}) => {
+  const {
+    dbPath = resolveCredentialDbPath({ dataDir: OPENCODE_DATA_DIR, path }),
+    fileSystem = fs,
+    logger = console,
+    now = Date.now,
+  } = options;
+
+  const open = loadSqlite();
+  if (!open) return outcome('unavailable', 'no-sqlite-runtime');
+  if (!fileSystem.existsSync(dbPath)) return outcome('skipped', 'no-database');
+
+  let db;
+  try {
+    db = open(dbPath);
+    if (!hasTables(db, ['session', 'session_v2', 'session_message', 'kv'])) {
+      return outcome('skipped', 'no-v1-sessions');
+    }
+    const migration = readCompletedMigration(db);
+    if (!migration) return outcome('skipped', 'migration-not-completed');
+
+    const missingCount = countMissingSessions(db);
+    if (missingCount === 0) return outcome('skipped', 'nothing-missing');
+
+    const maxMissing = firstRow(
+      nullableIdRowSchema,
+      db.all(`SELECT MAX(id) AS id FROM session WHERE ${MISSING_CONDITION}`),
+    )?.id;
+    if (!maxMissing) return outcome('skipped', 'nothing-missing');
+
+    const cursor = computeResumeCursor(maxMissing);
+    const revisitedCount = countRevisitedSessions(db, cursor);
+    const unsafe = findRevisitedSessionsWithV2Activity(db, cursor, migration.completedAt);
+    if (unsafe.length > 0) {
+      logger.warn(
+        `[OpenCode] ${missingCount} OpenCode 1.x session(s) are missing from the v2 database, but importing them ` +
+          `would make OpenCode rewrite ${unsafe.length} already-migrated session(s) that have been used in v2 ` +
+          `since. Leaving the migration state untouched.`,
+      );
+      return outcome('unsafe', 'revisited-sessions-have-v2-activity', missingCount, revisitedCount);
+    }
+
+    db.run('UPDATE kv SET value = ?, time_updated = ? WHERE key = ?', [
+      JSON.stringify({ phase: 'sessions', cursor }),
+      now(),
+      MIGRATION_STATE_KEY,
+    ]);
+    logger.log(
+      `[OpenCode] Scheduled the import of ${missingCount} OpenCode 1.x session(s) created after the v2 migration; ` +
+        `OpenCode will re-import ${revisitedCount} untouched session(s) on the way.`,
+    );
+    return outcome('scheduled', undefined, missingCount, revisitedCount);
+  } catch (error) {
+    logger.warn('[OpenCode] Could not check the v1 session migration:', error instanceof Error ? error.message : error);
+    return outcome('unavailable', 'database-error');
+  } finally {
+    try {
+      db?.close();
+    } catch {
+      // Closing a database we are done with must never break startup.
+    }
+  }
+};

package/server/lib/opencode/v1-migration-topup.test.js

@@ -0,0 +1,266 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+import { computeResumeCursor, topUpV1Migration } from './v1-migration-topup.js';
+
+const sqlite = (() => {
+  try {
+    return createRequire(import.meta.url)('node:sqlite');
+  } catch {
+    return null;
+  }
+})();
+
+const MIGRATION_KEY = 'migration.v1-v2';
+/** Stands in for "when OpenCode finished the migration". */
+const COMPLETED_AT = 1_000_000;
+
+let dir;
+let dbPath;
+
+const openDb = () => new sqlite.DatabaseSync(dbPath);
+
+/**
+ * Build a database with the tables the top-up reads, in OpenCode's shape.
+ * `options.tables` drops tables to cover half-built databases.
+ */
+const createDatabase = ({ tables = ['session', 'session_v2', 'session_message', 'kv', 'event'] } = {}) => {
+  const db = openDb();
+  if (tables.includes('session')) {
+    db.exec('CREATE TABLE session (id TEXT PRIMARY KEY, project_id TEXT, time_created INTEGER, time_updated INTEGER)');
+  }
+  if (tables.includes('session_v2')) {
+    db.exec('CREATE TABLE session_v2 (id TEXT PRIMARY KEY, time_created INTEGER, time_updated INTEGER)');
+  }
+  if (tables.includes('session_message')) {
+    db.exec(
+      'CREATE TABLE session_message (id TEXT PRIMARY KEY, session_id TEXT, type TEXT, seq INTEGER, time_created INTEGER, time_updated INTEGER)',
+    );
+  }
+  if (tables.includes('kv')) {
+    db.exec('CREATE TABLE kv (key TEXT PRIMARY KEY, value TEXT NOT NULL, time_created INTEGER, time_updated INTEGER)');
+  }
+  if (tables.includes('event')) {
+    db.exec('CREATE TABLE event (id TEXT PRIMARY KEY, payload TEXT)');
+  }
+  db.close();
+};
+
+/**
+ * `v1` entries are ids or `{ id, timeCreated }`. A bare id stands for a session
+ * created after the migration completed (the case the top-up exists for); a
+ * session the migration already walked needs `timeCreated` before COMPLETED_AT.
+ */
+const seed = ({ v1 = [], v2 = [], messages = [], migration = { phase: 'completed' } } = {}) => {
+  const db = openDb();
+  for (const entry of v1) {
+    const { id, timeCreated = COMPLETED_AT + 1 } = typeof entry === 'string' ? { id: entry } : entry;
+    db.prepare('INSERT INTO session (id, project_id, time_created, time_updated) VALUES (?, ?, ?, ?)').run(
+      id,
+      'prj',
+      timeCreated,
+      timeCreated,
+    );
+  }
+  for (const session of v2) {
+    db.prepare('INSERT INTO session_v2 (id, time_created, time_updated) VALUES (?, ?, ?)').run(
+      session.id,
+      1,
+      session.timeUpdated ?? COMPLETED_AT - 500,
+    );
+  }
+  for (const [index, message] of messages.entries()) {
+    db.prepare(
+      'INSERT INTO session_message (id, session_id, type, seq, time_created, time_updated) VALUES (?, ?, ?, ?, ?, ?)',
+    ).run(`msg_${index}`, message.session, message.type, index, message.timeCreated ?? COMPLETED_AT - 500, 1);
+  }
+  if (migration) {
+    db.prepare('INSERT INTO kv (key, value, time_created, time_updated) VALUES (?, ?, ?, ?)').run(
+      MIGRATION_KEY,
+      JSON.stringify(migration),
+      1,
+      COMPLETED_AT,
+    );
+  }
+  db.close();
+};
+
+const readMigrationRow = () => {
+  const db = openDb();
+  const row = db.prepare('SELECT value, time_updated FROM kv WHERE key = ?').all(MIGRATION_KEY)[0];
+  db.close();
+  return row ? { state: JSON.parse(row.value), timeUpdated: row.time_updated } : null;
+};
+
+const countEvents = () => {
+  const db = openDb();
+  const count = db.prepare('SELECT COUNT(*) AS value FROM event').all()[0].value;
+  db.close();
+  return count;
+};
+
+const run = () => topUpV1Migration({ dbPath, logger: { log: () => {}, warn: () => {} }, now: () => 2_000_000 });
+
+beforeEach(() => {
+  dir = fs.mkdtempSync(path.join(os.tmpdir(), 'oc-topup-'));
+  dbPath = path.join(dir, 'opencode.db');
+});
+
+afterEach(() => {
+  fs.rmSync(dir, { recursive: true, force: true });
+});
+
+describe('computeResumeCursor', () => {
+  it('sorts immediately above the id it must reach', () => {
+    const cursor = computeResumeCursor('ses_b');
+    expect(cursor > 'ses_b').toBe(true);
+    // No same-length id can fall between the id and the cursor.
+    expect(cursor > 'ses_c').toBe(false);
+  });
+});
+
+describe.skipIf(!sqlite)('topUpV1Migration', () => {
+  it('skips when the database file does not exist', () => {
+    expect(run()).toEqual({ status: 'skipped', missing: 0, revisited: 0, reason: 'no-database' });
+  });
+
+  it('skips a database without the v1 session table', () => {
+    createDatabase({ tables: ['session_v2', 'session_message', 'kv', 'event'] });
+    seed({ v1: [] });
+    expect(run()).toEqual({ status: 'skipped', missing: 0, revisited: 0, reason: 'no-v1-sessions' });
+  });
+
+  it('skips when the migration row is absent, and never clears it', () => {
+    createDatabase();
+    seed({ v1: ['ses_a'], migration: null });
+    expect(run()).toEqual({ status: 'skipped', missing: 0, revisited: 0, reason: 'migration-not-completed' });
+    expect(readMigrationRow()).toBeNull();
+  });
+
+  it('skips while OpenCode is still migrating', () => {
+    createDatabase();
+    seed({ v1: ['ses_a'], migration: { phase: 'sessions', cursor: 'ses_b' } });
+    expect(run()).toEqual({ status: 'skipped', missing: 0, revisited: 0, reason: 'migration-not-completed' });
+    expect(readMigrationRow().state).toEqual({ phase: 'sessions', cursor: 'ses_b' });
+  });
+
+  it('does nothing when every v1 session is already in v2', () => {
+    createDatabase();
+    seed({ v1: ['ses_a', 'ses_b'], v2: [{ id: 'ses_a' }, { id: 'ses_b' }] });
+    expect(run()).toEqual({ status: 'skipped', missing: 0, revisited: 0, reason: 'nothing-missing' });
+    expect(readMigrationRow().state).toEqual({ phase: 'completed' });
+  });
+
+  it('schedules a cursor for missing sessions when nothing would be revisited', () => {
+    createDatabase();
+    seed({ v1: ['ses_c', 'ses_d'], v2: [] });
+    expect(run()).toEqual({ status: 'scheduled', missing: 2, revisited: 0 });
+    expect(readMigrationRow()).toEqual({
+      state: { phase: 'sessions', cursor: computeResumeCursor('ses_d') },
+      timeUpdated: 2_000_000,
+    });
+  });
+
+  it('schedules when the sessions it will revisit were never touched in v2', () => {
+    createDatabase();
+    seed({
+      v1: ['ses_a', 'ses_d'],
+      v2: [{ id: 'ses_a' }],
+      messages: [{ session: 'ses_a', type: 'user' }, { session: 'ses_a', type: 'assistant' }],
+    });
+    expect(run()).toEqual({ status: 'scheduled', missing: 1, revisited: 1 });
+    expect(readMigrationRow().state).toEqual({ phase: 'sessions', cursor: computeResumeCursor('ses_d') });
+  });
+
+  it('refuses when a revisited session gained a message after the migration finished', () => {
+    createDatabase();
+    seed({
+      v1: ['ses_a', 'ses_d'],
+      v2: [{ id: 'ses_a' }],
+      messages: [{ session: 'ses_a', type: 'user', timeCreated: COMPLETED_AT + 1 }],
+    });
+    expect(run()).toEqual({
+      status: 'unsafe',
+      missing: 1,
+      revisited: 1,
+      reason: 'revisited-sessions-have-v2-activity',
+    });
+    expect(readMigrationRow().state).toEqual({ phase: 'completed' });
+  });
+
+  it('refuses when a revisited session carries a message type the v1 import never produces', () => {
+    createDatabase();
+    seed({
+      v1: ['ses_a', 'ses_d'],
+      v2: [{ id: 'ses_a' }],
+      messages: [{ session: 'ses_a', type: 'shell' }],
+    });
+    expect(run().status).toBe('unsafe');
+    expect(readMigrationRow().state).toEqual({ phase: 'completed' });
+  });
+
+  it('refuses when a revisited session row was updated after the migration finished', () => {
+    createDatabase();
+    seed({ v1: ['ses_a', 'ses_d'], v2: [{ id: 'ses_a', timeUpdated: COMPLETED_AT + 10 }] });
+    expect(run().status).toBe('unsafe');
+    expect(readMigrationRow().state).toEqual({ phase: 'completed' });
+  });
+
+  it('handles wrapped session ids: the cursor comes from the largest missing id', () => {
+    // Real ids wrap, so a 2026-08 session (`ses_002f…`) sorts far below a
+    // newer one (`ses_f4b7…`). The migrated low session is below the cursor
+    // and therefore counted as revisited.
+    createDatabase();
+    seed({
+      v1: ['ses_002fb287fffe', 'ses_f4b70000aaaa'],
+      v2: [{ id: 'ses_002fb287fffe' }],
+      messages: [{ session: 'ses_002fb287fffe', type: 'user' }],
+    });
+    expect(run()).toEqual({ status: 'scheduled', missing: 1, revisited: 1 });
+    expect(readMigrationRow().state).toEqual({
+      phase: 'sessions',
+      cursor: computeResumeCursor('ses_f4b70000aaaa'),
+    });
+  });
+
+  it('imports a session deleted in v2 again rather than leaving newer 1.x sessions behind', () => {
+    // ses_a was walked by the migration and deleted in v2 (only the legacy row
+    // is left); ses_d was created after. The maintainer chose to bring ses_a
+    // back over losing ses_d: deleting again is cheap, a lost session is not.
+    createDatabase();
+    seed({ v1: [{ id: 'ses_a', timeCreated: COMPLETED_AT - 1 }, 'ses_d'] });
+    expect(run()).toEqual({ status: 'scheduled', missing: 2, revisited: 0 });
+    expect(readMigrationRow().state).toEqual({ phase: 'sessions', cursor: computeResumeCursor('ses_d') });
+  });
+
+  it('never touches the durable event log', () => {
+    createDatabase();
+    const db = openDb();
+    db.prepare('INSERT INTO event (id, payload) VALUES (?, ?)').run('evt_1', '{}');
+    db.close();
+    seed({ v1: ['ses_d'] });
+    expect(run().status).toBe('scheduled');
+    expect(countEvents()).toBe(1);
+  });
+
+  it('skips on a second run, once OpenCode has imported the sessions', () => {
+    createDatabase();
+    seed({ v1: ['ses_d'] });
+    expect(run().status).toBe('scheduled');
+
+    // OpenCode runs, imports ses_d and marks the migration completed again.
+    const db = openDb();
+    db.prepare('INSERT INTO session_v2 (id, time_created, time_updated) VALUES (?, ?, ?)').run('ses_d', 1, 2_000_100);
+    db.prepare('UPDATE kv SET value = ?, time_updated = ? WHERE key = ?').run(
+      JSON.stringify({ phase: 'completed' }),
+      2_000_200,
+      MIGRATION_KEY,
+    );
+    db.close();
+
+    expect(run()).toEqual({ status: 'skipped', missing: 0, revisited: 0, reason: 'nothing-missing' });
+  });
+});

package/server/lib/opencode/v2-install.d.ts

@@ -0,0 +1,8 @@
+export function supportsOpenCodeV2Install(platform?: NodeJS.Platform): boolean;
+export function installOpenCodeV2(options?: {
+  homeDirectory?: string;
+  env?: NodeJS.ProcessEnv;
+  fetchImpl?: typeof fetch;
+  platform?: NodeJS.Platform;
+  tarCommand?: string;
+}): Promise<string>;