@vantran-se/openchamber-web 1.23.1 → 1.24.3

package/server/lib/opencode/lifecycle-process.test.js

@@ -0,0 +1,84 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { createOpenCodeLifecycleRuntime } from './lifecycle.js';
+
+const alive = (pid) => {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+};
+
+const createRuntime = (waitForReady, state) => createOpenCodeLifecycleRuntime({
+  state,
+  env: { ENV_CONFIGURED_OPENCODE_PORT: 45678, ENV_CONFIGURED_OPENCODE_HOSTNAME: '127.0.0.1' },
+  syncToHmrState() {}, syncFromHmrState() {},
+  ensureOpencodeCliEnv: () => process.execPath,
+  applyOpencodeBinaryFromSettings: async () => {},
+  ensureLocalOpenCodeServerPassword: async () => 'fixture-only',
+  resolveManagedOpenCodeLaunchSpec: (binary) => ({ binary, args: [] }),
+  normalizeApiPrefix: (value) => value,
+  setOpenCodePort() {}, setDetectedOpenCodeApiPrefix() {},
+  waitForReady,
+  managedStartupTimeoutMs: 1500,
+});
+
+describe('managed process lifecycle with real children', () => {
+  for (const failure of ['invalid-readiness', 'health-error', 'startup-timeout', 'shutdown-during-startup', 'none']) {
+    it(`reaps the server and its child after ${failure}`, async () => {
+      const root = await fs.mkdtemp(path.join(os.tmpdir(), 'oc-process-'));
+      const previousRegistry = process.env.OPENCHAMBER_MANAGED_PROCESS_REGISTRY;
+      process.env.OPENCHAMBER_MANAGED_PROCESS_REGISTRY = path.join(root, 'registry');
+      const marker = path.join(root, 'pids');
+      const childScript = `process.on('SIGTERM', () => {}); require('node:fs').appendFileSync(${JSON.stringify(marker)}, process.pid + '\\n'); process.stdout.write('ready\\n'); setInterval(() => {}, 1000);`;
+      let readinessMessage = 'opencode server listening on http://127.0.0.1:45678\n';
+      if (failure === 'invalid-readiness') readinessMessage = 'opencode server listening without a URL\n';
+      if (failure === 'startup-timeout' || failure === 'shutdown-during-startup') readinessMessage = '';
+      // Node is an isolated stand-in for the native OpenCode binary. Lifecycle
+      // still launches its real `serve --hostname ... --port ...` command.
+      await fs.writeFile(path.join(root, 'serve'), `
+        const fs = require('node:fs');
+        fs.appendFileSync(${JSON.stringify(marker)}, process.pid + '\\n');
+        const child = require('node:child_process').spawn(process.execPath, ['-e', ${JSON.stringify(childScript)}], { stdio: ['ignore', 'pipe', 'ignore'] });
+        child.stdout.once('data', () => {
+          process.stdout.write(${JSON.stringify(readinessMessage)});
+        });
+        setInterval(() => {}, 1000);
+      `);
+      try {
+        const state = { openCodeWorkingDirectory: root, useWslForOpencode: false };
+        const runtime = createRuntime(async () => {
+          if (failure === 'health-error') throw new Error('fixture health failure');
+          return true;
+        }, state);
+        if (failure === 'none') {
+          const server = await runtime.startOpenCode();
+          await Promise.all([server.close(), server.close()]);
+        } else if (failure === 'shutdown-during-startup') {
+          const starting = runtime.startOpenCode();
+          const rejected = expect(starting).rejects.toThrow('exited before serving');
+          await expect.poll(async () => (await fs.readFile(marker, 'utf8').catch(() => '')).trim().split('\n').filter(Boolean).length).toBe(2);
+          state.isShuttingDown = true;
+          await state.openCodeProcess.close();
+          await rejected;
+        } else if (failure === 'startup-timeout') {
+          await expect(runtime.startOpenCode()).rejects.toThrow('Timeout waiting for OpenCode');
+        } else {
+          await expect(runtime.startOpenCode()).rejects.toThrow(failure === 'health-error' ? 'fixture health failure' : 'Failed to parse server url');
+        }
+        const pids = (await fs.readFile(marker, 'utf8')).trim().split('\n').map(Number);
+        expect(pids).toHaveLength(failure === 'none' || failure === 'shutdown-during-startup' ? 2 : 4);
+        await expect.poll(() => pids.filter(alive), { timeout: 3000 }).toEqual([]);
+        expect(await fs.readdir(path.join(root, 'registry')).catch(() => [])).toEqual([]);
+      } finally {
+        const pids = (await fs.readFile(marker, 'utf8').catch(() => '')).trim().split('\n').map(Number).filter((pid) => pid > 0);
+        for (const pid of pids.reverse()) {
+          if (!alive(pid)) continue;
+          try { process.kill(pid, 'SIGKILL'); } catch { /* already exited */ }
+        }
+        if (previousRegistry === undefined) delete process.env.OPENCHAMBER_MANAGED_PROCESS_REGISTRY;
+        else process.env.OPENCHAMBER_MANAGED_PROCESS_REGISTRY = previousRegistry;
+        await fs.rm(root, { recursive: true, force: true });
+      }
+    }, 15_000);
+  }
+});

