@vantran-se/openchamber-web 2.0.3 → 2.0.5

package/server/lib/opencode/shutdown-runtime.test.js

@@ -16,18 +16,20 @@ const createRuntime = (server, overrides = {}) => {
     openCodeWatcherRuntime: { stop: vi.fn() },
     sessionRuntime: { dispose: vi.fn() },
     scheduledTasksRuntime: { stop: vi.fn() },
+    globalEventHub: { stop: vi.fn() },
     getHealthCheckInterval: () => null,
     clearHealthCheckInterval: vi.fn(),
     getTerminalRuntime: () => null,
     setTerminalRuntime: vi.fn(),
     getMessageStreamRuntime: () => null,
     setMessageStreamRuntime: vi.fn(),
-    shouldSkipOpenCodeStop: () => true,
+    getOpenCodeConnectionKind: () => 'explicit-external',
     getOpenCodePort: () => null,
     getOpenCodeProcess: () => null,
     setOpenCodeProcess: vi.fn(),
     killProcessOnPort: vi.fn(),
     waitForPortRelease: vi.fn(async () => true),
+    disposeSharedOpenCodeService: vi.fn(async () => {}),
     getServer: () => server,
     getUiAuthController: () => null,
     setUiAuthController: vi.fn(),
@@ -151,7 +153,7 @@ describe('graceful shutdown runtime', () => {
         throw new Error('fixture cleanup failure');
       },
       getTerminalRuntime: () => ({ shutdown: terminalShutdown }),
-      shouldSkipOpenCodeStop: () => false,
+      getOpenCodeConnectionKind: () => 'managed-owned',
       getOpenCodeProcess: () => ({ close: processClose }),
     });
     await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
@@ -187,6 +189,70 @@ describe('graceful shutdown runtime', () => {
     }
   });
 
