@cloudcli-ai/cloudcli 1.37.2 → 1.37.4

package/server/modules/websocket/services/shell-websocket.service.ts

@@ -5,7 +5,7 @@ import path from 'node:path';
 import pty, { type IPty } from 'node-pty';
 import { WebSocket, type RawData } from 'ws';
 
-import { parseIncomingJsonObject } from '@/shared/utils.js';
+import { parseIncomingJsonObject, stripAnsiSequences } from '@/shared/utils.js';
 
 type ShellIncomingMessage = {
   type?: string;
@@ -19,8 +19,12 @@ type ShellIncomingMessage = {
   initialCommand?: string;
   isPlainShell?: boolean;
   forceRestart?: boolean;
+  bypassPermissions?: boolean;
+  colorScheme?: string;
 };
 
+type ShellColorScheme = 'light' | 'dark';
+
 type PtySessionEntry = {
   pty: IPty;
   ws: WebSocket | null;
@@ -28,18 +32,17 @@ type PtySessionEntry = {
   timeoutId: NodeJS.Timeout | null;
   projectPath: string;
   sessionId: string | null;
+  // The app theme a Claude CLI in this pty was launched for; null for any other
+  // program. A running CLI keeps its launch-time colours, so a reattaching
+  // client needs this, not its own current theme, to know if they differ.
+  claudeColorScheme: ShellColorScheme | null;
 };
 
 const ptySessionsMap = new Map<string, PtySessionEntry>();
 const PTY_SESSION_TIMEOUT = 30 * 60 * 1000;
 const SHELL_URL_PARSE_BUFFER_LIMIT = 32768;
-const ANSI_ESCAPE_SEQUENCE_REGEX = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1B\\))/g;
 const TRAILING_URL_PUNCTUATION_REGEX = /[)\]}>.,;:!?]+$/;
 
