@vantran-se/openchamber-web 1.23.0 → 1.24.3

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

@@ -16,6 +16,43 @@ function quotePosixShell(value) {
   return `'${String(value).replace(/'/g, "'\\''")}'`;
 }
 
+/**
+ * `echo` in batch treats `& | < > ( ) ^` as syntax and `%var%` as expansion,
+ * so a line of the log preamble is escaped before it becomes an `echo`.
+ */
+const escapeBatchEchoLine = (line) => {
+  if (!line) return 'echo.';
+  return `echo ${line.replace(/%/g, '%%').replace(/[&|<>()^]/g, '^$&')}`;
+};
+
+/**
+ * The Windows update runs as a batch file, one command per line, so the
+ * `if ... else` block and the multi-line log preamble keep their structure.
+ */
+const buildWindowsUpdateScript = ({ logPreamble, updateCmd, restartCmd }) => [
+  '@echo off',
+  ...logPreamble.split('\n').map(escapeBatchEchoLine),
+  // `timeout` refuses redirected stdin, which is what a detached child has;
+  // a ping to loopback waits about two seconds without a console.
+  'ping -n 3 127.0.0.1 >nul',
+  // npm, pnpm and yarn are .cmd shims on Windows. Without `call`, a batch
+  // file hands control to them for good and the restart below never runs.
+  // Read from a file, cmd expands `%x%` and drops a lone `%`, so a `%` in a
+  // host or UI password would change the restart command. Doubling keeps it.
+  `call ${updateCmd.replace(/%/g, '%%')}`,
+  'if %ERRORLEVEL% EQU 0 (',
+  '  echo Update successful, restarting OpenChamber...',
+  `  ${restartCmd ? restartCmd.replace(/%/g, '%%') : 'echo Service manager will restart OpenChamber.'}`,
+  ') else (',
+  '  echo Update failed',
+  ')',
+  // The restart command carries the server's own flags, `--ui-password`
+  // included, so the file does not outlive the run. Deleting the running
+  // batch file on its last line is safe: cmd has already read it.
+  'del "%~f0"',
+  '',
+].join('\r\n');
+
 export const registerOpenChamberRoutes = (app, dependencies) => {
   const {
     fs,
@@ -300,6 +337,26 @@ export const registerOpenChamberRoutes = (app, dependencies) => {
         `logPath=${updateLogPath}`,
       ].join('\n');
 
+      const shell = isWindows ? (process.env.ComSpec || 'cmd.exe') : 'sh';
+      const shellFlag = isWindows ? '/c' : '-c';
+      // cmd.exe /c takes one command line: a newline inside it ends the
+      // command, so a multi-line script passed as the argument ran nothing
+      // and exited 0, and the server shut itself down believing the update
+      // was under way (#3084). Batch runs from a file instead, written before
+      // the client is told to expect a restart.
+      const windowsScriptPath = path.join(openchamberDataDir, 'update-install.cmd');
+      if (isWindows) {
+        try {
+          fs.mkdirSync(path.dirname(windowsScriptPath), { recursive: true });
+          fs.writeFileSync(windowsScriptPath, buildWindowsUpdateScript({ logPreamble, updateCmd, restartCmd }), 'utf8');
+        } catch (scriptError) {
+          console.error('Failed to write the update script, update not started:', scriptError);
+          return res.status(500).json({
+            error: `Could not write the update script at ${windowsScriptPath}: ${scriptError instanceof Error ? scriptError.message : String(scriptError)}`,
+          });
+        }
+      }
+
       res.json({
         success: true,
         message: 'Update starting, server will restart shortly',
@@ -314,21 +371,8 @@ export const registerOpenChamberRoutes = (app, dependencies) => {
           console.log(`Running: ${updateCmd}`);
           console.log(logPreamble);
 
-          const shell = isWindows ? (process.env.ComSpec || 'cmd.exe') : 'sh';
-          const shellFlag = isWindows ? '/c' : '-c';
           const script = isWindows
-            ? `
-            echo ${quoteCmd(logPreamble)}
-            timeout /t 2 /nobreak >nul
-            ${updateCmd}
-            if %ERRORLEVEL% EQU 0 (
-              echo Update successful, restarting OpenChamber...
-              ${restartCmd || 'echo Service manager will restart OpenChamber.'}
-            ) else (
-              echo Update failed
-              exit /b 1
-            )
-            `
+            ? windowsScriptPath
           : `
             printf '%s\n' ${quotePosix(logPreamble)}
             sleep 2
@@ -350,10 +394,24 @@ export const registerOpenChamberRoutes = (app, dependencies) => {
           console.warn('Failed to open update log file, continuing without log capture:', logError);
         }
 
+        if (isWindows) {
+          // On Windows the detached child inherits this process's listening
+          // socket, and keeps the port for as long as the batch runs. The
+          // restart inside that batch then fails with "port already in use",
+          // and the update ends with no server. Closing the listener first
+          // leaves nothing to inherit; the process exits right after anyway.
+          try {
+            server.close();
+          } catch (closeError) {
+            console.warn('Failed to close the listener before the update script:', closeError);
+          }
+        }
+
         const child = spawnChild(shell, [shellFlag, script], {
           detached: true,
           stdio: logFd !== null ? ['ignore', logFd, logFd] : 'ignore',
           env: process.env,
+          windowsHide: true,
         });
         child.unref();
 

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

@@ -18,11 +18,15 @@ const childProcess = await import('child_process');
 const packageManager = await import('../package-manager.js');
 const { registerOpenChamberRoutes } = await import('./openchamber-routes.js');
 
-const createApp = ({ environment = {}, storedOptions = {}, desktopUpdater } = {}) => {
+const createApp = ({ environment = {}, storedOptions = {}, desktopUpdater, platform = 'linux', execPath = '/usr/bin/node' } = {}) => {
   const app = express();
   const dependencies = {
     fs: {
       existsSync: vi.fn(() => false),
+      mkdirSync: vi.fn(),
+      writeFileSync: vi.fn(),
+      openSync: vi.fn(() => 7),
+      closeSync: vi.fn(),
       promises: {
         readFile: vi.fn(async () => JSON.stringify({
           launchMode: 'foreground',
@@ -34,11 +38,13 @@ const createApp = ({ environment = {}, storedOptions = {}, desktopUpdater } = {}
     path,
     process: {
       env: environment,
-      platform: 'linux',
-      execPath: '/usr/bin/node',
+      platform,
+      execPath,
+      exit: vi.fn(),
     },
     server: {
       address: () => ({ port: 7897 }),
+      close: vi.fn(),
     },
     __dirname: '/opt/openchamber/server',
     openchamberDataDir: '/tmp/openchamber',
@@ -268,3 +274,65 @@ describe('OpenChamber foreground update route', () => {
     });
   });
 });
+
+describe('OpenChamber web update route on Windows', () => {
+  it('runs the install-and-restart script from a batch file instead of a cmd.exe /c argument', async () => {
+    const { app, dependencies } = createApp({
+      platform: 'win32',
+      execPath: 'C:\\Program Files\\nodejs\\node.exe',
+      environment: { ComSpec: 'C:\\Windows\\system32\\cmd.exe' },
+      storedOptions: { launchMode: 'daemon', port: 7897, uiPassword: 'pa%ss' },
+    });
+    childProcess.spawn.mockReturnValue({ unref: vi.fn() });
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await request(app).post('/api/openchamber/update-install').expect(200);
+    await new Promise((resolve) => setTimeout(resolve, 1300));
+
+    const scriptPath = path.join('/tmp/openchamber', 'update-install.cmd');
+    expect(dependencies.fs.writeFileSync).toHaveBeenCalledWith(scriptPath, expect.any(String), 'utf8');
+    const script = dependencies.fs.writeFileSync.mock.calls[0][1];
+    const lines = script.split('\r\n');
+    expect(lines[0]).toBe('@echo off');
+    // Every preamble line is an echo; none is left to run as a command.
+    expect(lines.filter((line) => line.startsWith('currentVersion=') || line.startsWith('restartCommand='))).toEqual([]);
+    expect(lines).toContain('echo packageManager=npm');
+    expect(lines).toContain('echo restartCommand=^("C:\\Program Files\\nodejs\\node.exe" "/opt/openchamber/bin/cli.js" serve --port 7897 --ui-password "pa%%ss"^) ^|^| ^(openchamber serve --port 7897 --ui-password "pa%%ss"^)');
+    // A .cmd shim (npm, pnpm, yarn) must be `call`ed or the script ends there.
+    expect(lines).toContain('call npm install -g @openchamber/web@latest');
+    expect(lines).toContain('ping -n 3 127.0.0.1 >nul');
+    expect(lines.some((line) => line.startsWith('timeout '))).toBe(false);
+    expect(lines).toContain('if %ERRORLEVEL% EQU 0 (');
+    expect(lines.at(-2)).toBe('del "%~f0"');
+    // A `%` in the password survives batch expansion only when doubled.
+    expect(lines).toContain('  ("C:\\Program Files\\nodejs\\node.exe" "/opt/openchamber/bin/cli.js" serve --port 7897 --ui-password "pa%%ss") || (openchamber serve --port 7897 --ui-password "pa%%ss")');
+
+    expect(childProcess.spawn).toHaveBeenCalledWith(
+      'C:\\Windows\\system32\\cmd.exe',
+      ['/c', scriptPath],
+      expect.objectContaining({ detached: true, windowsHide: true }),
+    );
+    // The listener is closed before the batch is spawned, so the detached
+    // child cannot inherit the socket and hold the port against the restart.
+    expect(dependencies.server.close).toHaveBeenCalledOnce();
+    expect(dependencies.server.close.mock.invocationCallOrder[0]).toBeLessThan(childProcess.spawn.mock.invocationCallOrder[0]);
+    expect(dependencies.process.exit).toHaveBeenCalledWith(0);
+  });
+
+  it('answers 500 and keeps the server up when the batch file cannot be written', async () => {
+    const { app, dependencies } = createApp({ platform: 'win32', storedOptions: { launchMode: 'daemon', port: 7897 } });
+    dependencies.fs.writeFileSync.mockImplementation(() => { throw new Error('EACCES'); });
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    const logError = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    const response = await request(app).post('/api/openchamber/update-install').expect(500);
+    await new Promise((resolve) => setTimeout(resolve, 1300));
+
+    expect(response.body.error).toContain('update-install.cmd');
+    expect(response.body.error).toContain('EACCES');
+    expect(childProcess.spawn).not.toHaveBeenCalled();
+    expect(dependencies.process.exit).not.toHaveBeenCalled();
+    expect(logError).toHaveBeenCalledOnce();
+  });
+});
+

package/server/lib/opencode/proxy.js

@@ -11,6 +11,7 @@ import {
 import { createRealpathCache } from '../path-realpath-cache.js';
 import { DEFAULT_UPSTREAM_STALL_TIMEOUT_MS } from '../event-stream/upstream-reader.js';
 import { recordStartupPerformance } from './startup-performance.js';
+import { getWorktreeBootstrapStatus } from '../git/service.js';
 
 const DEFAULT_SSE_HEARTBEAT_INTERVAL_MS = 20_000;
 
@@ -286,6 +287,8 @@ export const registerOpenCodeProxy = (app, deps) => {
     SSE_HEARTBEAT_INTERVAL_MS = DEFAULT_SSE_HEARTBEAT_INTERVAL_MS,
     SSE_UPSTREAM_STALL_TIMEOUT_MS = DEFAULT_UPSTREAM_STALL_TIMEOUT_MS,
     getSseUpstreamStallTimeoutMs = () => SSE_UPSTREAM_STALL_TIMEOUT_MS,
+    readWorktreeBootstrapStatus = getWorktreeBootstrapStatus,
+    WORKTREE_READY_TIMEOUT_MS = 5 * 60 * 1000,
   } = deps;
 
   if (app.get('opencodeProxyConfigured')) {
@@ -775,6 +778,36 @@ export const registerOpenCodeProxy = (app, deps) => {
     }
   });
 
+  // Any directory-scoped read can initialize OpenCode's cached project/config,
+  // before session.create runs. Hold all upstream requests until Git population
+  // finishes, independently of the user's optional setup-script wait.
+  app.use('/api', async (req, res, next) => {
+    normalizeForwardedDirectoryHeaders(req.headers);
+    const url = new URL(req.url, 'http://localhost');
+    const directory = url.searchParams.get('directory') || req.get('x-opencode-directory');
+    if (!directory) return next();
+
+    const deadline = Date.now() + WORKTREE_READY_TIMEOUT_MS;
+    try {
+      while (!res.destroyed && !res.writableEnded && !req.aborted) {
+        const status = await readWorktreeBootstrapStatus(directory);
+        if (res.destroyed || res.writableEnded || req.aborted) return;
+        if (status.status === 'failed') {
+          return res.status(503).json({ error: status.error || 'Worktree bootstrap failed' });
+        }
+        if (status.status === 'ready' || status.phase === 'git-ready' || status.phase === 'setup-ready') {
+          return next();
+        }
+        if (Date.now() >= deadline) {
+          return res.status(503).json({ error: 'Timed out waiting for worktree checkout' });
+        }
+        await sleep(75);
+      }
+    } catch (error) {
+      next(error);
+    }
+  });
+
   // Windows: session merge for cross-directory session listing
   if (process.platform === 'win32') {
     app.get('/api/session', async (req, res, next) => {

package/server/lib/opencode/session-runtime.js

@@ -38,13 +38,76 @@ const extractSessionStatusUpdate = (payload) => {
   };
 };
 
+const readRequestId = (value) => (typeof value === 'string' && value.trim() ? value.trim() : '');
+
 export const createSessionRuntime = ({ writeSseEvent, getNotificationClients, broadcastEvent }) => {
   const sessionActivityPhases = new Map();
   const sessionActivityCooldowns = new Map();
   const sessionStates = new Map();
   const sessionAttentionStates = new Map();
+  // Pending permission and question requests per session, kept from the same
+  // upstream stream. Clients that do not initialize a directory cannot read
+  // its pending list from OpenCode (that read creates an instance), so this
+  // map is their seed. Entries live until the matching reply, the session's
+  // deletion, or an OpenCode restart, which drops every pending request.
+  const pendingRequestsBySession = new Map();
   let activeSessionCount = 0;
 
+  const getOrCreatePendingRequests = (sessionId) => {
+    let entry = pendingRequestsBySession.get(sessionId);
+    if (!entry) {
+      entry = { permissions: new Map(), questions: new Map() };
+      pendingRequestsBySession.set(sessionId, entry);
+    }
+    return entry;
+  };
+
+  const settlePendingRequest = (kind, sessionId, requestId) => {
+    const entry = pendingRequestsBySession.get(sessionId);
+    if (!entry) return;
+    // OpenCode may omit the request ID on a reply; the session then has no
+    // pending request of that kind we can still vouch for.
+    if (requestId) entry[kind].delete(requestId);
+    else entry[kind].clear();
+    if (entry.permissions.size === 0 && entry.questions.size === 0) pendingRequestsBySession.delete(sessionId);
+  };
+
+  const processBlockingRequestPayload = (payload) => {
+    if (!payload || typeof payload.type !== 'string') return;
+    const properties = payload.properties && typeof payload.properties === 'object' ? payload.properties : {};
+    if (payload.type === 'permission.asked' || payload.type === 'question.asked') {
+      const sessionId = readRequestId(properties.sessionID);
+      const requestId = readRequestId(properties.id);
+      if (!sessionId || !requestId) return;
+      getOrCreatePendingRequests(sessionId)[payload.type === 'permission.asked' ? 'permissions' : 'questions'].set(requestId, properties);
+      return;
+    }
+    if (payload.type === 'permission.replied') {
+      settlePendingRequest('permissions', readRequestId(properties.sessionID), readRequestId(properties.requestID));
+      return;
+    }
+    if (payload.type === 'question.replied' || payload.type === 'question.rejected') {
+      settlePendingRequest('questions', readRequestId(properties.sessionID), readRequestId(properties.requestID));
+      return;
+    }
+    if (payload.type === 'session.deleted') {
+      const info = properties.info && typeof properties.info === 'object' ? properties.info : {};
+      const sessionId = readRequestId(properties.sessionID) || readRequestId(info.id);
+      if (sessionId) pendingRequestsBySession.delete(sessionId);
+    }
+  };
+
+  const getPendingBlockingRequestsSnapshot = () => {
+    const result = {};
+    for (const [sessionId, entry] of pendingRequestsBySession) {
+      result[sessionId] = {
+        permissions: [...entry.permissions.values()],
+        questions: [...entry.questions.values()],
+      };
+    }
+    return result;
+  };
+
   const getOrCreateAttentionState = (sessionId) => {
     if (!sessionId || typeof sessionId !== 'string') return null;
 
@@ -307,6 +370,8 @@ export const createSessionRuntime = ({ writeSseEvent, getNotificationClients, br
       }
     }
 
+    // A restarted OpenCode forgot every pending request with the turns.
+    pendingRequestsBySession.clear();
     const eventId = `opencode-restart-${Date.now()}`;
     for (const sessionId of interruptedSessionIds) {
       updateSessionState(sessionId, 'idle', eventId, {
@@ -354,6 +419,7 @@ export const createSessionRuntime = ({ writeSseEvent, getNotificationClients, br
   const cleanupInterval = setInterval(cleanupOldSessionStates, SESSION_STATE_CLEANUP_INTERVAL_MS);
 
   const processOpenCodeSsePayload = (payload) => {
+    processBlockingRequestPayload(payload);
     const update = extractSessionStatusUpdate(payload);
     if (!update) return;
 
@@ -379,6 +445,7 @@ export const createSessionRuntime = ({ writeSseEvent, getNotificationClients, br
     sessionActivityPhases.clear();
     sessionStates.clear();
     sessionAttentionStates.clear();
+    pendingRequestsBySession.clear();
     activeSessionCount = 0;
   };
 
@@ -387,6 +454,7 @@ export const createSessionRuntime = ({ writeSseEvent, getNotificationClients, br
     getSessionActivitySnapshot,
     getActiveSessionCount,
     getSessionStateSnapshot,
+    getPendingBlockingRequestsSnapshot,
     getSessionAttentionSnapshot,
     getSessionState,
     getSessionAttentionState,

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

@@ -12,6 +12,49 @@ describe('session runtime', () => {
     runtimes.length = 0;
   });
 
+  it('keeps pending permission and question requests until they are answered', () => {
+    const runtime = createSessionRuntime({
+      writeSseEvent() {},
+      getNotificationClients: () => new Set(),
+      broadcastEvent: () => {},
+    });
+    runtimes.push(runtime);
+    const permission = { id: 'perm-1', sessionID: 'session-1', permission: 'bash', patterns: ['rm *'], metadata: {}, always: [] };
+    const question = { id: 'q-1', sessionID: 'session-2', questions: [{ header: 'Pick', question: 'Which?', options: [] }] };
+
+    runtime.processOpenCodeSsePayload({ type: 'permission.asked', properties: permission });
+    runtime.processOpenCodeSsePayload({ type: 'permission.asked', properties: permission });
+    runtime.processOpenCodeSsePayload({ type: 'question.asked', properties: question });
+    expect(runtime.getPendingBlockingRequestsSnapshot()).toEqual({
+      'session-1': { permissions: [permission], questions: [] },
+      'session-2': { permissions: [], questions: [question] },
+    });
+
+    runtime.processOpenCodeSsePayload({ type: 'permission.replied', properties: { sessionID: 'session-1', requestID: 'perm-1' } });
+    runtime.processOpenCodeSsePayload({ type: 'question.rejected', properties: { sessionID: 'session-2' } });
+    expect(runtime.getPendingBlockingRequestsSnapshot()).toEqual({});
+  });
+
+  it('drops pending requests when the session is deleted or OpenCode restarts', () => {
+    const runtime = createSessionRuntime({
+      writeSseEvent() {},
+      getNotificationClients: () => new Set(),
+      broadcastEvent: () => {},
+    });
+    runtimes.push(runtime);
+    const ask = (sessionID, id) => runtime.processOpenCodeSsePayload({
+      type: 'permission.asked', properties: { id, sessionID, permission: 'edit', patterns: [], metadata: {}, always: [] },
+    });
+
+    ask('session-1', 'perm-1');
+    ask('session-2', 'perm-2');
+    runtime.processOpenCodeSsePayload({ type: 'session.deleted', properties: { info: { id: 'session-1' } } });
+    expect(Object.keys(runtime.getPendingBlockingRequestsSnapshot())).toEqual(['session-2']);
+
+    runtime.interruptBusySessionsAfterRestart();
+    expect(runtime.getPendingBlockingRequestsSnapshot()).toEqual({});
+  });
+
   it('broadcasts attention clears through the shared broadcaster', () => {
     const events = [];
     const runtime = createSessionRuntime({

package/server/lib/opencode/settings-helpers.js

@@ -1,6 +1,7 @@
 import { createRequire } from 'node:module';
 
 import { isAgentMemoryFeatureAvailable } from '../agent-memory/feature-flag.js';
+import { isRoutingFeatureAvailable } from '../routing/feature-flag.js';
 
 // Generated from packages/ui/src/lib/settings/registry.ts by
 // `bun run settings-registry:generate`; `registry.test.ts` fails when stale.
@@ -233,6 +234,11 @@ export const createSettingsHelpers = (dependencies) => {
     if (typeof candidate.workStatusHiddenSectionsExplicit === 'boolean') {
       result.workStatusHiddenSectionsExplicit = candidate.workStatusHiddenSectionsExplicit;
     }
+    if (Array.isArray(candidate.workStatusSectionOrder)) {
+      result.workStatusSectionOrder = [
+        ...new Set(candidate.workStatusSectionOrder.filter((entry) => typeof entry === 'string' && entry.length > 0)),
+      ];
+    }
     if (typeof candidate.desktopLanAccessEnabled === 'boolean') {
       result.desktopLanAccessEnabled = candidate.desktopLanAccessEnabled;
     }
@@ -473,6 +479,9 @@ export const createSettingsHelpers = (dependencies) => {
     if (candidate.sessionRetentionAction === 'archive' || candidate.sessionRetentionAction === 'delete') {
       result.sessionRetentionAction = candidate.sessionRetentionAction;
     }
+    if (typeof candidate.sessionRetentionOnlyArchived === 'boolean') {
+      result.sessionRetentionOnlyArchived = candidate.sessionRetentionOnlyArchived;
+    }
     if (candidate.tunnelBootstrapTtlMs === null) {
       result.tunnelBootstrapTtlMs = null;
     } else if (typeof candidate.tunnelBootstrapTtlMs === 'number' && Number.isFinite(candidate.tunnelBootstrapTtlMs)) {
@@ -1005,6 +1014,8 @@ export const createSettingsHelpers = (dependencies) => {
       // Tells the client whether agent memory exists in this build at all, so
       // its settings row and panel tab can be absent rather than merely off.
       agentMemoryFeatureAvailable: isAgentMemoryFeatureAvailable(),
+      // Same idea for Jev routing: absent from the picker and Settings unless the build has it.
+      routingFeatureAvailable: isRoutingFeatureAvailable(),
       ...(pwaAppName ? { pwaAppName } : {}),
       pwaOrientation,
       mobileKeyboardMode,

package/server/lib/opencode/settings-helpers.test.js

@@ -69,6 +69,18 @@ const createTestHelpersWithRealSanitizers = () => {
 };
 
 describe('settings helpers', () => {
+  it('round-trips section order and preserves it across unrelated writes', () => {
+    const helpers = createTestHelpers();
+    const changes = helpers.sanitizeSettingsUpdate({ workStatusSectionOrder: ['mcp', 'session', 'mcp', null, ''] });
+    expect(changes.workStatusSectionOrder).toEqual(['mcp', 'session']);
+    const saved = helpers.mergePersistedSettings({}, changes);
+    const reloaded = helpers.formatSettingsResponse(JSON.parse(JSON.stringify(saved)));
+    expect(reloaded.workStatusSectionOrder).toEqual(['mcp', 'session']);
+    const next = helpers.mergePersistedSettings(reloaded, helpers.sanitizeSettingsUpdate({ workStatusPanelEnabled: false }));
+    expect(helpers.formatSettingsResponse(next).workStatusSectionOrder).toEqual(['mcp', 'session']);
+    expect(helpers.sanitizeSettingsUpdate({ workStatusSectionOrder: 'bad' }).workStatusSectionOrder).toBeUndefined();
+    expect(helpers.sanitizeSettingsUpdate({ workStatusSectionOrder: [] }).workStatusSectionOrder).toEqual([]);
+  });
   it('round-trips telemetry opt-in with the hidden list and preserves it across unrelated writes', () => {
     const helpers = createTestHelpers();
     const legacy = helpers.sanitizeSettingsUpdate({ workStatusHiddenSections: [] });
@@ -690,6 +702,14 @@ describe('settings helpers', () => {
   });
 
   describe('session retention settings persistence', () => {
+    it('round-trips archived-only retention and rejects non-boolean values', () => {
+      const helpers = createTestHelpersWithRealSanitizers();
+      for (const sessionRetentionOnlyArchived of [true, false]) {
+        expect(helpers.sanitizeSettingsUpdate({ sessionRetentionOnlyArchived })).toEqual({ sessionRetentionOnlyArchived });
+      }
+      expect(helpers.sanitizeSettingsUpdate({ sessionRetentionOnlyArchived: 'true' })).toEqual({});
+      expect(helpers.sanitizeSettingsUpdate({ sessionRetentionOnlyArchived: null })).toEqual({});
+    });
     it('round-trips sessionRetentionAction archive and delete through the sanitizer', () => {
       const helpers = createTestHelpersWithRealSanitizers();
 
@@ -714,6 +734,7 @@ describe('settings helpers', () => {
         autoDeleteEnabled: true,
         autoDeleteAfterDays: 60,
         sessionRetentionAction: 'delete',
+        sessionRetentionOnlyArchived: true,
       };
 
       const sanitized = helpers.sanitizeSettingsUpdate(payload);
@@ -721,6 +742,7 @@ describe('settings helpers', () => {
       expect(sanitized.autoDeleteEnabled).toBe(true);
       expect(sanitized.autoDeleteAfterDays).toBe(60);
       expect(sanitized.sessionRetentionAction).toBe('delete');
+      expect(sanitized.sessionRetentionOnlyArchived).toBe(true);
     });
   });
 });
@@ -746,13 +768,13 @@ describe('settings registry gate', () => {
     desktopUiPassword: 'secret', githubClientId: 'client', githubScopes: 'repo', skillCatalogs: [{ id: 'c', label: 'C', source: 'https://x' }],
     defaultGitIdentityId: 'global', permissionAutoAccept: { sessions: { s: true }, revision: 1 },
     agentControlToolEnabled: true, agentWebToolEnabled: true, agentMemoryToolEnabled: true, openCodeUpdateToastDismissedVersion: '1.0.0',
-    autoDeleteEnabled: true, autoDeleteAfterDays: 30, sessionRetentionAction: 'archive', terminalShell: 'zsh', terminalLoginShells: ['zsh'],
+    autoDeleteEnabled: true, autoDeleteAfterDays: 30, sessionRetentionOnlyArchived: false, sessionRetentionAction: 'archive', terminalShell: 'zsh', terminalLoginShells: ['zsh'],
     openInAppId: 'vscode', dictationEnabled: true, sttProvider: 'local', sttServerUrl: 'http://localhost:8001/v1', sttModel: 'm', sttLocalModel: 'm', sttLanguage: 'en',
     tunnelProvider: 'cloudflare', tunnelMode: 'quick', tunnelBootstrapTtlMs: 600000, tunnelSessionTtlMs: 86400000, managedLocalTunnelConfigPath: '/tmp/x',
     managedRemoteTunnelHostname: 'x.example', managedRemoteTunnelToken: 'token', managedRemoteTunnelPresets: [{ id: 'a', name: 'A', hostname: 'a.example' }],
     managedRemoteTunnelSelectedPresetId: 'a', managedRemoteTunnelPresetTokens: { a: 'token' },
     sidebarProjectDisplayMode: 'all', sidebarSessionGroupingMode: 'flat', sidebarProjectSortOrder: 'manual', sidebarShowRecentSection: true,
-    workStatusPanelEnabled: true, workStatusHiddenSections: ['mcp'], workStatusHiddenSectionsExplicit: true,
+    workStatusPanelEnabled: true, workStatusHiddenSections: ['mcp'], workStatusHiddenSectionsExplicit: true, workStatusSectionOrder: ['mcp', 'session'],
     showReasoningTraces: true, streamingAutoFollowEnabled: true, collapsibleThinkingBlocks: true, showTextJustificationActivity: true,
     chatRenderMode: 'live', activityRenderMode: 'summary', mermaidRenderingMode: 'svg', userMessageRenderingMode: 'markdown', collapsibleUserMessages: true,
     stickyUserHeader: true, promptNavigatorEnabled: true, wideChatLayoutEnabled: true, showSplitAssistantMessageActions: true, showToolFileIcons: true,

package/server/lib/opencode/settings-normalization-runtime.js

@@ -154,6 +154,7 @@ export const createSettingsNormalizationRuntime = (dependencies) => {
         : null;
       const iconBackground = normalizeIconBackground(candidate.iconBackground);
       const color = typeof candidate.color === 'string' ? candidate.color.trim() : '';
+      const defaultAgent = typeof candidate.defaultAgent === 'string' ? candidate.defaultAgent.trim() : '';
       const defaultModel = typeof candidate.defaultModel === 'string' ? candidate.defaultModel.trim() : '';
       const defaultVariant = typeof candidate.defaultVariant === 'string' ? candidate.defaultVariant.trim() : '';
       const addedAt = Number.isFinite(candidate.addedAt) ? Number(candidate.addedAt) : null;
@@ -175,6 +176,7 @@ export const createSettingsNormalizationRuntime = (dependencies) => {
         ...(icon ? { icon } : {}),
         ...(iconBackground ? { iconBackground } : {}),
         ...(color ? { color } : {}),
+        ...(defaultAgent ? { defaultAgent } : {}),
         ...(defaultModel && defaultModel.includes('/') ? { defaultModel } : {}),
         // A variant is meaningless without the model it belongs to.
         ...(defaultModel && defaultModel.includes('/') && defaultVariant ? { defaultVariant } : {}),

package/server/lib/opencode/settings-normalization-runtime.test.js

@@ -122,6 +122,19 @@ describe('settings normalization runtime - symlink resolution', () => {
       expect(result[1].defaultVariant).toBe(undefined);
     });
 
+    it('keeps a project default agent', () => {
+      const runtime = createTestRuntime({
+        realpathSync: (p) => p,
+        path: { resolve: (p) => p, sep: '/', dirname: (p) => p.split('/').slice(0, -1).join('/') || '/' },
+      });
+
+      const result = runtime.sanitizeProjects([
+        { id: 'proj1', path: '/a', defaultAgent: 'plan' },
+      ]);
+
+      expect(result[0].defaultAgent).toBe('plan');
+    });
+
     it('deduplicates projects that resolve to the same realpath', () => {
       const runtime = createTestRuntime({
         realpathSync: (p) => p.startsWith('/symlink') ? '/real/project' : p,

package/server/lib/opencode/settings-registry.json

@@ -127,6 +127,10 @@
       "scope": "instance",
       "computed": true
     },
+    "routingFeatureAvailable": {
+      "scope": "instance",
+      "computed": true
+    },
     "openCodeUpdateToastDismissedVersion": {
       "scope": "instance"
     },
@@ -136,6 +140,9 @@
     "autoDeleteAfterDays": {
       "scope": "instance"
     },
+    "sessionRetentionOnlyArchived": {
+      "scope": "instance"
+    },
     "sessionRetentionAction": {
       "scope": "instance"
     },
@@ -214,6 +221,9 @@
     "sidebarShowRecentSection": {
       "scope": "profile"
     },
+    "workStatusSectionOrder": {
+      "scope": "profile"
+    },
     "workStatusPanelEnabled": {
       "scope": "profile"
     },
@@ -602,6 +612,10 @@
       "scope": "device",
       "local": true
     },
+    "contextEditorVisible": {
+      "scope": "device",
+      "local": true
+    },
     "contextEditorTreeWidth": {
       "scope": "device",
       "local": true
@@ -614,6 +628,10 @@
       "scope": "device",
       "local": true
     },
+    "messageQueueExpanded": {
+      "scope": "device",
+      "local": true
+    },
     "workStatusScrollTop": {
       "scope": "device",
       "local": true