+  it('only managed-owned closes and kills OpenCode before waiting for its port', async () => {
+    const close = vi.fn(async () => {});
+    const killProcessOnPort = vi.fn();
+    const waitForPortRelease = vi.fn(async () => true);
+    const disposeSharedOpenCodeService = vi.fn(async () => {});
+    const runtime = createRuntime(null, {
+      getOpenCodeConnectionKind: () => 'managed-owned',
+      getOpenCodePort: () => 4096,
+      getOpenCodeProcess: () => ({ close }),
+      killProcessOnPort,
+      waitForPortRelease,
+      disposeSharedOpenCodeService,
+    });
+
+    await runtime.gracefulShutdown({ exitProcess: false });
+
+    expect(close).toHaveBeenCalledOnce();
+    expect(killProcessOnPort).toHaveBeenCalledWith(4096);
+    expect(waitForPortRelease).toHaveBeenCalledWith(4096, 5000);
+    expect(disposeSharedOpenCodeService).not.toHaveBeenCalled();
+  });
+
+  it('shared-local disposes connection state without touching the shared service process', async () => {
+    const close = vi.fn();
+    const killProcessOnPort = vi.fn();
+    const waitForPortRelease = vi.fn();
+    const disposeSharedOpenCodeService = vi.fn(async () => {});
+    const runtime = createRuntime(null, {
+      getOpenCodeConnectionKind: () => 'shared-local',
+      getOpenCodeProcess: () => ({ close }),
+      killProcessOnPort,
+      waitForPortRelease,
+      disposeSharedOpenCodeService,
+    });
+
+    await runtime.gracefulShutdown({ exitProcess: false });
+
+    expect(disposeSharedOpenCodeService).toHaveBeenCalledOnce();
+    expect(close).not.toHaveBeenCalled();
+    expect(killProcessOnPort).not.toHaveBeenCalled();
+    expect(waitForPortRelease).not.toHaveBeenCalled();
+  });
+
+  it('explicit-external leaves OpenCode and shared state untouched', async () => {
+    const close = vi.fn();
+    const killProcessOnPort = vi.fn();
+    const waitForPortRelease = vi.fn();
+    const disposeSharedOpenCodeService = vi.fn();
+    const runtime = createRuntime(null, {
+      getOpenCodeConnectionKind: () => 'explicit-external',
+      getOpenCodeProcess: () => ({ close }),
+      killProcessOnPort,
+      waitForPortRelease,
+      disposeSharedOpenCodeService,
+    });
+
+    await runtime.gracefulShutdown({ exitProcess: false });
+
+    expect(close).not.toHaveBeenCalled();
+    expect(killProcessOnPort).not.toHaveBeenCalled();
+    expect(waitForPortRelease).not.toHaveBeenCalled();
+    expect(disposeSharedOpenCodeService).not.toHaveBeenCalled();
+  });
+
   it('stops guest services during shutdown', async () => {
     const server = {
       close: vi.fn((callback) => {
@@ -255,6 +321,15 @@ describe('graceful shutdown runtime', () => {
     expect(vi.getTimerCount()).toBe(0);
   });
 
+  it('stops the application-owned global event hub during embedded shutdown', async () => {
+    const globalEventHub = { stop: vi.fn() };
+    const runtime = createRuntime(null, { globalEventHub });
+
+    await runtime.gracefulShutdown({ exitProcess: false });
+
+    expect(globalEventHub.stop).toHaveBeenCalledOnce();
+  });
+
   it('isolates failed viewer and relay cleanup and still drains guests and exits', async () => {
     const stop = vi.fn(() => { throw new Error('stop failed'); });
     const stopAllGuestServices = vi.fn(async () => {});

package/server/lib/opencode/skill-routes.js

@@ -125,9 +125,12 @@ export const registerSkillRoutes = (app, dependencies) => {
     return { scope: SKILL_SCOPE.USER, source };
   };
 
+  // Returns null when OpenCode's list could not be read (not running, error,
+  // timeout, malformed payload) so callers can tell a failed fetch from a
+  // genuinely empty list.
   const fetchOpenCodeDiscoveredSkills = async (workingDirectory) => {
     if (!getOpenCodePort()) {
-      return [];
+      return null;
     }
 
     try {
@@ -145,13 +148,19 @@ export const registerSkillRoutes = (app, dependencies) => {
       const response = await client.skill.list();
       const payload = response?.data;
       if (!Array.isArray(payload)) {
-        return [];
+        return null;
       }
 
       return payload
         .map((item) => {
           const name = typeof item?.name === 'string' ? item.name.trim() : '';
-          const location = typeof item?.location === 'string' ? item.location : '';
+          // OpenCode v1's skill payload used `location`; v2 renamed the field
+          // to `path`. Accept both, or the whole authoritative list is dropped
+          // and the panel falls back to the (smaller) local disk scan.
+          const rawLocation = typeof item?.path === 'string' ? item.path : (typeof item?.location === 'string' ? item.location : '');
+          // v1 marked built-in skills with `<built-in>`; v2 gives them a synthetic
+          // `/builtin/<id>.md` path. Normalize so they stay read-only in the panel.
+          const location = rawLocation.startsWith('/builtin/') ? '<built-in>' : rawLocation;
           const description = typeof item?.description === 'string' ? item.description : '';
           const content = typeof item?.content === 'string' ? item.content : '';
           if (!name || !location) {
@@ -183,7 +192,7 @@ export const registerSkillRoutes = (app, dependencies) => {
         .filter(Boolean);
     } catch (error) {
       console.error('Failed to list OpenCode skills:', error);
-      return [];
+      return null;
     }
   };
 
@@ -244,7 +253,7 @@ export const registerSkillRoutes = (app, dependencies) => {
       }
       const openCodeSkills = await fetchOpenCodeDiscoveredSkills(directory);
       const localSkills = discoverSkills(directory);
-      const skills = mergeDiscoveredSkills(openCodeSkills, localSkills);
+      const skills = mergeDiscoveredSkills(openCodeSkills ?? [], localSkills);
 
       const enrichedSkills = skills.map((skill) => {
         const sources = getSkillSources(skill.name, directory, skill);
@@ -268,7 +277,7 @@ export const registerSkillRoutes = (app, dependencies) => {
       // OpenCode's own skill-list endpoint is not usable for this: on 1.18.14
       // it returns only global and builtin skills, omitting the project
       // `.agents`/`.claude` skills the agent demonstrably has.
-      res.json({
+      const body = {
         skills: enrichedSkills,
         externalSkills: {
           // `OPENCODE_DISABLE_CLAUDE_CODE` is the broad switch; the specific
@@ -277,7 +286,14 @@ export const registerSkillRoutes = (app, dependencies) => {
             || isEnvFlagEnabled(process.env.OPENCODE_DISABLE_CLAUDE_CODE_SKILLS),
           allDisabled: isEnvFlagEnabled(process.env.OPENCODE_DISABLE_EXTERNAL_SKILLS),
         },
-      });
+      };
+      // The list is only the disk scan when OpenCode's own list failed:
+      // built-in skills and anything OpenCode finds only through its config
+      // are missing, so the client must not treat this as complete.
+      if (openCodeSkills === null) {
+        body.openCodeSkillsUnavailable = true;
+      }
+      res.json(body);
     } catch (error) {
       console.error('Failed to list skills:', error);
       res.status(500).json({ error: 'Failed to list skills' });
@@ -366,7 +382,7 @@ export const registerSkillRoutes = (app, dependencies) => {
       }
 
       const resolvedDiscovered = mergeDiscoveredSkills(
-        await fetchOpenCodeDiscoveredSkills(directory),
+        (await fetchOpenCodeDiscoveredSkills(directory)) ?? [],
         discoverSkills(directory),
       );
       const installedByName = new Map(resolvedDiscovered.map((s) => [s.name, s]));
@@ -538,7 +554,7 @@ export const registerSkillRoutes = (app, dependencies) => {
       if (error) {
         return res.status(400).json({ error });
       }
-      const discoveredSkill = (await fetchOpenCodeDiscoveredSkills(directory))
+      const discoveredSkill = ((await fetchOpenCodeDiscoveredSkills(directory)) ?? [])
         .find((skill) => skill.name === skillName) || null;
       const sources = getSkillSources(skillName, directory, discoveredSkill);
 
@@ -567,7 +583,7 @@ export const registerSkillRoutes = (app, dependencies) => {
         return res.status(400).json({ error });
       }
 
-      const discoveredSkill = (await fetchOpenCodeDiscoveredSkills(directory))
+      const discoveredSkill = ((await fetchOpenCodeDiscoveredSkills(directory)) ?? [])
         .find((skill) => skill.name === skillName) || null;
       const sources = getSkillSources(skillName, directory, discoveredSkill);
       if (!sources.md.exists || !sources.md.dir) {
@@ -661,7 +677,7 @@ export const registerSkillRoutes = (app, dependencies) => {
         return res.status(400).json({ error });
       }
 
-      const discoveredSkill = (await fetchOpenCodeDiscoveredSkills(directory))
+      const discoveredSkill = ((await fetchOpenCodeDiscoveredSkills(directory)) ?? [])
         .find((skill) => skill.name === skillName) || null;
       const sources = getSkillSources(skillName, directory, discoveredSkill);
       if (!sources.md.exists || !sources.md.dir) {
@@ -695,7 +711,7 @@ export const registerSkillRoutes = (app, dependencies) => {
         return res.status(400).json({ error });
       }
 
-      const discoveredSkill = (await fetchOpenCodeDiscoveredSkills(directory))
+      const discoveredSkill = ((await fetchOpenCodeDiscoveredSkills(directory)) ?? [])
         .find((skill) => skill.name === skillName) || null;
       const sources = getSkillSources(skillName, directory, discoveredSkill);
       if (!sources.md.exists || !sources.md.dir) {

package/server/lib/opencode/skill-routes.test.js

@@ -28,7 +28,7 @@ const createTempProject = () => {
   return projectRoot;
 };
 
-const startSkillsApp = ({ projectRoot }) => {
+const startSkillsApp = ({ projectRoot, overrides = {} }) => {
   const app = express();
   app.use(express.json());
 
@@ -76,6 +76,7 @@ const startSkillsApp = ({ projectRoot }) => {
     fetchGitHubRepoMetas: async () => ({}),
     getProfiles: () => [],
     getProfile: () => null,
+    ...overrides,
   });
 
   const server = app.listen(0);
@@ -213,4 +214,123 @@ describe('skill-routes directory soft fallback', () => {
       });
     }
   });
+
+  it('lists OpenCode skills reported with the v2 `path` field and keeps the v1 `location` fallback', async () => {
+    projectRoot = createTempProject();
+
+    // OpenCode v2's skill payload renamed `location` to `path`. The route maps
+    // the fetch result to { name, path, ... }; with the old field only, the
+    // whole authoritative list was dropped and the panel fell back to the
+    // smaller local disk scan. Serve a v2-style payload from a stub.
+    const stub = express();
+    stub.get('/api/skill', (_req, res) => {
+      res.json({
+        location: { directory: projectRoot },
+        data: [
+          {
+            id: 'v2-path-skill',
+            name: 'v2-path-skill',
+            path: path.join(projectRoot, '.agents', 'skills', 'v2-path-skill'),
+            description: 'Delivered with the v2 path field',
+          },
+          {
+            id: 'v1-location-skill',
+            name: 'v1-location-skill',
+            location: path.join(projectRoot, '.agents', 'skills', 'v1-location-skill'),
+            description: 'Delivered with the legacy location field',
+          },
+          {
+            id: 'opencode',
+            name: 'OpenCode',
+            path: '/builtin/opencode.md',
+            description: 'v2 built-in skill with a synthetic path',
+          },
+          {
+            id: 'unlocated-skill',
+            name: 'unlocated-skill',
+            description: 'Has neither field; must be dropped',
+          },
+        ],
+      });
+    });
+    const stubServer = await new Promise((resolve) => {
+      const server = stub.listen(0, () => resolve(server));
+    });
+    const stubPort = stubServer.address().port;
+
+    try {
+      appHandle = startSkillsApp({
+        projectRoot,
+        overrides: {
+          buildOpenCodeUrl: () => `http://127.0.0.1:${stubPort}/`,
+          getOpenCodePort: () => stubPort,
+          getOpenCodeAuthHeaders: () => ({}),
+        },
+      });
+
+      const listResponse = await fetch(
+        `${appHandle.baseUrl}/api/config/skills?directory=${encodeURIComponent(projectRoot)}`,
+      );
+      expect(listResponse.status).toBe(200);
+      const payload = await listResponse.json();
+      const byName = new Map(payload.skills.map((skill) => [skill.name, skill]));
+
+      expect(byName.has('v2-path-skill')).toBe(true);
+      expect(byName.get('v2-path-skill').path).toContain('v2-path-skill');
+
+      expect(byName.has('v1-location-skill')).toBe(true);
+      expect(byName.get('v1-location-skill').path).toContain('v1-location-skill');
+
+      expect(byName.get('OpenCode')?.path).toBe('<built-in>');
+      expect(byName.get('OpenCode')?.renamable).toBe(false);
+
+      expect(byName.has('unlocated-skill')).toBe(false);
+    } finally {
+      stubServer.close();
+    }
+  });
+  it('flags the list as partial when OpenCode skill list fails, and not when it succeeds', async () => {
+    projectRoot = createTempProject();
+    fs.mkdirSync(path.join(projectRoot, '.agents', 'skills', 'disk-skill'), { recursive: true });
+    fs.writeFileSync(
+      path.join(projectRoot, '.agents', 'skills', 'disk-skill', 'SKILL.md'),
+      '---\nname: disk-skill\ndescription: On disk\n---\nBody\n',
+    );
+
+    let failing = true;
+    const stub = express();
+    stub.get('/api/skill', (_req, res) => {
+      if (failing) {
+        res.status(500).json({ error: 'boom' });
+        return;
+      }
+      res.json({ data: [] });
+    });
+    const stubServer = await new Promise((resolve) => {
+      const server = stub.listen(0, () => resolve(server));
+    });
+    const stubPort = stubServer.address().port;
+
+    try {
+      appHandle = startSkillsApp({
+        projectRoot,
+        overrides: {
+          buildOpenCodeUrl: () => `http://127.0.0.1:${stubPort}/`,
+          getOpenCodePort: () => stubPort,
+        },
+      });
+      const url = `${appHandle.baseUrl}/api/config/skills?directory=${encodeURIComponent(projectRoot)}`;
+
+      const failed = await (await fetch(url)).json();
+      expect(failed.openCodeSkillsUnavailable).toBe(true);
+      expect(failed.skills.map((skill) => skill.name)).toContain('disk-skill');
+
+      failing = false;
+      const complete = await (await fetch(url)).json();
+      expect(complete.openCodeSkillsUnavailable).toBeUndefined();
+      expect(complete.skills.map((skill) => skill.name)).toContain('disk-skill');
+    } finally {
+      stubServer.close();
+    }
+  });
 });

package/server/lib/opencode/startup-pipeline-runtime.js

@@ -34,7 +34,6 @@ export const createStartupPipelineRuntime = (dependencies) => {
       terminalRebindWindowMs,
       terminalMaxRebindsPerWindow,
       setupProxy,
-      scheduleOpenCodeApiDetection,
       bootstrapOpenCodeAtStartup,
       staticRoutesRuntime,
       process,
@@ -132,13 +131,15 @@ export const createStartupPipelineRuntime = (dependencies) => {
       bindHost,
       startupTunnelRequest,
       onTunnelReady,
+      afterListening: async ({ activePort }) => {
+        tunnelRuntimeContext.setActivePort(activePort);
+        await bootstrapOpenCodeAtStartup();
+      },
     });
     recordStartupPerformance('web.listener.ready', {
       durationMs: performance.now() - pipelineStartedAt,
     });
-    tunnelRuntimeContext.setActivePort(startupResult.activePort);
-    scheduleOpenCodeApiDetection();
-    void bootstrapOpenCodeAtStartup();
+
 
     serverStartupRuntime.attachProcessHandlers({ attachSignals });
 

package/server/lib/opencode/startup-pipeline-runtime.test.js

@@ -3,23 +3,27 @@ import { describe, expect, it, vi } from 'vitest';
 import { createStartupPipelineRuntime } from './startup-pipeline-runtime.js';
 
 describe('startup pipeline runtime', () => {
-  it('publishes the listening port before bootstrapping managed OpenCode', async () => {
+  it('publishes the listening port before awaiting OpenCode bootstrap', async () => {
     const order = [];
+    let releaseBootstrap;
+    const bootstrapGate = new Promise((resolve) => { releaseBootstrap = resolve; });
     const runtime = createStartupPipelineRuntime({
       createTerminalRuntime: () => ({}),
       createDictationRuntime: () => ({}),
       createMessageStreamWsRuntime: () => ({}),
       createServerStartupRuntime: () => ({
         resolveBindHost: () => '127.0.0.1',
-        startListeningAndMaybeTunnel: async () => {
+        startListeningAndMaybeTunnel: async ({ afterListening }) => {
           order.push('listen');
+          await afterListening({ activePort: 3901, bindHost: '127.0.0.1' });
+          order.push('ready');
           return { activePort: 3901 };
         },
         attachProcessHandlers: vi.fn(),
       }),
     });
 
-    await runtime.run({
+    const run = runtime.run({
       app: {},
       setupProxy: vi.fn(),
       staticRoutesRuntime: { registerStaticRoutes: vi.fn() },
@@ -27,14 +31,21 @@ describe('startup pipeline runtime', () => {
       tunnelRuntimeContext: {
         setActivePort: (port) => order.push(`port:${port}`),
       },
-      scheduleOpenCodeApiDetection: () => order.push('detect'),
-      bootstrapOpenCodeAtStartup: () => order.push('bootstrap'),
+      bootstrapOpenCodeAtStartup: async () => {
+        order.push('bootstrap');
+        await bootstrapGate;
+      },
       process: {},
       crypto: {},
-      server: {},
+      server: { close: (callback) => callback() },
       attachSignals: false,
     });
 
-    expect(order).toEqual(['listen', 'port:3901', 'detect', 'bootstrap']);
+    await Promise.resolve();
+    expect(order).toEqual(['listen', 'port:3901', 'bootstrap']);
+    releaseBootstrap();
+    await run;
+
+    expect(order).toEqual(['listen', 'port:3901', 'bootstrap', 'ready']);
   });
 });

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

@@ -1,23 +1,9 @@
-// TEMPORARY WORKAROUND — Windows ARM64: native opencode.exe fails with a Bun
-// FFI/TinyCC dlopen error (https://github.com/anomalyco/opencode/issues/19130).
-// Disable OpenCode self-upgrade on ARM64 so it can't overwrite the working x64
-// binary with the broken ARM64 build. Remove when the upstream issue is resolved.
-const isWindowsArm64 = () => process.platform === 'win32' && process.arch === 'arm64';
-
 export const resolveOpenCodeUpgradeCapability = ({
   isExternal,
   hasManagedProcess,
   activeBinary,
   isBundledBinary,
 }) => {
-  if (isWindowsArm64()) {
-    return {
-      supported: false,
-      manager: 'openchamber',
-      reason: 'windows-arm64-workaround',
-    };
-  }
-
   if (isExternal) {
     return {
       supported: false,

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

@@ -21,14 +21,16 @@
  *    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.
+ * 3. Only 1.x activity since the last completed import triggers a new one.
+ *    A v2 delete removes the `session_v2` row but leaves the legacy `session`
+ *    row behind, so "missing from v2" alone would bring deleted sessions back
+ *    on every start. A legacy session counts as missing only when its
+ *    `time_updated` is newer than the completion stamp OpenCode writes on
+ *    `migration.v1-v2`: only OpenCode 1.x writes that table, so an unchanged
+ *    table means nobody ran 1.x since and the top-up skips. Decided by the
+ *    maintainer (2026-09-24). When 1.x was used again, OpenCode still walks
+ *    every id below the cursor, so a deleted session sorting below a fresh one
+ *    comes back with it; that needs an import route taking an explicit list.
  *
  * 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
@@ -196,11 +198,15 @@ const findRevisitedSessionsWithV2Activity = (db, cursor, completedAt) =>
       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)';
+/**
+ * A legacy session with no `session_v2` twin that 1.x touched after the last
+ * completed import (see rule 3). Bound parameter: the completion timestamp.
+ */
+const MISSING_CONDITION = 'id NOT IN (SELECT id FROM session_v2) AND time_updated > ?';
 
-const countMissingSessions = (db) =>
-  firstRow(countRowSchema, db.all(`SELECT COUNT(*) AS value FROM session WHERE ${MISSING_CONDITION}`))?.value ?? 0;
+const countMissingSessions = (db, completedAt) =>
+  firstRow(countRowSchema, db.all(`SELECT COUNT(*) AS value FROM session WHERE ${MISSING_CONDITION}`, [completedAt]))
+    ?.value ?? 0;
 
 const countRevisitedSessions = (db, cursor) =>
   firstRow(
@@ -244,12 +250,12 @@ export const topUpV1Migration = (options = {}) => {
     const migration = readCompletedMigration(db);
     if (!migration) return outcome('skipped', 'migration-not-completed');
 
-    const missingCount = countMissingSessions(db);
+    const missingCount = countMissingSessions(db, migration.completedAt);
     if (missingCount === 0) return outcome('skipped', 'nothing-missing');
 
     const maxMissing = firstRow(
       nullableIdRowSchema,
-      db.all(`SELECT MAX(id) AS id FROM session WHERE ${MISSING_CONDITION}`),
+      db.all(`SELECT MAX(id) AS id FROM session WHERE ${MISSING_CONDITION}`, [migration.completedAt]),
     )?.id;
     if (!maxMissing) return outcome('skipped', 'nothing-missing');
 
@@ -271,7 +277,7 @@ export const topUpV1Migration = (options = {}) => {
       MIGRATION_STATE_KEY,
     ]);
     logger.log(
-      `[OpenCode] Scheduled the import of ${missingCount} OpenCode 1.x session(s) created after the v2 migration; ` +
+      `[OpenCode] Scheduled the import of ${missingCount} OpenCode 1.x session(s) changed since the last v2 import; ` +
         `OpenCode will re-import ${revisitedCount} untouched session(s) on the way.`,
     );
     return outcome('scheduled', undefined, missingCount, revisitedCount);

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

@@ -226,13 +226,21 @@ describe.skipIf(!sqlite)('topUpV1Migration', () => {
     });
   });
 
-  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.
+  it('does not bring back a session deleted in v2 when 1.x was not used since', () => {
+    // ses_a was imported and then deleted in v2: only its legacy row is left,
+    // untouched since the last completed import.
     createDatabase();
-    seed({ v1: [{ id: 'ses_a', timeCreated: COMPLETED_AT - 1 }, 'ses_d'] });
-    expect(run()).toEqual({ status: 'scheduled', missing: 2, revisited: 0 });
+    seed({ v1: [{ id: 'ses_a', timeCreated: COMPLETED_AT - 1 }] });
+    expect(run()).toEqual({ status: 'skipped', missing: 0, revisited: 0, reason: 'nothing-missing' });
+    expect(readMigrationRow().state).toEqual({ phase: 'completed' });
+  });
+
+  it('imports only sessions 1.x changed since the last import, cursor included', () => {
+    // ses_z (deleted in v2, old) sorts above ses_d (fresh from 1.x): the
+    // cursor must stop at ses_d so ses_z stays gone.
+    createDatabase();
+    seed({ v1: [{ id: 'ses_z', timeCreated: COMPLETED_AT - 1 }, 'ses_d'] });
+    expect(run()).toEqual({ status: 'scheduled', missing: 1, revisited: 0 });
     expect(readMigrationRow().state).toEqual({ phase: 'sessions', cursor: computeResumeCursor('ses_d') });
   });
 

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

@@ -4,5 +4,6 @@ export function installOpenCodeV2(options?: {
   env?: NodeJS.ProcessEnv;
   fetchImpl?: typeof fetch;
   platform?: NodeJS.Platform;
+  arch?: NodeJS.Architecture;
   tarCommand?: string;
 }): Promise<string>;

package/server/lib/opencode/v2-install.js

@@ -18,10 +18,10 @@ const packageDistSchema = z.object({
 });
 
 // OpenCode's installer is a bash script, so Windows installs the npm platform
-// package that script downloads. x64-baseline serves arm64 too: the native arm64
-// build fails to load (https://github.com/anomalyco/opencode/issues/19130), the
-// same workaround the desktop bundle uses in packages/electron/scripts/prepare-opencode-cli.mjs.
-const WINDOWS_PACKAGE = '@opencode/cli-windows-x64-baseline';
+// package that script downloads, the same one the desktop bundle picks in
+// packages/electron/scripts/prepare-opencode-cli.mjs. x64 takes the baseline
+// build so hosts without AVX2 still run it.
+const windowsPackage = (arch) => (arch === 'arm64' ? '@opencode/cli-windows-arm64' : '@opencode/cli-windows-x64-baseline');
 
 export const supportsOpenCodeV2Install = (platform = process.platform) =>
   (platform === 'darwin' || platform === 'linux' || platform === 'win32') && (process.arch === 'x64' || process.arch === 'arm64');
@@ -72,8 +72,8 @@ const prepareInstallerScript = async ({ version, workDirectory, env, fetchImpl }
  * Downloads the Windows platform package, checks it against the integrity npm
  * publishes for it, and unpacks it. Returns the step that replaces the binary.
  */
-const prepareWindowsBinary = async ({ version, directory, workDirectory, fetchImpl, tarCommand }) => {
-  const metadataResponse = await fetchImpl(`${NPM_REGISTRY}/${WINDOWS_PACKAGE.replace('/', '%2F')}/${version}`, { signal: AbortSignal.timeout(15_000) });
+const prepareWindowsBinary = async ({ version, arch, directory, workDirectory, fetchImpl, tarCommand }) => {
+  const metadataResponse = await fetchImpl(`${NPM_REGISTRY}/${windowsPackage(arch).replace('/', '%2F')}/${version}`, { signal: AbortSignal.timeout(15_000) });
   if (!metadataResponse.ok) throw new Error('Could not resolve the OpenCode v2 package.');
   const { dist } = packageDistSchema.parse(await metadataResponse.json());
   if (new URL(dist.tarball).origin !== NPM_REGISTRY) throw new Error('The OpenCode v2 package is not served by the npm registry.');
@@ -100,6 +100,7 @@ export const installOpenCodeV2 = async ({
   env = process.env,
   fetchImpl = fetch,
   platform = process.platform,
+  arch = process.arch,
   // Windows' own bsdtar. Git Bash's GNU tar on PATH reads `C:\...` as a remote host.
   tarCommand = path.join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'tar.exe'),
 } = {}) => {
@@ -119,7 +120,7 @@ export const installOpenCodeV2 = async ({
     if (!releaseResponse.ok) throw new Error('Could not resolve the OpenCode v2 release.');
     const { version } = releaseSchema.parse(await releaseResponse.json());
     const replaceBinary = windows
-      ? await prepareWindowsBinary({ version, directory, workDirectory: lock, fetchImpl, tarCommand })
+      ? await prepareWindowsBinary({ version, arch, directory, workDirectory: lock, fetchImpl, tarCommand })
       : await prepareInstallerScript({ version, workDirectory: lock, env, fetchImpl });
     for (const name of binaryNames) {
       const target = path.join(directory, name);