-function stripAnsiSequences(value: string): string {
-  return value.replace(ANSI_ESCAPE_SEQUENCE_REGEX, '');
-}
-
 function normalizeDetectedUrl(url: string): string | null {
   const cleanedUrl = url.trim().replace(TRAILING_URL_PUNCTUATION_REGEX, '');
   if (!cleanedUrl) {
@@ -89,6 +92,17 @@ function extractUrlsFromText(value: string): string[] {
   return Array.from(new Set([...directMatches, ...wrappedMatches]));
 }
 
+/**
+ * Tells the client which app theme the Claude CLI in its pty was launched for,
+ * so the Shell can suggest a restart once the app theme no longer matches it.
+ * Clients that predate this frame ignore unknown frame types.
+ */
+function sendClaudeColorScheme(ws: WebSocket, colorScheme: ShellColorScheme | null): void {
+  if (colorScheme && ws.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify({ type: 'claude_theme', colorScheme }));
+  }
+}
+
 function shouldAutoOpenUrlFromOutput(value: string): boolean {
   const normalizedOutput = value.toLowerCase();
   return (
@@ -129,6 +143,14 @@ function readNumber(value: unknown, fallback: number): number {
   return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
 }
 
+/**
+ * Reads the app theme the Shell tab is painted in. Older clients send none and
+ * anything unexpected is ignored, which keeps the launch exactly as before.
+ */
+function readColorScheme(value: unknown): ShellColorScheme | null {
+  return value === 'light' || value === 'dark' ? value : null;
+}
+
 /**
  * Parses incoming websocket shell messages and keeps processing safe when
  * malformed payloads are received.
@@ -172,13 +194,23 @@ function resolveResumeSessionId(
   return resolvedSessionId;
 }
 
+type ShellLaunch = {
+  command: string;
+  /**
+   * Whether the command starts a Claude CLI that paints in the app's colour
+   * scheme, so a later theme toggle can be applied by restarting it.
+   */
+  claudeFollowsAppTheme: boolean;
+};
+
 /**
  * Resolves provider command line for plain shell and agent-backed shell modes.
  */
 function buildShellCommand(
   message: ShellIncomingMessage,
-  dependencies: ShellWebSocketDependencies
-): string {
+  dependencies: ShellWebSocketDependencies,
+  projectPath: string
+): ShellLaunch {
   const hasSession = readBoolean(message.hasSession);
   const initialCommand = readString(message.initialCommand);
   const provider = readString(message.provider, 'claude');
@@ -188,42 +220,251 @@ function buildShellCommand(
     (!!initialCommand && !hasSession) ||
     provider === 'plain-shell';
 
+  const otherProgram = (command: string): ShellLaunch => ({ command, claudeFollowsAppTheme: false });
+
   if (isPlainShell) {
-    return initialCommand;
+    return otherProgram(initialCommand);
   }
 
   if (provider === 'cursor') {
     if (resumeSessionId) {
-      return `cursor-agent --resume="${resumeSessionId}"`;
+      return otherProgram(`cursor-agent --resume="${resumeSessionId}"`);
     }
-    return 'cursor-agent';
+    return otherProgram('cursor-agent');
   }
 
   if (provider === 'codex') {
     if (resumeSessionId) {
       if (os.platform() === 'win32') {
-        return `codex resume "${resumeSessionId}"; if ($LASTEXITCODE -ne 0) { codex }`;
+        return otherProgram(`codex resume "${resumeSessionId}"; if ($LASTEXITCODE -ne 0) { codex }`);
       }
-      return `codex resume "${resumeSessionId}" || codex`;
+      return otherProgram(`codex resume "${resumeSessionId}" || codex`);
     }
-    return 'codex';
+    return otherProgram('codex');
   }
 
   if (provider === 'opencode') {
     if (resumeSessionId) {
-      return `opencode --session "${resumeSessionId}"`;
+      return otherProgram(`opencode --session "${resumeSessionId}"`);
     }
-    return initialCommand || 'opencode';
+    return otherProgram(initialCommand || 'opencode');
   }
 
-  const command = initialCommand || 'claude';
+  // Launching with the flag is what unlocks "bypass permissions" in the CLI's
+  // shift+tab permission-mode cycle; it cannot be enabled from inside a
+  // session started without it.
+  const bypassFlag = readBoolean(message.bypassPermissions)
+    ? ' --dangerously-skip-permissions'
+    : '';
+  const theme = buildClaudeThemeLaunch(readColorScheme(message.colorScheme), projectPath);
+  const launchFlags = `${bypassFlag}${theme.flag}`;
   if (resumeSessionId) {
-    if (os.platform() === 'win32') {
-      return `claude --resume "${resumeSessionId}"; if ($LASTEXITCODE -ne 0) { claude }`;
+    const command = os.platform() === 'win32'
+      ? `claude --resume "${resumeSessionId}"${launchFlags}; if ($LASTEXITCODE -ne 0) { claude${launchFlags} }`
+      : `claude --resume "${resumeSessionId}"${launchFlags} || claude${launchFlags}`;
+    return { command, claudeFollowsAppTheme: theme.followsAppTheme };
+  }
+  if (initialCommand) {
+    // A caller's own command (e.g. `claude /login`) is launched as given.
+    return otherProgram(initialCommand);
+  }
+  return { command: `claude${launchFlags}`, claudeFollowsAppTheme: theme.followsAppTheme };
+}
+
+// Claude Code's built-in theme ids (the `/theme` picker of CLI 2.1.280). A
+// `custom:<slug>` theme is valid too; any other value is ignored by the CLI.
+const CLAUDE_THEME_IDS = new Set([
+  'auto',
+  'dark',
+  'light',
+  'dark-daltonized',
+  'light-daltonized',
+  'dark-ansi',
+  'light-ansi',
+]);
+
+// Dark themes and their light counterparts. A light theme, `auto` (it asks the
+// terminal for its background, which xterm answers from the live theme) or a
+// custom theme is the user's own choice and is left alone.
+const LIGHT_CLAUDE_THEME_BY_DARK_THEME = new Map([
+  ['dark', 'light'],
+  ['dark-daltonized', 'light-daltonized'],
+  ['dark-ansi', 'light-ansi'],
+]);
+
+// The CLI refuses settings files over 2 MiB, so a bigger one holds no theme it
+// would use. The legacy global config (`~/.claude.json`) is not a settings file
+// and can grow to several MB; its cap is only there so a huge file is never
+// pulled into the server's memory.
+const MAX_CLAUDE_SETTINGS_FILE_BYTES = 2 * 1024 * 1024;
+const MAX_CLAUDE_GLOBAL_CONFIG_FILE_BYTES = 64 * 1024 * 1024;
+
+/**
+ * Reads a config file only when it is a regular, non-empty file of sane size,
+ * else returns null. The project can be a cloned repository whose
+ * `.claude/settings.local.json` is a symlink to a FIFO or to a device such as
+ * /dev/zero: reading one would stall the server's event loop or exhaust its
+ * memory. `statSync` follows the symlink without opening the target. Empty
+ * files are skipped too: they hold no theme, and kernel pseudo-files (procfs,
+ * tracefs) report a size of 0 even when a read would block.
+ */
+function readRegularConfigFile(filePath: string, maxBytes = MAX_CLAUDE_SETTINGS_FILE_BYTES): string | null {
+  try {
+    const stats = fs.statSync(filePath);
+    if (!stats.isFile() || stats.size === 0 || stats.size > maxBytes) {
+      return null;
     }
-    return `claude --resume "${resumeSessionId}" || claude`;
+    return fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return null;
   }
-  return command;
+}
+
+/**
+ * Reads the `theme` key of one Claude config file. A missing, unreadable,
+ * special (FIFO, device) or unparsable file, or a value the CLI would reject,
+ * counts as unset.
+ */
+function readClaudeThemeFile(filePath: string, maxBytes: number): string | null {
+  const text = readRegularConfigFile(filePath, maxBytes);
+  if (text === null) {
+    return null;
+  }
+  try {
+    const config: unknown = JSON.parse(text);
+    const theme = config && typeof config === 'object' ? (config as Record<string, unknown>).theme : undefined;
+    if (typeof theme !== 'string') {
+      return null;
+    }
+    return CLAUDE_THEME_IDS.has(theme) || theme.startsWith('custom:') ? theme : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Finds the theme Claude Code would start with in `projectPath`, read-only and
+ * in the CLI's own order: local, project and user settings, then the legacy
+ * global config key, then its "dark" default. Managed settings are not read:
+ * they outrank `--settings`, so no flag could change their theme anyway.
+ */
+function resolveClaudeTheme(projectPath: string): string {
+  const configDirOverride = process.env.CLAUDE_CONFIG_DIR;
+  const configHome = configDirOverride || path.join(os.homedir(), '.claude');
+  const legacyGlobalConfigPath = path.join(configHome, '.config.json');
+  const configFiles: Array<[string, number]> = [
+    [path.join(projectPath, '.claude', 'settings.local.json'), MAX_CLAUDE_SETTINGS_FILE_BYTES],
+    [path.join(projectPath, '.claude', 'settings.json'), MAX_CLAUDE_SETTINGS_FILE_BYTES],
+    [path.join(configHome, 'settings.json'), MAX_CLAUDE_SETTINGS_FILE_BYTES],
+    [
+      fs.existsSync(legacyGlobalConfigPath)
+        ? legacyGlobalConfigPath
+        : path.join(configDirOverride || os.homedir(), '.claude.json'),
+      MAX_CLAUDE_GLOBAL_CONFIG_FILE_BYTES,
+    ],
+  ];
+
+  for (const [filePath, maxBytes] of configFiles) {
+    const theme = readClaudeThemeFile(filePath, maxBytes);
+    if (theme) {
+      return theme;
+    }
+  }
+  return 'dark';
+}
+
+let hasLoggedThemeSettingsFileError = false;
+
+/**
+ * Returns a settings file that holds only `{"theme": theme}`, writing it when
+ * it is missing or differs. It lives in the app's own data folder
+ * (`~/.cloudcli`, like the chat assets); the user's Claude config is never
+ * written. The write goes through a temp file and a rename, so a CLI starting
+ * at the same time never reads half a file. Returns null, and logs once, when
+ * the file cannot be written (a read-only home, say): the launch then simply
+ * goes ahead without a theme.
+ */
+function ensureClaudeThemeSettingsFile(theme: string): string | null {
+  const contents = `${JSON.stringify({ theme })}\n`;
+  let tempPath: string | null = null;
+  try {
+    const filePath = path.join(os.homedir(), '.cloudcli', `claude-shell-theme-${theme}.json`);
+    // Anything but the expected regular file is replaced; the rename never
+    // opens what it replaces.
+    if (readRegularConfigFile(filePath) !== contents) {
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      tempPath = `${filePath}.${process.pid}.tmp`;
+      fs.writeFileSync(tempPath, contents);
+      fs.renameSync(tempPath, filePath);
+    }
+    return filePath;
+  } catch (error) {
+    if (tempPath) {
+      // Asynchronous and unchecked: cleaning up must not throw into the launch.
+      fs.rm(tempPath, { force: true }, () => undefined);
+    }
+    if (!hasLoggedThemeSettingsFileError) {
+      hasLoggedThemeSettingsFileError = true;
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`[WARN] Shell: cannot write the Claude theme settings file, launching without it: ${message}`);
+    }
+    return null;
+  }
+}
+
+/**
+ * Quotes one argument for the shell that runs the launch command. bash takes
+ * everything between single quotes literally, so a `'` closes the quote, adds
+ * an escaped one and reopens it. PowerShell (win32) single quotes are literal
+ * too, backslashes included; a quote is doubled, and PowerShell also treats
+ * the typographic single quotes as quote characters.
+ */
+function quoteShellArgument(value: string): string {
+  if (os.platform() === 'win32') {
+    return `'${value.replace(/['\u2018\u2019\u201A\u201B]/g, '$&$&')}'`;
+  }
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+type ClaudeThemeLaunch = {
+  flag: string;
+  /** Whether the CLI will paint in the app's colour scheme. */
+  followsAppTheme: boolean;
+};
+
+/**
+ * Claude Code paints its own colours in its own theme, dark by default, so in
+ * a light Shell tab its prompt rows became dark bands. Only a light tab gets a
+ * flag, and only when the user's theme is a dark one: it is swapped for the
+ * matching light variant. `--settings` applies it to this launch only. It is
+ * given a file path rather than inline JSON because PowerShell strips the
+ * JSON's double quotes when it passes an argument to a native program.
+ *
+ * The CLI follows the app theme when it gets that flag, when a dark tab runs a
+ * dark theme, and with `auto` (it asks the terminal, which xterm answers from
+ * the live theme). A light or custom theme the user chose, or a flag that
+ * could not be written, paints the same in either app theme, so restarting
+ * after a toggle would change nothing.
+ */
+function buildClaudeThemeLaunch(colorScheme: ShellColorScheme | null, projectPath: string): ClaudeThemeLaunch {
+  if (!colorScheme) {
+    return { flag: '', followsAppTheme: false };
+  }
+  const userTheme = resolveClaudeTheme(projectPath);
+  if (userTheme === 'auto') {
+    return { flag: '', followsAppTheme: true };
+  }
+  const lightTheme = LIGHT_CLAUDE_THEME_BY_DARK_THEME.get(userTheme);
+  if (!lightTheme) {
+    return { flag: '', followsAppTheme: false };
+  }
+  if (colorScheme === 'dark') {
+    return { flag: '', followsAppTheme: true };
+  }
+  const settingsPath = ensureClaudeThemeSettingsFile(lightTheme);
+  return settingsPath
+    ? { flag: ` --settings ${quoteShellArgument(settingsPath)}`, followsAppTheme: true }
+    : { flag: '', followsAppTheme: false };
 }
 
 function readEnvValue(env: NodeJS.ProcessEnv, key: string): string | undefined {
@@ -311,6 +552,7 @@ export function handleShellConnection(
         const provider = readString(data.provider, 'claude');
         const initialCommand = readString(data.initialCommand);
         const forceRestart = readBoolean(data.forceRestart);
+        const colorScheme = readColorScheme(data.colorScheme);
         const isPlainShell =
           readBoolean(data.isPlainShell) ||
           (!!initialCommand && !hasSession) ||
@@ -370,6 +612,7 @@ export function handleShellConnection(
           }
 
           existingSession.ws = ws;
+          sendClaudeColorScheme(ws, existingSession.claudeColorScheme);
           return;
         }
 
@@ -390,8 +633,13 @@ export function handleShellConnection(
           return;
         }
 
-        const shellCommand = buildShellCommand(data, dependencies);
+        const { command: shellCommand, claudeFollowsAppTheme } = buildShellCommand(
+          data,
+          dependencies,
+          resolvedProjectPath,
+        );
         const resumeSessionId = resolveResumeSessionId(data, dependencies);
+        const claudeColorScheme = claudeFollowsAppTheme ? colorScheme : null;
         const shell = os.platform() === 'win32' ? 'powershell.exe' : 'bash';
         const shellArgs =
           os.platform() === 'win32' ? ['-Command', shellCommand] : ['-c', shellCommand];
@@ -410,6 +658,10 @@ export function handleShellConnection(
             TERM: 'xterm-256color',
             COLORTERM: 'truecolor',
             FORCE_COLOR: '3',
+            // rxvt's "foreground;background" palette indices (15 = white, 0 = black).
+            // Programs that cannot query the terminal (vim, Claude Code's "auto"
+            // theme before its OSC 11 reply arrives) read it to pick light or dark.
+            ...(colorScheme ? { COLORFGBG: colorScheme === 'light' ? '0;15' : '15;0' } : {}),
           },
         });
 
@@ -420,6 +672,7 @@ export function handleShellConnection(
           timeoutId: null,
           projectPath,
           sessionId,
+          claudeColorScheme,
         });
 
         shellProcess.onData((chunk) => {
@@ -548,6 +801,7 @@ export function handleShellConnection(
             data: welcomeMsg,
           })
         );
+        sendClaudeColorScheme(ws, claudeColorScheme);
         return;
       }
 

package/server/modules/websocket/tests/chat-background-subscribe.test.ts

@@ -0,0 +1,167 @@
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import { mkdtemp, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test, { mock } from 'node:test';
+
+import { closeConnection, initializeDatabase, sessionsDb } from '@/modules/database/index.js';
+import { handleChatConnection } from '@/modules/websocket/services/chat-websocket.service.js';
+import { chatRunRegistry } from '@/modules/websocket/services/chat-run-registry.service.js';
+import { connectedClients } from '@/modules/websocket/services/websocket-state.service.js';
+
+/**
+ * A session's turn ends while its agents, workflow or backgrounded command are
+ * still going. The run registry marks the run completed at the turn's
+ * `complete`, but the runtime keeps producing events through that run's
+ * writer — task progress, and the turn the CLI pushes when the task reports.
+ * A tab opened during that work has to attach to the run to see them, and the
+ * run has to still be there to attach to.
+ */
+
+const SESSION_ID = 'held-session';
+const FIVE_MINUTES = 5 * 60 * 1000;
+
+function createFakeSocket() {
+  const socket = new EventEmitter() as EventEmitter & {
+    readyState: number;
+    frames: Array<Record<string, unknown>>;
+    send: (data: string) => void;
+  };
+  socket.readyState = 1;
+  socket.frames = [];
+  socket.send = (data: string) => socket.frames.push(JSON.parse(data) as Record<string, unknown>);
+  return socket;
+}
+
+async function withIsolatedDatabase(runTest: () => Promise<void>): Promise<void> {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const tempDirectory = await mkdtemp(path.join(os.tmpdir(), 'chat-background-subscribe-'));
+  closeConnection();
+  process.env.DATABASE_PATH = path.join(tempDirectory, 'auth.db');
+  await initializeDatabase();
+  try {
+    sessionsDb.createAppSession(SESSION_ID, 'claude', tempDirectory);
+    await runTest();
+  } finally {
+    connectedClients.clear();
+    chatRunRegistry.clearAll();
+    chatRunRegistry.setRetentionGuard(() => false);
+    closeConnection();
+    if (previousDatabasePath === undefined) {
+      delete process.env.DATABASE_PATH;
+    } else {
+      process.env.DATABASE_PATH = previousDatabasePath;
+    }
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+}
+
+/** Starts a run for the session and ends its turn, leaving the run completed but registered. */
+function startAndCompleteRun(connection: ReturnType<typeof createFakeSocket>) {
+  const run = chatRunRegistry.startRun({
+    appSessionId: SESSION_ID,
+    provider: 'claude',
+    providerSessionId: 'native-1',
+    connection: connection as never,
+    userId: 1,
+  });
+  assert.ok(run);
+  run.writer.send({ kind: 'complete', provider: 'claude', sessionId: 'native-1', exitCode: 0 });
+  assert.equal(chatRunRegistry.isProcessing(SESSION_ID), false);
+  return run;
+}
+
+const settle = () => new Promise((resolve) => { setTimeout(resolve, 30); });
+
+test('a tab that subscribes during background work receives the run\'s later events', async () => {
+  await withIsolatedDatabase(async () => {
+    const run = startAndCompleteRun(createFakeSocket());
+
+    const newTab = createFakeSocket();
+    handleChatConnection(
+      newTab as never,
+      { user: { id: 1 } } as never,
+      { runtime: { hasBackgroundWork: (sessionId: string) => sessionId === SESSION_ID, getPendingApprovalsForSession: () => [] } as never },
+    );
+    newTab.emit('message', JSON.stringify({ type: 'chat.subscribe', sessions: [{ sessionId: SESSION_ID, lastSeq: 0 }] }));
+    await settle();
+
+    // Not processing — the composer stays usable — but attached.
+    assert.equal(newTab.frames[0]?.kind, 'chat_subscribed');
+    assert.equal(newTab.frames[0]?.isProcessing, false);
+
+    run.writer.send({ kind: 'task_status', provider: 'claude', sessionId: 'native-1', event: 'notification', taskId: 't1', status: 'completed' } as never);
+    assert.ok(
+      newTab.frames.some((frame) => frame.kind === 'task_status'),
+      'the task event must reach the tab that subscribed after the turn ended',
+    );
+  });
+});
+
+test('a tab that subscribes to an idle session is not attached to its old run', async () => {
+  await withIsolatedDatabase(async () => {
+    const run = startAndCompleteRun(createFakeSocket());
+
+    const newTab = createFakeSocket();
+    handleChatConnection(
+      newTab as never,
+      { user: { id: 1 } } as never,
+      { runtime: { hasBackgroundWork: () => false, getPendingApprovalsForSession: () => [] } as never },
+    );
+    newTab.emit('message', JSON.stringify({ type: 'chat.subscribe', sessions: [{ sessionId: SESSION_ID, lastSeq: 0 }] }));
+    await settle();
+
+    run.writer.send({ kind: 'task_status', provider: 'claude', sessionId: 'native-1', event: 'notification', taskId: 't1', status: 'completed' } as never);
+    assert.ok(!newTab.frames.some((frame) => frame.kind === 'task_status'));
+  });
+});
+
+test('a completed run stays registered while its session still has background work', async () => {
+  mock.timers.enable({ apis: ['setTimeout'] });
+  try {
+    await withIsolatedDatabase(async () => {
+      let working = true;
+      chatRunRegistry.setRetentionGuard((sessionId) => sessionId === SESSION_ID && working);
+      startAndCompleteRun(createFakeSocket());
+
+      mock.timers.tick(FIVE_MINUTES);
+      assert.ok(chatRunRegistry.getRun(SESSION_ID), 'the run must outlive the retention window while work is outstanding');
+
+      working = false;
+      mock.timers.tick(FIVE_MINUTES);
+      assert.equal(chatRunRegistry.getRun(SESSION_ID), undefined, 'once the work is gone the run is evicted as before');
+    });
+  } finally {
+    mock.timers.reset();
+  }
+});
+
+test('a retained run\'s eviction timer cannot evict the session\'s next run early', async () => {
+  // Run one completes with work outstanding and is re-armed at five minutes;
+  // run two takes the slot and completes with two minutes of retention to
+  // go. Run one's timer firing on the slot alone would evict run two.
+  mock.timers.enable({ apis: ['setTimeout'] });
+  try {
+    await withIsolatedDatabase(async () => {
+      let working = true;
+      chatRunRegistry.setRetentionGuard((sessionId) => sessionId === SESSION_ID && working);
+      const first = startAndCompleteRun(createFakeSocket());
+      mock.timers.tick(FIVE_MINUTES);
+      assert.equal(chatRunRegistry.getRun(SESSION_ID), first);
+
+      working = false;
+      mock.timers.tick(FIVE_MINUTES - 2 * 60 * 1000);
+      const second = startAndCompleteRun(createFakeSocket());
+      assert.equal(chatRunRegistry.getRun(SESSION_ID), second);
+
+      // Run one's re-armed timer fires now; run two's has two minutes left.
+      mock.timers.tick(2 * 60 * 1000);
+      assert.equal(chatRunRegistry.getRun(SESSION_ID), second, 'run two keeps its own retention window');
+      mock.timers.tick(FIVE_MINUTES);
+      assert.equal(chatRunRegistry.getRun(SESSION_ID), undefined);
+    });
+  } finally {
+    mock.timers.reset();
+  }
+});