@openchambery/web 1.19.21-beta.1 → 2.0.0-beta.1

package/server/lib/opencode/opencode2-pin.js

@@ -0,0 +1,139 @@
+// Pinned desktop/runtime opencode2. Upgrade and prepare must not fall back to 1.18.x.
+export const PINNED_OPENCODE2_VERSION = '2.0.12';
+
+// Global npm/bun package that installs the opencode2 binary (not 1.x opencode-ai).
+export const OPENCODE2_NPM_PACKAGE = '@opencode/cli';
+
+export function isOpenCode1xVersion(value) {
+  if (typeof value !== 'string') return false;
+  const normalized = value.trim().replace(/^v/i, '');
+  if (!normalized) return false;
+  return /^1(?:\.|$)/.test(normalized);
+}
+
+/**
+ * Health admission for managed/external opencode2.
+ * healthy alone is not enough: reject 1.x and missing/unknown version strings.
+ */
+export function isAcceptableOpenCode2HealthVersion(value) {
+  if (typeof value !== 'string') return false;
+  const normalized = value.trim().replace(/^v/i, '');
+  if (!normalized) return false;
+  if (isOpenCode1xVersion(normalized)) return false;
+  // Require a version-like token (semver or next pin), not free-form noise.
+  return /^\d+(?:\.\d+)*(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(normalized);
+}
+
+/**
+ * Pure health/info body gate used by lifecycle and VS Code sidecar.
+ * Accepts classic `{ healthy: true, version }` and official 2.x `ServerInfo`
+ * (`GET /api/info` → `{ version, pid, urls, paths }` without `healthy`).
+ * @param {{ healthy?: unknown, version?: unknown } | null | undefined} body
+ * @returns {{ ok: boolean, version: string | null, reason?: string }}
+ */
+export function evaluateOpenCodeHealthBody(body) {
+  if (!body || typeof body !== 'object' || Array.isArray(body)) {
+    return { ok: false, version: null, reason: 'invalid-body' };
+  }
+  // Classic /api/health required healthy:true; /api/info omits healthy entirely.
+  if (Object.prototype.hasOwnProperty.call(body, 'healthy') && body.healthy !== true) {
+    return { ok: false, version: null, reason: 'unhealthy' };
+  }
+  const raw = typeof body.version === 'string' ? body.version.trim() : '';
+  const version = raw ? raw.replace(/^v/i, '') : null;
+  if (!isAcceptableOpenCode2HealthVersion(version)) {
+    if (isOpenCode1xVersion(version)) {
+      return { ok: false, version, reason: '1x-version' };
+    }
+    return { ok: false, version, reason: 'unknown-version' };
+  }
+  return { ok: true, version };
+}
+
+export function rejectOpenCode1xUpgradeTarget(target) {
+  if (isOpenCode1xVersion(target)) {
+    const error = new Error(`OpenCode upgrade refuses 1.x target: ${target}`);
+    error.code = 'OPENCODE_UPGRADE_1X_REFUSED';
+    throw error;
+  }
+  return target;
+}
+
+export function resolveOpenCode2UpgradeTarget(target) {
+  const trimmed = typeof target === 'string' ? target.trim() : '';
+  if (trimmed) {
+    rejectOpenCode1xUpgradeTarget(trimmed);
+    return trimmed;
+  }
+  return PINNED_OPENCODE2_VERSION;
+}
+
+/**
+ * Parse `opencode2 --version` / `opencode --version` stdout.
+ * v2: `opencode2 v2.0.12` (name then version). 1.x: `1.18.18`.
+ */
+export function parseOpenCode2VersionOutput(stdout) {
+  const tokens = String(stdout || '').trim().split(/\s+/);
+  const versionToken = tokens.find((token) => /^v?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(token));
+  if (!versionToken) return '';
+  return versionToken.replace(/^v/, '');
+}
+
+export function openCodeBinaryName(platform = process.platform) {
+  return platform === 'win32' ? 'opencode.exe' : 'opencode';
+}
+
+/** @deprecated Packaging leftover. Runtime install uses `openCodeBinaryName`. */
+export function openCode2BinaryName(platform = process.platform) {
+  return platform === 'win32' ? 'opencode2.exe' : 'opencode2';
+}
+
+export function resolveOpenCode2NpmArchitecture(arch = process.arch) {
+  const normalized = String(arch || '').trim().toLowerCase();
+  if (normalized === 'x64' || normalized === 'amd64' || normalized === 'x86_64') return 'x64';
+  if (normalized === 'arm64' || normalized === 'aarch64') return 'arm64';
+  throw new Error(`Unsupported OpenCode architecture ${JSON.stringify(arch)}`);
+}
+
+/**
+ * Official 2.x ships as `@opencode/cli-<os>-<arch>[-baseline]`.
+ * `targetArchitecture` may be `{ opencode }` (Electron prepare) or an arch string.
+ */
+export function npmPackageForOpenCode2(platform = process.platform, targetArchitecture = process.arch) {
+  const rawArch = targetArchitecture && typeof targetArchitecture === 'object'
+    ? (targetArchitecture.opencode ?? targetArchitecture.node)
+    : targetArchitecture;
+  const arch = resolveOpenCode2NpmArchitecture(rawArch);
+  const os = { darwin: 'darwin', win32: 'windows', linux: 'linux' }[platform];
+  if (!os) throw new Error(`No opencode2 npm package mapping for platform ${platform}`);
+  const suffix = arch === 'x64' ? '-baseline' : '';
+  return `@opencode/cli-${os}-${arch}${suffix}`;
+}
+
+function parseVersionForComparison(value) {
+  const normalized = String(value || '').replace(/^v/i, '').split('+')[0];
+  const prereleaseIndex = normalized.indexOf('-');
+  const core = prereleaseIndex >= 0 ? normalized.slice(0, prereleaseIndex) : normalized;
+  const parts = core.split('.').map((part) => {
+    const parsed = Number.parseInt(part || '0', 10);
+    return Number.isFinite(parsed) ? parsed : 0;
+  });
+  return { parts, prerelease: prereleaseIndex >= 0 };
+}
+
+export function compareOpenCode2Versions(left, right) {
+  const a = parseVersionForComparison(left);
+  const b = parseVersionForComparison(right);
+  const length = Math.max(a.parts.length, b.parts.length);
+  for (let index = 0; index < length; index += 1) {
+    const diff = (a.parts[index] || 0) - (b.parts[index] || 0);
+    if (diff !== 0) return diff;
+  }
+  if (a.prerelease !== b.prerelease) return a.prerelease ? -1 : 1;
+  return 0;
+}
+
+export function isOpenCode2VersionAtLeast(version, minimum = PINNED_OPENCODE2_VERSION) {
+  if (!isAcceptableOpenCode2HealthVersion(version)) return false;
+  return compareOpenCode2Versions(version, minimum) >= 0;
+}

package/server/lib/opencode/opencode2-pin.test.js

@@ -0,0 +1,87 @@
+import { describe, expect, it } from 'vitest';
+import {
+  OPENCODE2_NPM_PACKAGE,
+  PINNED_OPENCODE2_VERSION,
+  compareOpenCode2Versions,
+  evaluateOpenCodeHealthBody,
+  isAcceptableOpenCode2HealthVersion,
+  isOpenCode1xVersion,
+  isOpenCode2VersionAtLeast,
+  npmPackageForOpenCode2,
+  parseOpenCode2VersionOutput,
+  rejectOpenCode1xUpgradeTarget,
+  resolveOpenCode2UpgradeTarget,
+} from './opencode2-pin.js';
+
+describe('opencode2 pin (ticket 12)', () => {
+  it('rejects 1.x version strings and accepts the pinned v2', () => {
+    expect(isOpenCode1xVersion('1.18.4')).toBe(true);
+    expect(isOpenCode1xVersion('v1.18.18')).toBe(true);
+    expect(isOpenCode1xVersion('1.18.x')).toBe(true);
+    expect(isOpenCode1xVersion('1')).toBe(true);
+    expect(isOpenCode1xVersion(PINNED_OPENCODE2_VERSION)).toBe(false);
+    expect(isOpenCode1xVersion('2.0.12')).toBe(false);
+    expect(isOpenCode1xVersion('')).toBe(false);
+    expect(isOpenCode1xVersion(null)).toBe(false);
+  });
+
+  it('throws on 1.x upgrade targets and defaults empty to the pin', () => {
+    expect(() => rejectOpenCode1xUpgradeTarget('1.18.4')).toThrow(/1\.x/);
+    expect(() => rejectOpenCode1xUpgradeTarget('1.18.4')).toThrow(expect.objectContaining({ code: 'OPENCODE_UPGRADE_1X_REFUSED' }));
+    expect(resolveOpenCode2UpgradeTarget(undefined)).toBe(PINNED_OPENCODE2_VERSION);
+    expect(resolveOpenCode2UpgradeTarget('')).toBe(PINNED_OPENCODE2_VERSION);
+    expect(resolveOpenCode2UpgradeTarget(PINNED_OPENCODE2_VERSION)).toBe(PINNED_OPENCODE2_VERSION);
+    expect(() => resolveOpenCode2UpgradeTarget('1.18.18')).toThrow(/1\.x/);
+  });
+
+  it('pins the opencode2 npm package name (not 1.x opencode-ai)', () => {
+    expect(OPENCODE2_NPM_PACKAGE).toBe('@opencode/cli');
+    expect(OPENCODE2_NPM_PACKAGE).not.toBe('opencode-ai');
+    expect(OPENCODE2_NPM_PACKAGE).not.toBe('@opencode-ai/cli');
+  });
+
+  it('accepts authoritative v2 health/info versions and rejects 1.x / missing / noise', () => {
+    expect(isAcceptableOpenCode2HealthVersion(PINNED_OPENCODE2_VERSION)).toBe(true);
+    expect(isAcceptableOpenCode2HealthVersion('v2.0.12')).toBe(true);
+    expect(isAcceptableOpenCode2HealthVersion('1.15.0')).toBe(false);
+    expect(isAcceptableOpenCode2HealthVersion('v1.18.18')).toBe(false);
+    expect(isAcceptableOpenCode2HealthVersion('')).toBe(false);
+    expect(isAcceptableOpenCode2HealthVersion(null)).toBe(false);
+    expect(isAcceptableOpenCode2HealthVersion('not-a-version')).toBe(false);
+
+    expect(evaluateOpenCodeHealthBody({ healthy: true, version: PINNED_OPENCODE2_VERSION })).toEqual({
+      ok: true,
+      version: PINNED_OPENCODE2_VERSION,
+    });
+    // Official 2.x ServerInfo from GET /api/info has version without healthy.
+    expect(evaluateOpenCodeHealthBody({ version: PINNED_OPENCODE2_VERSION, pid: 1 })).toEqual({
+      ok: true,
+      version: PINNED_OPENCODE2_VERSION,
+    });
+    expect(evaluateOpenCodeHealthBody({ healthy: true, version: '1.15.0' })).toMatchObject({
+      ok: false,
+      version: '1.15.0',
+      reason: '1x-version',
+    });
+    expect(evaluateOpenCodeHealthBody({ healthy: true })).toMatchObject({
+      ok: false,
+      reason: 'unknown-version',
+    });
+    expect(evaluateOpenCodeHealthBody({ healthy: false, version: PINNED_OPENCODE2_VERSION })).toMatchObject({
+      ok: false,
+      reason: 'unhealthy',
+    });
+    expect(evaluateOpenCodeHealthBody(null)).toMatchObject({ ok: false, reason: 'invalid-body' });
+  });
+
+  it('parses --version output and compares against the pin', () => {
+    expect(parseOpenCode2VersionOutput('opencode2 v2.0.12\n')).toBe('2.0.12');
+    expect(parseOpenCode2VersionOutput('1.18.18\n')).toBe('1.18.18');
+    expect(compareOpenCode2Versions('2.0.12', '2.0.1')).toBeGreaterThan(0);
+    expect(isOpenCode2VersionAtLeast('2.0.12', '2.0.12')).toBe(true);
+    expect(isOpenCode2VersionAtLeast('2.0.1', '2.0.12')).toBe(false);
+    expect(isOpenCode2VersionAtLeast('1.18.18', '2.0.12')).toBe(false);
+    expect(npmPackageForOpenCode2('darwin', 'arm64')).toBe('@opencode/cli-darwin-arm64');
+    expect(npmPackageForOpenCode2('darwin', { opencode: 'x64' })).toBe('@opencode/cli-darwin-x64-baseline');
+  });
+});

package/server/lib/opencode/opencode2-sidecar.e2e.test.js

@@ -0,0 +1,203 @@
+import { afterEach, describe, expect, it } from 'bun:test';
+import net from 'node:net';
+import path from 'node:path';
+
+import { createOpenCodeEnvRuntime } from './env-runtime.js';
+import { createOpenCodeLifecycleRuntime } from './lifecycle.js';
+import { createOpenCodeNetworkRuntime } from './network-runtime.js';
+import { fetchV1MigrationGate } from './v1-migration-gate.js';
+
+const E2E_PASSWORD = 'openchamber-opencode2-e2e';
+const basicAuth = `Basic ${Buffer.from(`opencode:${E2E_PASSWORD}`, 'utf8').toString('base64')}`;
+const OPENCODE2_HEALTH_VERSION = /^(?:v)?(?:0\.0\.0-(?:next|beta)(?:-\d+)?|2(?:\.\d+)*)/i;
+const OPENCODE_1X_VERSION = /^v?1(?:\.|$)/;
+
+const freePort = () => new Promise((resolve, reject) => {
+  const server = net.createServer();
+  server.once('error', reject);
+  server.listen(0, '127.0.0.1', () => {
+    const address = server.address();
+    server.close((error) => (error ? reject(error) : resolve(address.port)));
+  });
+});
+
+const jsonGet = async (url, pathname) => {
+  const response = await fetch(`${url.replace(/\/+$/, '')}${pathname}`, {
+    headers: {
+      Accept: 'application/json',
+      Authorization: basicAuth,
+    },
+  });
+  const body = await response.json().catch(() => null);
+  return { status: response.status, body };
+};
+
+const jsonPost = async (url, pathname, payload) => {
+  const response = await fetch(`${url.replace(/\/+$/, '')}${pathname}`, {
+    method: 'POST',
+    headers: {
+      Accept: 'application/json',
+      Authorization: basicAuth,
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify(payload ?? {}),
+  });
+  const body = await response.json().catch(() => null);
+  return { status: response.status, body };
+};
+
+describe('opencode2 sidecar e2e', () => {
+  let server = null;
+  const previousBinary = process.env.OPENCODE_BINARY;
+  const previousPassword = process.env.OPENCODE_PASSWORD;
+
+  afterEach(async () => {
+    if (server?.close) {
+      await server.close().catch(() => {});
+      server = null;
+    }
+    if (typeof previousBinary === 'string') {
+      process.env.OPENCODE_BINARY = previousBinary;
+    } else {
+      delete process.env.OPENCODE_BINARY;
+    }
+    if (typeof previousPassword === 'string') {
+      process.env.OPENCODE_PASSWORD = previousPassword;
+    } else {
+      delete process.env.OPENCODE_PASSWORD;
+    }
+  });
+
+  it('starts managed opencode2 and serves health, migration, session, and message projection', async () => {
+    delete process.env.OPENCODE_BINARY;
+    delete process.env.OPENCODE_PATH;
+    delete process.env.OPENCHAMBER_OPENCODE_PATH;
+    delete process.env.OPENCHAMBER_OPENCODE_BIN;
+
+    const envRuntime = createOpenCodeEnvRuntime({
+      state: {
+        cachedLoginShellEnvSnapshot: null,
+        resolvedOpencodeBinary: null,
+        resolvedOpencodeBinarySource: null,
+        useWslForOpencode: false,
+        resolvedWslBinary: null,
+        resolvedWslOpencodePath: null,
+        resolvedWslDistro: null,
+        resolvedNodeBinary: null,
+        resolvedBunBinary: null,
+        managedOpenCodeShellEnvSnapshot: null,
+      },
+      normalizeDirectoryPath: (value) => value,
+      readSettingsFromDiskMigrated: async () => ({}),
+    });
+
+    const resolved = envRuntime.resolveOpencodeCliPath();
+    expect(resolved).toBeTruthy();
+    expect(path.basename(resolved).replace(/\.exe$/i, '')).toBe('opencode2');
+
+    process.env.OPENCODE_BINARY = resolved;
+    process.env.OPENCODE_PASSWORD = E2E_PASSWORD;
+
+    const port = await freePort();
+    const state = {
+      openCodeWorkingDirectory: process.cwd(),
+      openCodeProcess: null,
+      openCodePort: null,
+      openCodeBaseUrl: null,
+      currentRestartPromise: null,
+      isRestartingOpenCode: false,
+      openCodeApiPrefix: '',
+      openCodeApiPrefixDetected: false,
+      openCodeApiDetectionTimer: null,
+      lastOpenCodeError: null,
+      isOpenCodeReady: false,
+      v1Migration: null,
+      openCodeNotReadySince: 0,
+      isExternalOpenCode: false,
+      isShuttingDown: false,
+      healthCheckInterval: null,
+      expressApp: null,
+      useWslForOpencode: false,
+      resolvedWslBinary: null,
+      resolvedWslOpencodePath: null,
+      resolvedWslDistro: null,
+    };
+
+    const getOpenCodeAuthHeaders = () => ({ Authorization: basicAuth });
+    const network = createOpenCodeNetworkRuntime({
+      state,
+      getOpenCodeAuthHeaders,
+      configuredOpenCodeHostname: '127.0.0.1',
+    });
+
+    const runtime = createOpenCodeLifecycleRuntime({
+      state,
+      env: {
+        ENV_CONFIGURED_OPENCODE_PORT: port,
+        ENV_CONFIGURED_OPENCODE_HOST: null,
+        ENV_EFFECTIVE_PORT: port,
+        ENV_CONFIGURED_OPENCODE_HOSTNAME: '127.0.0.1',
+        ENV_SKIP_OPENCODE_START: false,
+      },
+      syncToHmrState: () => {},
+      syncFromHmrState: () => {},
+      getOpenCodeAuthHeaders,
+      buildOpenCodeUrl: (route) => `http://127.0.0.1:${state.openCodePort || port}${route}`,
+      waitForReady: network.waitForReady,
+      normalizeApiPrefix: network.normalizeApiPrefix,
+      applyOpencodeBinaryFromSettings: async () => resolved,
+      ensureOpencodeCliEnv: () => {},
+      ensureLocalOpenCodeServerPassword: async () => E2E_PASSWORD,
+      resolveManagedOpenCodeLaunchSpec: envRuntime.resolveManagedOpenCodeLaunchSpec,
+      setOpenCodePort: (nextPort) => {
+        state.openCodePort = nextPort;
+      },
+      setDetectedOpenCodeApiPrefix: network.setDetectedOpenCodeApiPrefix,
+      setupProxy: () => {},
+      ensureOpenCodeApiPrefix: () => {},
+      clearResolvedOpenCodeBinary: envRuntime.clearResolvedOpenCodeBinary,
+      buildAugmentedPath: () => process.env.PATH,
+      buildManagedOpenCodePath: () => process.env.PATH,
+      getManagedOpenCodeShellEnvSnapshot: () => ({
+        PATH: process.env.PATH,
+        OPENCODE_PASSWORD: E2E_PASSWORD,
+        OPENCODE_SERVER_PASSWORD: E2E_PASSWORD,
+      }),
+    });
+
+    server = await runtime.startOpenCode();
+    expect(server.url).toMatch(/^http:\/\/127\.0\.0\.1:\d+$/);
+    expect(String(state.lastOpenCodeLaunchDiagnostics?.binary || '')).toContain('opencode2');
+
+    const health = await jsonGet(server.url, '/api/info');
+    expect(health.status).toBe(200);
+    expect(health.body).toMatchObject({
+      healthy: true,
+      version: expect.stringMatching(OPENCODE2_HEALTH_VERSION),
+    });
+    expect(String(health.body?.version ?? '')).not.toMatch(OPENCODE_1X_VERSION);
+
+    const unauthenticated = await fetch(`${server.url}/api/info`);
+    expect(unauthenticated.status).toBe(401);
+
+    const gate = await fetchV1MigrationGate({
+      url: `${server.url}/api/experimental/migration/v1`,
+      headers: getOpenCodeAuthHeaders(),
+    });
+    expect(gate.admitTranscript).toBe(true);
+    expect(['completed', 'absent']).toContain(gate.phase);
+
+    const created = await jsonPost(server.url, '/api/session', {});
+    expect(created.status).toBe(200);
+    const sessionID = created.body?.data?.id ?? created.body?.id;
+    expect(sessionID).toMatch(/^ses_/);
+
+    const messages = await jsonGet(
+      server.url,
+      `/api/session/${encodeURIComponent(sessionID)}/message?limit=20&order=desc`,
+    );
+    expect(messages.status).toBe(200);
+    const page = messages.body?.data ?? messages.body;
+    expect(Array.isArray(page)).toBe(true);
+  }, 60_000);
+});

package/server/lib/opencode/plugin-compatibility.js

@@ -0,0 +1,15 @@
+// V1 plugin API cannot run on opencode2. Settings must mark this explicitly
+// instead of letting load fail silently.
+export const PLUGIN_COMPATIBILITY_V1_INCOMPATIBLE = 'v1-incompatible';
+
+export function pluginCompatibilityForV2() {
+  return {
+    compatibility: PLUGIN_COMPATIBILITY_V1_INCOMPATIBLE,
+    compatible: false,
+  };
+}
+
+export function withV1PluginIncompatibility(record) {
+  if (!record || typeof record !== 'object') return record;
+  return { ...record, ...pluginCompatibilityForV2() };
+}

package/server/lib/opencode/plugin-compatibility.test.js

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest';
+import {
+  PLUGIN_COMPATIBILITY_V1_INCOMPATIBLE,
+  pluginCompatibilityForV2,
+  withV1PluginIncompatibility,
+} from './plugin-compatibility.js';
+
+describe('V1 plugin compatibility (ticket 12)', () => {
+  it('marks V1 plugins incompatible instead of a silent load failure', () => {
+    expect(pluginCompatibilityForV2()).toEqual({
+      compatibility: PLUGIN_COMPATIBILITY_V1_INCOMPATIBLE,
+      compatible: false,
+    });
+    expect(withV1PluginIncompatibility({ id: 'config:user:oh-my-opencode', spec: 'oh-my-opencode' })).toEqual({
+      id: 'config:user:oh-my-opencode',
+      spec: 'oh-my-opencode',
+      compatibility: 'v1-incompatible',
+      compatible: false,
+    });
+  });
+});

package/server/lib/opencode/plugins.js

@@ -7,6 +7,7 @@ import {
   writeConfig,
 } from './shared.js';
 import { isPathSpec } from './plugin-spec.js';
+import { withV1PluginIncompatibility } from './plugin-compatibility.js';
 
 const PLUGIN_FILE_NAME_PATTERN = /^[a-z0-9][a-z0-9-_.]*\.(js|ts|mjs|cjs)$/;
 
@@ -248,7 +249,7 @@ function listPluginEntries(workingDirectory) {
     }
     return source.config.plugin.map((raw) => {
       const parsed = parsePluginRaw(raw);
-      return {
+      return withV1PluginIncompatibility({
         id: encodePluginId('config', `${source.scope}:${parsed.spec}`),
         spec: parsed.spec,
         ...(parsed.options !== undefined ? { options: parsed.options } : {}),
@@ -256,7 +257,7 @@ function listPluginEntries(workingDirectory) {
         kind: 'config',
         parsedKind: parsedKindForSpec(parsed.spec),
         sourcePath: source.filePath,
-      };
+      });
     });
   });
 }