package/server/lib/opencode/lifecycle.js

@@ -109,6 +109,7 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
     reapManagedOrphanedProcesses = reapOrphanedProcesses,
     getWarmupDirectories = async () => [],
     onOpenCodeRestarted = null,
+    managedStartupTimeoutMs = 30_000,
     now = Date.now,
   } = deps;
 
@@ -287,7 +288,7 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
     }
 
     const pid = child.pid;
-    if (!pid || hasChildProcessExited(child)) {
+    if (!pid || (process.platform === 'win32' && hasChildProcessExited(child))) {
       await waitForChildProcessClose(child, 250);
       return;
     }
@@ -301,34 +302,14 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
       }
 
       try {
-        child.kill(signal);
+        if (!hasChildProcessExited(child)) child.kill(signal);
       } catch {
       }
     };
 
     if (process.platform === 'win32') {
-      try {
-        child.kill();
-      } catch {
-      }
-
-      if (await waitForChildProcessClose(child, 800)) {
-        return;
-      }
-
-      try {
-        spawnSync('taskkill', ['/pid', String(pid), '/t'], {
-          stdio: 'ignore',
-          timeout: 3000,
-          windowsHide: true,
-        });
-      } catch {
-      }
-
-      if (await waitForChildProcessClose(child, 1500)) {
-        return;
-      }
-
+      // Windows child.kill() terminates only the parent. Kill the owned tree
+      // while its parent still exists, otherwise /T cannot find its children.
       try {
         spawnSync('taskkill', ['/pid', String(pid), '/f', '/t'], {
           stdio: 'ignore',
@@ -343,11 +324,9 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
     }
 
     signalProcessTree('SIGTERM');
-
-    if (await waitForChildProcessClose(child, 2500)) {
-      return;
-    }
-
+    await waitForChildProcessClose(child, 2500);
+    // Parent exit does not prove group exit. Tools can ignore SIGTERM and keep
+    // running after their server has exited and closed its own stdio.
     signalProcessTree('SIGKILL');
 
     await waitForChildProcessClose(child, 1000);
@@ -452,7 +431,29 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
     child.on('exit', recordManagedProcessExit);
     child.on('close', recordManagedProcessExit);
 
-    const url = await new Promise((resolve, reject) => {
+    // Ownership starts at spawn, including processes that never become ready.
+    const registration = registerManagedProcess({
+      pid: child.pid,
+      ownerPid: process.pid,
+      port,
+      binary,
+      runtime: process.env.OPENCHAMBER_RUNTIME || 'web',
+    });
+
+    let closePromise = null;
+    const serverProcess = {
+      url: null,
+      pid: child.pid || null,
+      get exitCode() { return observedExitCode ?? child.exitCode; },
+      get signalCode() { return observedSignalCode ?? child.signalCode; },
+      get stderrTail() { return getManagedProcessSnapshot().stderrTail; },
+      close() {
+        if (!closePromise) closePromise = registration.then(() => closeManagedOpenCodeChild(child));
+        return closePromise;
+      },
+    };
+
+    const readiness = new Promise((resolve, reject) => {
       let stdout = '';
       let stderr = '';
       let done = false;
@@ -507,37 +508,21 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
       child.stderr?.on('data', onStderr);
       child.on('exit', onExit);
       child.on('error', onError);
+    }).catch(async (error) => {
+      await serverProcess.close();
+      if (state.openCodeProcess === serverProcess) {
+        state.openCodeProcess = null;
+        syncToHmrState();
+      }
+      throw error;
     });
 
-    // Record this child so a future run can reap it if we crash before teardown.
-    // The web-server lifecycle runs in-process inside multiple hosts, so tag the
-    // actual host (Electron sets OPENCHAMBER_RUNTIME='desktop'; the standalone
-    // web CLI leaves it unset → 'web'; SSH remote → 'ssh-remote') rather than a
-    // hardcoded label, matching the server's existing runtimeName convention.
-    await registerManagedProcess({
-      pid: child.pid,
-      ownerPid: process.pid,
-      port,
-      binary,
-      runtime: process.env.OPENCHAMBER_RUNTIME || 'web',
-    });
-
-    return {
-      url,
-      pid: child.pid || null,
-      get exitCode() {
-        return observedExitCode ?? child.exitCode;
-      },
-      get signalCode() {
-        return observedSignalCode ?? child.signalCode;
-      },
-      get stderrTail() {
-        return getManagedProcessSnapshot().stderrTail;
-      },
-      async close() {
-        await closeManagedOpenCodeChild(child);
-      },
-    };
+    // Shutdown must be able to close an in-flight startup, not only a ready server.
+    state.openCodeProcess = serverProcess;
+    syncToHmrState();
+    serverProcess.url = await readiness;
+    await registration;
+    return serverProcess;
   };
 
   const resolveManagedOpenCodePort = async (requestedPort, hostname = '127.0.0.1') => {
@@ -719,12 +704,14 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
     });
     phaseStartedAt = performance.now();
 
+    let serverInstance;
     try {
-      const serverInstance = await createManagedOpenCodeServerProcess({
+      if (state.isShuttingDown) throw new Error('OpenCode startup cancelled during shutdown');
+      serverInstance = await createManagedOpenCodeServerProcess({
         resolvedBinary,
         hostname: env.ENV_CONFIGURED_OPENCODE_HOSTNAME,
         port: spawnPort,
-        timeout: 30000,
+        timeout: managedStartupTimeoutMs,
         cwd: state.openCodeWorkingDirectory,
         shellEnvKeysCount: Object.keys(shellEnv).length,
         env: stripAppImageArgv0Leak(applyProviderEnvAliases({
@@ -750,7 +737,9 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
       const port = parseInt(url.port, 10);
       const prefix = normalizeApiPrefix(url.pathname);
 
-      if (await waitForReady(serverInstance.url, 10000)) {
+      const ready = await waitForReady(serverInstance.url, 10000);
+      if (state.isShuttingDown) throw new Error('OpenCode startup cancelled during shutdown');
+      if (ready) {
         setOpenCodePort(port);
         setDetectedOpenCodeApiPrefix(prefix);
 
@@ -768,12 +757,10 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
         return serverInstance;
       }
 
-      try {
-        await serverInstance.close();
-      } catch {
-      }
       throw new Error('Server started but health check failed (timeout)');
     } catch (error) {
+      await serverInstance?.close();
+      if (serverInstance && state.openCodeProcess === serverInstance) state.openCodeProcess = null;
       const message = error instanceof Error ? error.message : String(error);
       state.lastOpenCodeError = message;
       state.openCodePort = null;
@@ -795,7 +782,7 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
         return await startOpenCodeOnce(attempt);
       } catch (error) {
         lastError = error;
-        if (error?.code === 'OPENCODE_BINARY_INVALID') {
+        if (state.isShuttingDown || error?.code === 'OPENCODE_BINARY_INVALID') {
           break;
         }
         if (attempt >= START_OPEN_CODE_MAX_ATTEMPTS) {

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/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({