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

package/server/lib/opencode/owned-runtime-upgrade.js

@@ -0,0 +1,431 @@
+/**
+ * Ownership + upgrade status for OpenCode runtimes (ticket 12).
+ *
+ * Binary ownership and process ownership are modeled separately:
+ * - arbitrary external serve is never upgraded/restarted in-app
+ * - official shared service can be replaced using an owned-cache binary
+ * - managed process using a global CLI is "global-cli" (manual guidance)
+ * - managed process using OpenChamber cache under opencode-cli/ is "owned-cache"
+ * - bundled desktop binary cannot be upgraded separately
+ *
+ * In-app upgrade only mutates the owned cache, then launches that target and
+ * verifies the running serve identity/version/contract before success.
+ */
+
+import path from 'node:path';
+import {
+  PINNED_OPENCODE2_VERSION,
+  compareOpenCode2Versions,
+  isOpenCode1xVersion,
+  resolveOpenCode2UpgradeTarget,
+} from './opencode2-pin.js';
+import {
+  installedOpenCode2BinaryPath,
+  resolveOpenChamberDataDir,
+} from './ensure-cli.js';
+import { evaluateRuntimeContract, normalizeRuntimeVersion } from './runtime-contract.js';
+
+/** @typedef {'shared-service' | 'external-serve' | 'owned-cache' | 'global-cli' | 'bundled' | 'settings' | 'env' | 'unknown'} RuntimeOwnership */
+
+/**
+ * @param {string | null | undefined} binaryPath
+ * @param {string | null | undefined} dataDir
+ */
+export function isOwnedOpenCodeCachePath(binaryPath, dataDir) {
+  if (typeof binaryPath !== 'string' || !binaryPath.trim()) return false;
+  const root = typeof dataDir === 'string' && dataDir.trim()
+    ? path.resolve(dataDir.trim())
+    : resolveOpenChamberDataDir();
+  const cacheRoot = path.resolve(root, 'opencode-cli');
+  const resolved = path.resolve(binaryPath.trim());
+  const rel = path.relative(cacheRoot, resolved);
+  return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+
+/**
+ * @param {{
+ *   isExternal?: boolean,
+ *   isSharedService?: boolean,
+ *   binarySource?: string | null,
+ *   binaryPath?: string | null,
+ *   dataDir?: string | null,
+ * }} input
+ */
+export function classifyRuntimeOwnership(input = {}) {
+  if (input.isSharedService === true) {
+    return {
+      ownership: /** @type {RuntimeOwnership} */ ('shared-service'),
+      processOwnership: 'shared',
+      binaryOwnership: isOwnedOpenCodeCachePath(input.binaryPath, input.dataDir) ? 'owned-cache' : 'external-or-global',
+      canUpgradeInApp: true,
+      supplySource: 'shared-service',
+      management: 'in-app',
+      reason: null,
+      guidance: null,
+    };
+  }
+  if (input.isExternal === true) {
+    return {
+      ownership: /** @type {RuntimeOwnership} */ ('external-serve'),
+      processOwnership: 'external',
+      binaryOwnership: isOwnedOpenCodeCachePath(input.binaryPath, input.dataDir) ? 'owned-cache' : 'external-or-global',
+      canUpgradeInApp: false,
+      supplySource: 'external-serve',
+      management: 'manual-external',
+      reason: 'external-serve',
+      guidance: 'This is an external OpenCode serve. Restart or upgrade it yourself; OpenChamber will not replace that process.',
+    };
+  }
+
+  const source = typeof input.binarySource === 'string' ? input.binarySource.trim() : '';
+  const ownedPath = isOwnedOpenCodeCachePath(input.binaryPath, input.dataDir);
+
+  if (source === 'bundled') {
+    return {
+      ownership: /** @type {RuntimeOwnership} */ ('bundled'),
+      processOwnership: 'managed',
+      binaryOwnership: 'bundled',
+      canUpgradeInApp: false,
+      supplySource: 'bundled',
+      management: 'bundled',
+      reason: 'bundled',
+      guidance: 'OpenCode is bundled with OpenChamber Desktop and cannot be upgraded separately from the app.',
+    };
+  }
+
+  if (source === 'installed' || ownedPath) {
+    return {
+      ownership: /** @type {RuntimeOwnership} */ ('owned-cache'),
+      processOwnership: 'managed',
+      binaryOwnership: 'owned-cache',
+      canUpgradeInApp: true,
+      supplySource: 'owned-cache',
+      management: 'in-app',
+      reason: null,
+      guidance: null,
+    };
+  }
+
+  if (source === 'settings') {
+    return {
+      ownership: /** @type {RuntimeOwnership} */ ('settings'),
+      processOwnership: 'managed',
+      binaryOwnership: 'user-configured',
+      canUpgradeInApp: false,
+      supplySource: 'settings',
+      management: 'manual-global',
+      reason: 'settings-binary',
+      guidance: 'OpenCode is launched from a user-configured binary path. Change or upgrade that binary yourself, or clear the setting to use OpenChamber-managed cache.',
+    };
+  }
+
+  if (source === 'env') {
+    return {
+      ownership: /** @type {RuntimeOwnership} */ ('env'),
+      processOwnership: 'managed',
+      binaryOwnership: 'env',
+      canUpgradeInApp: false,
+      supplySource: 'env',
+      management: 'manual-global',
+      reason: 'env-binary',
+      guidance: 'OpenCode is launched from OPENCODE_BINARY / related env. Upgrade that install yourself, or unset the env to allow OpenChamber-owned cache management.',
+    };
+  }
+
+  // path / fallback / where / discovered → treat as global CLI (read-only for upgrade).
+  if (source === 'path' || source === 'fallback' || source === 'where' || source === 'discovered') {
+    return {
+      ownership: /** @type {RuntimeOwnership} */ ('global-cli'),
+      processOwnership: 'managed',
+      binaryOwnership: 'global-cli',
+      canUpgradeInApp: false,
+      supplySource: 'global-cli',
+      management: 'manual-global',
+      reason: 'global-cli',
+      guidance: 'OpenChamber is using your global OpenCode CLI. Upgrade it with your package manager (for example npm/bun), or install an OpenChamber-owned cache and select that target explicitly.',
+    };
+  }
+
+  return {
+    ownership: /** @type {RuntimeOwnership} */ ('unknown'),
+    processOwnership: input.isExternal ? 'external' : 'managed',
+    binaryOwnership: ownedPath ? 'owned-cache' : 'unknown',
+    canUpgradeInApp: ownedPath,
+    supplySource: ownedPath ? 'owned-cache' : 'unknown',
+    management: ownedPath ? 'in-app' : 'none',
+    reason: ownedPath ? null : 'unknown-ownership',
+    guidance: ownedPath
+      ? null
+      : 'OpenCode supply source could not be classified. In-app upgrade is disabled until ownership is clear.',
+  };
+}
+
+/**
+ * @param {{
+ *   ownership: ReturnType<typeof classifyRuntimeOwnership>,
+ *   serveVersion?: string | null,
+ *   cliVersion?: string | null,
+ *   targetVersion?: string | null,
+ *   contract?: ReturnType<typeof evaluateRuntimeContract> | null,
+ *   operation?: Record<string, unknown> | null,
+ *   hasActiveTasks?: boolean,
+ * }} input
+ */
+export function buildUpgradeStatusSnapshot(input) {
+  const ownership = input.ownership;
+  const serveVersion = normalizeRuntimeVersion(input.serveVersion);
+  const cliVersion = normalizeRuntimeVersion(input.cliVersion);
+  const currentVersion = serveVersion || cliVersion;
+  let targetVersion = null;
+  try {
+    targetVersion = resolveOpenCode2UpgradeTarget(input.targetVersion ?? PINNED_OPENCODE2_VERSION);
+  } catch {
+    targetVersion = PINNED_OPENCODE2_VERSION;
+  }
+  if (isOpenCode1xVersion(targetVersion)) {
+    targetVersion = PINNED_OPENCODE2_VERSION;
+  }
+
+  const contract = input.contract || evaluateRuntimeContract({
+    serveVersion,
+    cliVersion,
+    reachable: serveVersion != null || cliVersion != null,
+    authenticated: true,
+    healthOk: serveVersion != null,
+  });
+
+  const canManage = ownership.canUpgradeInApp === true;
+  const newerTarget = Boolean(
+    currentVersion
+    && targetVersion
+    && !isOpenCode1xVersion(currentVersion)
+    && compareOpenCode2Versions(targetVersion, currentVersion) > 0,
+  );
+  const available = canManage && newerTarget ? true : (canManage ? false : null);
+
+  /** @type {string | null} */
+  let reason = ownership.reason;
+  if (canManage && available === false && currentVersion && targetVersion) {
+    reason = 'up-to-date';
+  }
+  if (!canManage && ownership.reason) {
+    reason = ownership.reason;
+  }
+  if (input.hasActiveTasks === true && canManage && available) {
+    reason = reason || 'active-tasks';
+  }
+
+  return {
+    schemaVersion: 1,
+    available,
+    currentVersion,
+    serveVersion,
+    cliVersion,
+    latestVersion: targetVersion,
+    targetVersion,
+    supplySource: ownership.supplySource,
+    ownership: ownership.ownership,
+    processOwnership: ownership.processOwnership,
+    binaryOwnership: ownership.binaryOwnership,
+    canManage,
+    management: ownership.management,
+    reason,
+    guidance: ownership.guidance,
+    hasActiveTasks: input.hasActiveTasks === true,
+    contract,
+    operation: input.operation && typeof input.operation === 'object'
+      ? input.operation
+      : { status: 'idle' },
+  };
+}
+
+/**
+ * In-memory upgrade operation state (single-flight).
+ * @returns {{
+ *   getState: () => object,
+ *   begin: (target: string) => { ok: true } | { ok: false, status: number, body: object },
+ *   succeed: (result: object) => void,
+ *   fail: (error: object) => void,
+ *   resetIdle: () => void,
+ * }}
+ */
+export function createUpgradeOperationState() {
+  /** @type {{
+   *   status: 'idle' | 'running' | 'succeeded' | 'failed',
+   *   targetVersion: string | null,
+   *   startedAt: number | null,
+   *   finishedAt: number | null,
+   *   phase: string | null,
+   *   error: string | null,
+   *   errorCode: string | null,
+   *   serveVersion: string | null,
+   *   binaryPath: string | null,
+   * }} */
+  let state = {
+    status: 'idle',
+    targetVersion: null,
+    startedAt: null,
+    finishedAt: null,
+    phase: null,
+    error: null,
+    errorCode: null,
+    serveVersion: null,
+    binaryPath: null,
+  };
+
+  return {
+    getState: () => ({ ...state }),
+    begin: (target) => {
+      if (state.status === 'running') {
+        return {
+          ok: false,
+          status: 409,
+          body: {
+            success: false,
+            error: 'An OpenCode upgrade is already in progress',
+            errorCode: 'UPGRADE_IN_PROGRESS',
+            operation: { ...state },
+          },
+        };
+      }
+      state = {
+        status: 'running',
+        targetVersion: target,
+        startedAt: Date.now(),
+        finishedAt: null,
+        phase: 'starting',
+        error: null,
+        errorCode: null,
+        serveVersion: null,
+        binaryPath: null,
+      };
+      return { ok: true };
+    },
+    setPhase: (phase, extra = {}) => {
+      if (state.status !== 'running') return;
+      state = { ...state, phase, ...extra };
+    },
+    succeed: (result = {}) => {
+      state = {
+        ...state,
+        status: 'succeeded',
+        finishedAt: Date.now(),
+        phase: 'verified',
+        error: null,
+        errorCode: null,
+        serveVersion: result.serveVersion ?? state.serveVersion,
+        binaryPath: result.binaryPath ?? state.binaryPath,
+      };
+    },
+    fail: (error = {}) => {
+      state = {
+        ...state,
+        status: 'failed',
+        finishedAt: Date.now(),
+        phase: error.phase || state.phase || 'failed',
+        error: typeof error.error === 'string' ? error.error : (error.message || 'Upgrade failed'),
+        errorCode: error.errorCode || error.code || 'UPGRADE_FAILED',
+        serveVersion: error.serveVersion ?? state.serveVersion,
+        binaryPath: error.binaryPath ?? state.binaryPath,
+      };
+    },
+    resetIdle: () => {
+      state = {
+        status: 'idle',
+        targetVersion: null,
+        startedAt: null,
+        finishedAt: null,
+        phase: null,
+        error: null,
+        errorCode: null,
+        serveVersion: null,
+        binaryPath: null,
+      };
+    },
+  };
+}
+
+/**
+ * Resolve the on-disk path OpenChamber will use for an owned-cache target.
+ * @param {string} targetVersion
+ * @param {object} [options]
+ */
+export function resolveOwnedCacheBinaryPath(targetVersion, options = {}) {
+  const version = resolveOpenCode2UpgradeTarget(targetVersion);
+  return installedOpenCode2BinaryPath(version, options);
+}
+
+/**
+ * Pure post-upgrade verification: running serve must match target and pass contract.
+ * @param {{
+ *   targetVersion: string,
+ *   serveVersion?: string | null,
+ *   cliVersion?: string | null,
+ *   binaryPath?: string | null,
+ *   expectedBinaryPath?: string | null,
+ *   contract?: ReturnType<typeof evaluateRuntimeContract> | null,
+ * }} input
+ */
+export function evaluateOwnedUpgradeResult(input) {
+  const target = resolveOpenCode2UpgradeTarget(input.targetVersion);
+  const serveVersion = normalizeRuntimeVersion(input.serveVersion);
+  const cliVersion = normalizeRuntimeVersion(input.cliVersion);
+  const contract = input.contract || evaluateRuntimeContract({
+    serveVersion,
+    cliVersion,
+    reachable: true,
+    authenticated: true,
+    healthOk: Boolean(serveVersion),
+  });
+
+  if (!serveVersion) {
+    return {
+      ok: false,
+      errorCode: 'UPGRADE_SERVE_VERSION_MISSING',
+      error: 'Upgrade started but the running OpenCode serve did not report a version',
+      serveVersion,
+      targetVersion: target,
+      contract,
+    };
+  }
+  if (serveVersion !== target) {
+    return {
+      ok: false,
+      errorCode: 'UPGRADE_SERVE_VERSION_MISMATCH',
+      error: `Running serve version ${serveVersion} does not match upgrade target ${target}`,
+      serveVersion,
+      targetVersion: target,
+      contract,
+    };
+  }
+  if (input.expectedBinaryPath && input.binaryPath
+    && path.resolve(input.binaryPath) !== path.resolve(input.expectedBinaryPath)) {
+    return {
+      ok: false,
+      errorCode: 'UPGRADE_BINARY_IDENTITY_MISMATCH',
+      error: 'Managed process is not using the owned-cache binary selected for upgrade',
+      serveVersion,
+      targetVersion: target,
+      contract,
+    };
+  }
+  if (
+    !contract.executionAllowed
+    || !contract.protocolCompatible
+  ) {
+    return {
+      ok: false,
+      errorCode: 'UPGRADE_CONTRACT_FAILED',
+      error: 'Running serve version matches target but failed runtime contract admission',
+      serveVersion,
+      targetVersion: target,
+      contract,
+    };
+  }
+  return {
+    ok: true,
+    serveVersion,
+    targetVersion: target,
+    contract,
+  };
+}

package/server/lib/opencode/owned-runtime-upgrade.test.js

@@ -0,0 +1,160 @@
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import {
+  buildUpgradeStatusSnapshot,
+  classifyRuntimeOwnership,
+  createUpgradeOperationState,
+  evaluateOwnedUpgradeResult,
+  isOwnedOpenCodeCachePath,
+} from './owned-runtime-upgrade.js';
+import { evaluateRuntimeContract } from './runtime-contract.js';
+
+describe('owned runtime upgrade (ticket 12)', () => {
+  const dataDir = path.join('/tmp', 'openchamber-owned-upgrade-test');
+  const ownedBinary = path.join(dataDir, 'opencode-cli', '2.0.12', 'opencode');
+
+  it('models binary vs process ownership separately', () => {
+    expect(isOwnedOpenCodeCachePath(ownedBinary, dataDir)).toBe(true);
+    expect(isOwnedOpenCodeCachePath('/usr/local/bin/opencode', dataDir)).toBe(false);
+
+    const externalUsingOwnedFile = classifyRuntimeOwnership({
+      isExternal: true,
+      binaryPath: ownedBinary,
+      binarySource: 'installed',
+      dataDir,
+    });
+    expect(externalUsingOwnedFile.ownership).toBe('external-serve');
+    expect(externalUsingOwnedFile.canUpgradeInApp).toBe(false);
+    expect(externalUsingOwnedFile.binaryOwnership).toBe('owned-cache');
+
+    const managedGlobal = classifyRuntimeOwnership({
+      isExternal: false,
+      binarySource: 'path',
+      binaryPath: '/usr/local/bin/opencode',
+      dataDir,
+    });
+    expect(managedGlobal.ownership).toBe('global-cli');
+    expect(managedGlobal.canUpgradeInApp).toBe(false);
+    expect(managedGlobal.guidance).toMatch(/global/i);
+
+    const owned = classifyRuntimeOwnership({
+      isExternal: false,
+      binarySource: 'installed',
+      binaryPath: ownedBinary,
+      dataDir,
+    });
+    expect(owned.ownership).toBe('owned-cache');
+    expect(owned.canUpgradeInApp).toBe(true);
+
+    const bundled = classifyRuntimeOwnership({
+      isExternal: false,
+      binarySource: 'bundled',
+      binaryPath: '/app/resources/opencode-cli/opencode',
+    });
+    expect(bundled.canUpgradeInApp).toBe(false);
+    expect(bundled.management).toBe('bundled');
+  });
+
+  it('upgrade-status exposes manage rights and manual guidance', () => {
+    const globalStatus = buildUpgradeStatusSnapshot({
+      ownership: classifyRuntimeOwnership({ isExternal: false, binarySource: 'path' }),
+      serveVersion: '2.0.12',
+      cliVersion: '2.0.12',
+      targetVersion: '2.0.14',
+    });
+    expect(globalStatus.canManage).toBe(false);
+    expect(globalStatus.available).toBeNull();
+    expect(globalStatus.management).toBe('manual-global');
+    expect(globalStatus.guidance).toBeTruthy();
+    expect(globalStatus.currentVersion).toBe('2.0.12');
+    expect(globalStatus.targetVersion).toBe('2.0.14');
+
+    const ownedStatus = buildUpgradeStatusSnapshot({
+      ownership: classifyRuntimeOwnership({
+        isExternal: false,
+        binarySource: 'installed',
+        binaryPath: ownedBinary,
+        dataDir,
+      }),
+      serveVersion: '2.0.12',
+      targetVersion: '2.0.14',
+    });
+    expect(ownedStatus.canManage).toBe(true);
+    expect(ownedStatus.available).toBe(true);
+    expect(ownedStatus.management).toBe('in-app');
+  });
+
+  it('verifies running serve identity before upgrade success', () => {
+    const contractOk = evaluateRuntimeContract({
+      serveVersion: '2.0.14',
+      reachable: true,
+      authenticated: true,
+      healthOk: true,
+      migrationAdmitTranscript: true,
+    });
+    expect(evaluateOwnedUpgradeResult({
+      targetVersion: '2.0.14',
+      serveVersion: '2.0.14',
+      binaryPath: ownedBinary,
+      expectedBinaryPath: ownedBinary,
+      contract: contractOk,
+    }).ok).toBe(true);
+
+    expect(evaluateOwnedUpgradeResult({
+      targetVersion: '2.0.14',
+      serveVersion: '2.0.12',
+      contract: evaluateRuntimeContract({
+        serveVersion: '2.0.12',
+        reachable: true,
+        authenticated: true,
+        healthOk: true,
+        migrationAdmitTranscript: true,
+      }),
+    })).toMatchObject({
+      ok: false,
+      errorCode: 'UPGRADE_SERVE_VERSION_MISMATCH',
+    });
+
+    expect(evaluateOwnedUpgradeResult({
+      targetVersion: '2.0.14',
+      serveVersion: '2.0.14',
+      binaryPath: '/usr/bin/opencode',
+      expectedBinaryPath: ownedBinary,
+      contract: contractOk,
+    }).errorCode).toBe('UPGRADE_BINARY_IDENTITY_MISMATCH');
+
+    // Target match alone is not enough — below-minimum versions must not succeed.
+    expect(evaluateOwnedUpgradeResult({
+      targetVersion: '2.0.5',
+      serveVersion: '2.0.5',
+      contract: evaluateRuntimeContract({
+        serveVersion: '2.0.5',
+        reachable: true,
+        authenticated: true,
+        healthOk: true,
+        migrationAdmitTranscript: true,
+      }),
+    })).toMatchObject({
+      ok: false,
+      errorCode: 'UPGRADE_CONTRACT_FAILED',
+    });
+  });
+
+  it('keeps concurrent upgrade state stable and reconciles failures', () => {
+    const op = createUpgradeOperationState();
+    expect(op.begin('2.0.14').ok).toBe(true);
+    const second = op.begin('2.0.14');
+    expect(second.ok).toBe(false);
+    expect(second.status).toBe(409);
+    expect(second.body.errorCode).toBe('UPGRADE_IN_PROGRESS');
+
+    op.setPhase('download');
+    op.fail({ error: 'download failed', errorCode: 'UPGRADE_DOWNLOAD_FAILED', phase: 'download' });
+    expect(op.getState()).toMatchObject({
+      status: 'failed',
+      errorCode: 'UPGRADE_DOWNLOAD_FAILED',
+      phase: 'download',
+      targetVersion: '2.0.14',
+    });
+  });
+});

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

@@ -12,8 +12,6 @@ const BAD_REQUEST_CODES = new Set(['INVALID_FILENAME', 'INVALID_SCOPE', 'INVALID
 export const registerPluginRoutes = (app, dependencies) => {
   const {
     resolveOptionalProjectDirectory,
-    refreshOpenCodeAfterConfigChange,
-    clientReloadDelayMs,
     listPluginEntries,
     getPluginEntry,
     createPluginEntry,
@@ -45,9 +43,9 @@ export const registerPluginRoutes = (app, dependencies) => {
 
   const successPayload = (message) => ({
     success: true,
-    requiresReload: true,
+    requiresReload: false,
+    application: 'watch',
     message,
-    reloadDelayMs: clientReloadDelayMs,
     reloadFailed: false,
     warning: undefined,
   });
@@ -57,20 +55,7 @@ export const registerPluginRoutes = (app, dependencies) => {
 
     const pastTense = operation.replace(/ion$/, 'ed').replace(/update$/, 'updated');
 
-    try {
-      await refreshOpenCodeAfterConfigChange(`plugin ${operation}`);
-      return res.json(successPayload(`Plugin ${pastTense}. Reloading interface…`));
-    } catch (error) {
-      console.error(`[API:plugin ${operation}] Reload failed after config write:`, error);
-      return res.json({
-        success: true,
-        requiresReload: false,
-        message: `Plugin ${pastTense}, but OpenCode reload failed.`,
-        reloadDelayMs: clientReloadDelayMs,
-        reloadFailed: true,
-        warning: error.message || 'OpenCode reload failed after plugin config changed',
-      });
-    }
+    return res.json(successPayload(`Plugin ${pastTense}.`));
   };
 
   const validateEntryId = (id) => {

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

@@ -263,11 +263,11 @@ describe('opencode plugin routes', () => {
     expect(response.body.results[0]).toMatchObject({ kind: 'npm-ok', spec: '@scope/foo@1.0.0', name: '@scope/foo' });
   });
 
-  test('POST /entry creates entry and requires reload', async () => {
+  test('POST /entry persists for V2 hot reload without restarting', async () => {
     const response = await createEntry('a');
 
-    expect(response.body).toMatchObject({ success: true, requiresReload: true, reloadDelayMs: 25 });
-    expect(refreshOpenCodeAfterConfigChange).toHaveBeenCalledWith('plugin entry creation');
+    expect(response.body).toMatchObject({ success: true, requiresReload: false, application: 'watch' });
+    expect(refreshOpenCodeAfterConfigChange).not.toHaveBeenCalled();
   });
 
   test('GET after POST returns created entry', async () => {
@@ -302,7 +302,7 @@ describe('opencode plugin routes', () => {
     expect(response.body.success).toBe(true);
     const after = await request(app).get('/api/config/plugins').expect(200);
     expect(after.body.entries[0]).toEqual(expect.objectContaining({ spec: 'b', scope: 'user' }));
-    expect(refreshOpenCodeAfterConfigChange).toHaveBeenCalledWith('plugin entry update');
+    expect(refreshOpenCodeAfterConfigChange).not.toHaveBeenCalled();
   });
 
   test('DELETE /entry/:id removes entry and prunes plugin key', async () => {
@@ -315,15 +315,15 @@ describe('opencode plugin routes', () => {
     const after = await request(app).get('/api/config/plugins').expect(200);
     expect(after.body.entries).toEqual([]);
     expect(readJson(userConfigPath).plugin).toBeUndefined();
-    expect(refreshOpenCodeAfterConfigChange).toHaveBeenCalledWith('plugin entry deletion');
+    expect(refreshOpenCodeAfterConfigChange).not.toHaveBeenCalled();
   });
 
   test('POST /file writes plugin dir file', async () => {
     const response = await createFile('test.js', '//x');
 
-    expect(response.body).toMatchObject({ success: true, requiresReload: true });
+    expect(response.body).toMatchObject({ success: true, requiresReload: false, application: 'watch' });
     expect(fs.readFileSync(path.join(rootDir, 'plugins', 'test.js'), 'utf8')).toBe('//x');
-    expect(refreshOpenCodeAfterConfigChange).toHaveBeenCalledWith('plugin file creation');
+    expect(refreshOpenCodeAfterConfigChange).not.toHaveBeenCalled();
   });
 
   test('POST duplicate file returns 409', async () => {
@@ -348,7 +348,7 @@ describe('opencode plugin routes', () => {
       .expect(200);
 
     expect(fs.readFileSync(path.join(rootDir, 'plugins', 'test.js'), 'utf8')).toBe('//y');
-    expect(refreshOpenCodeAfterConfigChange).toHaveBeenCalledWith('plugin file update');
+    expect(refreshOpenCodeAfterConfigChange).not.toHaveBeenCalled();
   });
 
   test('DELETE /file/:id unlinks file', async () => {
@@ -359,7 +359,7 @@ describe('opencode plugin routes', () => {
     await request(app).delete(`/api/config/plugins/file/${encodeURIComponent(id)}`).expect(200);
 
     expect(fs.existsSync(path.join(rootDir, 'plugins', 'test.js'))).toBe(false);
-    expect(refreshOpenCodeAfterConfigChange).toHaveBeenCalledWith('plugin file deletion');
+    expect(refreshOpenCodeAfterConfigChange).not.toHaveBeenCalled();
   });
 
   test('PATCH unknown entry id returns 404', async () => {