@@ -333,7 +334,7 @@ function listPluginDirFiles(workingDirectory) {
     }
     return fs.readdirSync(dir, { withFileTypes: true })
       .filter((entry) => entry.isFile() && PLUGIN_FILE_NAME_PATTERN.test(entry.name) && !entry.name.includes('..'))
-      .map((entry) => ({
+      .map((entry) => withV1PluginIncompatibility({
         id: encodePluginId('file', `${scope}:${entry.name}`),
         fileName: entry.name,
         scope,

package/server/lib/opencode/plugins.test.js

@@ -138,6 +138,18 @@ describe('opencode plugins data layer', () => {
     ]);
   });
 
+  test('lists V1 plugins as incompatible instead of a silent load failure', () => {
+    writeJson(userConfigPath, { plugin: ['oh-my-opencode'] });
+    const entries = plugins.listPluginEntries(projectDir);
+    expect(entries).toEqual([
+      expect.objectContaining({
+        spec: 'oh-my-opencode',
+        compatibility: 'v1-incompatible',
+        compatible: false,
+      }),
+    ]);
+  });
+
   test('encodes and decodes ids', () => {
     const id = plugins.encodePluginId('config', 'user:oh-my-openagent@4.3.0');
     expect(plugins.decodePluginId(id)).toEqual({ prefix: 'config', value: 'user:oh-my-openagent@4.3.0' });