clideck 1.31.16 → 1.31.17

package/activity.js

@@ -1,77 +1,22 @@
-// Per-session I/O tracking and burst detection.
-// Broadcasts rate + burst data so the frontend can derive working/idle status.
-
-let interval = null;
-const net = {};    // id → byte counters
-const stream = {}; // id → burst timing
+// Lightweight per-session I/O counters. The old per-second stats broadcast was
+// removed after frontend status tracking moved away from I/O heuristics.
+const net = {}; // id -> byte counters
 
 function ensure(id) {
-  if (!net[id]) net[id] = { in: 0, out: 0, prevIn: 0, prevOut: 0 };
-  if (!stream[id]) stream[id] = { lastOutAt: 0, burstStart: 0 };
+  if (!net[id]) net[id] = { in: 0, out: 0 };
+  return net[id];
 }
 
 function trackIn(id, bytes) {
-  ensure(id);
-  net[id].in += bytes;
-  stream[id].lastInAt = Date.now();
+  const n = ensure(id);
+  n.in += bytes;
 }
 
-function lastInputAt(id) { return stream[id]?.lastInAt || 0; }
-
 function trackOut(id, data) {
-  ensure(id);
-  const now = Date.now();
-  const s = stream[id];
-  net[id].out += data.length;
-  if (now - s.lastOutAt > 2000) s.burstStart = now;
-  s.lastOutAt = now;
-  s.lastChunk = data;
+  const n = ensure(id);
+  n.out += data.length;
 }
 
-function start(sessions, broadcast) {
-  if (interval) return;
-  interval = setInterval(() => {
-    if (!sessions.size) return;
-    const now = Date.now();
-    const stats = {};
-    for (const [id] of sessions) {
-      ensure(id);
-      const n = net[id];
-      const s = stream[id];
-      const rawRateOut = n.out - n.prevOut;
-      const rawRateIn = n.in - n.prevIn;
-      n.prevOut = n.out;
-      n.prevIn = n.in;
-      const silence = s.lastOutAt ? now - s.lastOutAt : 0;
-      const burstMs = s.burstStart && silence < 2000 ? now - s.burstStart : 0;
-      stats[id] = { rawRateOut, rawRateIn, burstMs };
-    }
-    if (Object.keys(stats).length) broadcast({ type: 'stats', stats });
-    // Debug: PTY active state + last output chars per session (1s tick)
-    const active = [];
-    for (const [id] of sessions) {
-      const s = stream[id]; if (!s?.lastOutAt) continue;
-      const state = now - s.lastOutAt < 2000 ? 'ACTIVE' : 'SILENT';
-      const last = (s.lastChunk || '').replace(/\x1b\[[0-9;?]*[ -/]*[@-~]|\x1b\].*?(?:\x07|\x1b\\)|\x1b./g, '').replace(/[\r\n]+/g, ' ').trim().slice(-80);
-      active.push(`${id.slice(0,8)}=${state} [${last}]`);
-    }
-    // if (active.length) console.log(`[pty] ${active.join(' | ')}`);
-  }, 1000);
-}
-
-function stop() {
-  clearInterval(interval);
-  interval = null;
-}
-
-function isActive(id) {
-  const s = stream[id];
-  return s ? (Date.now() - s.lastOutAt < 2000) : false;
-}
-
-function lastOutputAt(id) { return stream[id]?.lastOutAt || 0; }
-function lastChunk(id) { return stream[id]?.lastChunk || ''; }
-
-function clear(id) { delete net[id]; delete stream[id]; }
+function clear(id) { delete net[id]; }
 
-module.exports = { start, stop, trackIn, trackOut, isActive, lastOutputAt, lastInputAt, lastChunk, clear };
+module.exports = { trackIn, trackOut, clear };

package/ansi-utils.js

@@ -0,0 +1,7 @@
+const ANSI_RE = /\x1b[\[\]()#;?]*[0-9;?]*[ -/]*[@-~]|\x1b\].*?(?:\x07|\x1b\\)|\x1b.|\r|\x07/g;
+
+function stripAnsi(value) {
+  return String(value || '').replace(ANSI_RE, '');
+}
+
+module.exports = { ANSI_RE, stripAnsi };

package/claude-session.js

@@ -0,0 +1,17 @@
+const CLAUDE_SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+function updateClaudeSessionToken(sess, token, clideckId, options = {}) {
+  const next = String(token || '').trim();
+  if (!sess || sess.presetId !== 'claude-code' || !CLAUDE_SESSION_ID_RE.test(next)) return false;
+  if (sess.sessionToken === next) return false;
+  const prev = sess.sessionToken;
+  sess.sessionToken = next;
+
+  const label = options.label || 'Claude';
+  const source = options.source ? ` via ${options.source}` : '';
+  const previous = prev ? `${prev.slice(0, 12)}... -> ` : '';
+  console.log(`${label}: updated Claude session ID for ${clideckId.slice(0, 8)}${source}: ${previous}${next.slice(0, 12)}...`);
+  return true;
+}
+
+module.exports = { CLAUDE_SESSION_ID_RE, updateClaudeSessionToken };

package/config.js

@@ -3,7 +3,8 @@ const { join } = require('path');
 const crypto = require('crypto');
 const os = require('os');
 const { DATA_DIR } = require('./paths');
-const { defaultShell, binName } = require('./utils');
+const { defaultShell } = require('./utils');
+const { presetForCommand } = require('./preset-utils');
 
 const CONFIG_PATH = join(DATA_DIR, 'config.json');
 
@@ -63,10 +64,7 @@ function isPresetEnabled(preset) {
 }
 const EXPOSED_PRESETS = PRESETS.filter(isPresetEnabled);
 
-function matchPreset(cmd) {
-  const bin = binName(cmd.command);
-  return PRESETS.find(p => binName(p.command) === bin);
-}
+function matchPreset(cmd) { return presetForCommand(cmd, PRESETS, { usePresetId: false }); }
 
 function firstCommandToken(command) {
   const raw = String(command || '').trim();

package/handlers.js

@@ -7,6 +7,7 @@ const sessions = require('./sessions');
 const themes = require('./themes');
 const presets = JSON.parse(readFileSync(join(__dirname, 'agent-presets.json'), 'utf8'));
 const { listDirs, binName, defaultShell } = require('./utils');
+const { presetForCommand: findPresetForCommand } = require('./preset-utils');
 const { PORT } = require('./runtime');
 for (const p of presets) if (p.presetId === 'shell') p.command = defaultShell;
 function isPresetEnabled(preset) {
@@ -72,15 +73,10 @@ function getInstalledVersion(bin) {
 }
 
 function presetForCommand(cmd) {
-  if (cmd?.presetId) {
-    const preset = presets.find(p => p.presetId === cmd.presetId);
-    if (preset) return preset;
-  }
-  const bin = binName(cmd?.command);
-  return presets.find(p => binName(p.command) === bin);
+  return findPresetForCommand(cmd, presets);
 }
 
-function commandEnv(cmd) {
+function rawCommandEnv(cmd) {
   return cmd?.env && typeof cmd.env === 'object' && !Array.isArray(cmd.env) ? cmd.env : {};
 }
 
@@ -93,7 +89,7 @@ function expandHomePath(value) {
 }
 
 function configRootFor(preset, cmd) {
-  const env = commandEnv(cmd);
+  const env = rawCommandEnv(cmd);
   if (preset?.presetId === 'claude-code') return expandHomePath(env.CLAUDE_CONFIG_DIR) || join(os.homedir(), '.claude');
   if (preset?.presetId === 'codex') return expandHomePath(env.CODEX_HOME) || join(os.homedir(), '.codex');
   if (preset?.presetId === 'gemini-cli') return join(expandHomePath(env.GEMINI_CLI_HOME) || os.homedir(), '.gemini');
@@ -262,7 +258,7 @@ function detectTelemetryConfig(c) {
       if (preset.available && preset.minVersion && !preset.versionOk) {
         detected = false;
         reason = `Update required (${preset.minVersion}+)`;
-      } else if (!detected && cmd.telemetryEnabled && preset.telemetryAutoSetup && preset.available && preset.versionOk && !attemptedRepairs.has(cmd.id || preset.presetId)) {
+      } else if (!detected && cmd.telemetryEnabled && cmd.telemetrySetupConsent === true && preset.telemetryAutoSetup && preset.available && preset.versionOk && !attemptedRepairs.has(cmd.id || preset.presetId)) {
         attemptedRepairs.add(cmd.id || preset.presetId);
         const repaired = applyTelemetryConfig(preset, cmd);
         if (repaired.success) {
@@ -399,6 +395,7 @@ function onConnection(ws) {
         cfg = { ...cfg, ...msg.config };
         detectTelemetryConfig(cfg);
         config.save(cfg);
+        plugins.notifyConfig(cfg);
         sessions.broadcast({ type: 'config', config: configForClient() });
         break;
 
@@ -417,11 +414,13 @@ function onConnection(ws) {
           if (targetCmd ? cmd.id === targetCmd.id : presetForCommand(cmd)?.presetId === preset.presetId) {
             cmd.telemetryEnabled = result.success;
             cmd.telemetryStatus = result.success ? { ok: true } : { ok: false, error: result.message };
+            if (result.success) cmd.telemetrySetupConsent = true;
             // Enable the agent when setup succeeds, disable if it fails
             if (result.success) cmd.enabled = true;
           }
         }
         config.save(cfg);
+        plugins.notifyConfig(cfg);
         sessions.broadcast({ type: 'config', config: configForClient() });
         ws.send(JSON.stringify({
           type: 'telemetry.autosetup.result',
@@ -448,12 +447,14 @@ function onConnection(ws) {
         for (const cmd of cfg.commands) {
           if (targetCmd ? cmd.id === targetCmd.id : presetForCommand(cmd)?.presetId === preset.presetId) {
             cmd.telemetryEnabled = enable && result.success;
+            cmd.telemetrySetupConsent = enable && result.success;
             cmd.telemetryStatus = enable
               ? (result.success ? { ok: true } : { ok: false, error: result.message })
               : null;
           }
         }
         config.save(cfg);
+        plugins.notifyConfig(cfg);
         sessions.broadcast({ type: 'config', config: configForClient() });
         break;
       }
@@ -659,6 +660,7 @@ function onConnection(ws) {
 
       case 'remote.install': {
         const update = !!msg.update;
+        const restartAfterUpdate = !!msg.restart;
         const proc = require('child_process').spawn('npm', ['install', '-g', 'clideck-remote'], {
           shell: true, stdio: ['ignore', 'pipe', 'pipe'],
         });
@@ -666,8 +668,8 @@ function onConnection(ws) {
         proc.stderr.on('data', d => ws.send(JSON.stringify({ type: 'remote.install.progress', text: d.toString() })));
         proc.on('close', code => {
           remoteUpdateCache = null;
-          if (code !== 0 || !update) {
-            ws.send(JSON.stringify({ type: 'remote.install.done', success: code === 0, update }));
+          if (code !== 0 || !update || !restartAfterUpdate) {
+            ws.send(JSON.stringify({ type: 'remote.install.done', success: code === 0, update, restarted: false }));
             return;
           }
           require('child_process').execFile('clideck-remote', ['restart', '--json'], { timeout: 10000, shell: process.platform === 'win32', env: remoteCliEnv() }, (err, stdout) => {

package/http-util.js

@@ -0,0 +1,20 @@
+function sendJson(res, status, payload) {
+  res.writeHead(status, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify(payload));
+}
+
+function isLoopback(req) {
+  const addr = req.socket?.remoteAddress || '';
+  return addr === '::1' || addr === '127.0.0.1' || addr.startsWith('127.') || addr.startsWith('::ffff:127.');
+}
+
+function sameProject(a, b) {
+  return (a.projectId || null) === (b.projectId || null);
+}
+
+function projectName(projects, projectId) {
+  if (!projectId) return 'No project';
+  return projects.find(p => p.id === projectId)?.name || projectId;
+}
+
+module.exports = { sendJson, isLoopback, sameProject, projectName };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clideck",
-  "version": "1.31.16",
+  "version": "1.31.17",
   "description": "One screen for all your AI coding agents — run, monitor, and manage multiple CLI agents from a single browser tab",
   "main": "server.js",
   "bin": {

package/preset-utils.js

@@ -0,0 +1,13 @@
+const { binName } = require('./utils');
+
+function presetForCommand(cmd, presets, options = {}) {
+  const usePresetId = options.usePresetId !== false;
+  if (usePresetId && cmd?.presetId) {
+    const preset = presets.find(p => p.presetId === cmd.presetId);
+    if (preset) return preset;
+  }
+  const bin = binName(cmd?.command);
+  return presets.find(p => binName(p.command) === bin);
+}
+
+module.exports = { presetForCommand };

package/public/js/app.js

@@ -369,7 +369,7 @@ function connect() {
       case 'remote.update':
         remoteUpdateInfo = msg?.available ? msg : null;
         if (remoteUpdateInfo?.available && remoteInstalled && !remoteInstallMode) {
-          startRemoteInstall({ update: true, auto: true });
+          startRemoteInstall({ update: true, auto: true, connectAfter: remoteState === 'waiting' || remoteState === 'paired' || remoteModalOpen });
         }
         if (remotePreflight?.pending) {
           remotePreflight.updateSeen = true;
@@ -1222,7 +1222,7 @@ function finishRemotePreflight() {
     return;
   }
   if (remoteUpdateInfo?.available) {
-    startRemoteInstall({ update: true, auto: true });
+    startRemoteInstall({ update: true, auto: true, connectAfter: true });
     return;
   }
   if (remoteState === 'idle') {
@@ -1384,7 +1384,7 @@ function handleRemoteStatus(msg) {
     if (wasPaired) { stopRemoteStats(); setRemoteLock(false); }
   }
   if (remoteUpdateInfo?.available && remoteInstalled && !remoteInstallMode) {
-    startRemoteInstall({ update: true, auto: true });
+    startRemoteInstall({ update: true, auto: true, connectAfter: remoteState === 'waiting' || remoteState === 'paired' || remoteModalOpen });
     return;
   }
   updateRemoteButton();
@@ -1404,7 +1404,7 @@ function handleRemotePaired(msg) {
   updateRemoteButton();
   startRemotePoll();
   if (remoteUpdateInfo?.available && remoteInstalled && !remoteInstallMode) {
-    startRemoteInstall({ update: true, auto: true });
+    startRemoteInstall({ update: true, auto: true, connectAfter: true });
     return;
   }
   if (remotePreflight?.pending) {
@@ -1439,25 +1439,36 @@ function appendInstallLog(text) {
 }
 
 function startRemoteInstall(opts = {}) {
-  remoteInstallMode = { update: !!opts.update, auto: !!opts.auto };
+  const update = !!opts.update;
+  const auto = !!opts.auto;
+  const connectAfter = opts.connectAfter !== undefined
+    ? !!opts.connectAfter
+    : (!auto || remoteModalOpen || remoteState === 'waiting' || remoteState === 'paired');
+  remoteInstallMode = { update, auto, connectAfter };
   const log = document.getElementById('remote-install-log');
   log.textContent = '';
   if (remoteInstallMode.update) {
     appendInstallLog(`Updating clideck-remote to ${remoteUpdateInfo?.latest || 'latest'}...\n`);
   }
   setRemotePane('installing');
-  if (!remoteModalOpen) openRemoteModal();
-  send({ type: 'remote.install', update: remoteInstallMode.update });
+  if (!remoteModalOpen && remoteInstallMode.connectAfter) openRemoteModal();
+  send({ type: 'remote.install', update: remoteInstallMode.update, restart: remoteInstallMode.connectAfter });
 }
 
 function handleInstallDone(msg) {
   const success = !!msg?.success;
   const wasUpdate = !!msg?.update || !!remoteInstallMode?.update;
+  const mode = remoteInstallMode || {};
   remoteInstallMode = null;
   if (success) {
     remoteInstalled = true;
     remoteUpdateInfo = null;
     if (wasUpdate) {
+      if (!mode.connectAfter && !msg?.restart) {
+        send({ type: 'remote.status', forceUpdate: true });
+        updateRemoteButton();
+        return;
+      }
       remoteState = 'connecting';
       setRemotePane('connecting');
       send({ type: 'remote.status', forceUpdate: true });
@@ -1472,6 +1483,9 @@ function handleInstallDone(msg) {
     const log = document.getElementById('remote-install-log');
     log.textContent += `\n— ${msg?.error || 'Install failed'}. Check permissions or run manually:\n  npm install -g clideck-remote\n`;
     log.scrollTop = log.scrollHeight;
+    if (!remoteModalOpen) {
+      showToast('Mobile Remote update failed. Run `npm install -g clideck-remote` manually.', { type: 'error', duration: 6000 });
+    }
   }
 }
 

package/public/js/settings.js

@@ -614,6 +614,7 @@ function saveConfig() {
       outputMarker: existing.outputMarker || preset?.outputMarker || null,
       env: parseEnvText(card.querySelector('.agent-env')?.value || ''),
       telemetryEnabled: telemetryEnabledForCommand({ ...existing, presetId }, command),
+      telemetrySetupConsent: !!existing.telemetrySetupConsent,
       telemetryStatus: existing.telemetryStatus || null,
       bridge: existing.bridge || preset?.bridge,
       userAdded: !!existing.userAdded,

package/server.js

@@ -4,6 +4,7 @@ const { join, extname, resolve } = require('path');
 const { WebSocketServer } = require('ws');
 const { ensurePtyHelper } = require('./utils');
 const { PORT, HOST, localUrl } = require('./runtime');
+const { updateClaudeSessionToken } = require('./claude-session');
 
 function terminalLink(url, text = url) {
   return `\u001B]8;;${url}\u0007${text}\u001B]8;;\u0007`;
@@ -17,16 +18,6 @@ function openUrlHint() {
 const currentVersion = require('./package.json').version;
 const { execFile, execSync } = require('child_process');
 const shellOpt = process.platform === 'win32';
-const CLAUDE_SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-
-function updateClaudeSessionToken(sess, token, clideckId, source) {
-  const next = String(token || '').trim();
-  if (!sess || sess.presetId !== 'claude-code' || !CLAUDE_SESSION_ID_RE.test(next)) return;
-  if (sess.sessionToken === next) return;
-  const prev = sess.sessionToken;
-  sess.sessionToken = next;
-  console.log(`Claude: updated session ID for ${clideckId.slice(0, 8)} via ${source}: ${prev ? prev.slice(0, 12) + '... -> ' : ''}${next.slice(0, 12)}...`);
-}
 
 function checkSelfUpdate() {
   return new Promise(ok => {
@@ -180,7 +171,7 @@ const server = http.createServer((req, res) => {
             : null;
         if (clideckId) {
           const sess = allSessions.get(clideckId);
-          updateClaudeSessionToken(sess, sessionId, clideckId, `hook:${route}`);
+          updateClaudeSessionToken(sess, sessionId, clideckId, { label: 'Claude', source: `hook:${route}` });
           if (route === 'start') {
             sessions.broadcast({ type: 'session.status', id: clideckId, working: true, source: 'hook' });
           } else if (route === 'stop' || route === 'idle') {
@@ -301,15 +292,12 @@ const wss = new WebSocketServer({
 });
 wss.on('connection', onConnection);
 
-const activity = require('./activity');
-activity.start(sessions.getSessions(), sessions.broadcast);
 sessions.startAutoSave(() => require('./handlers').getConfig());
 
 // Graceful shutdown: persist sessions before exit
 const { getConfig } = require('./handlers');
 function onShutdown() {
   plugins.shutdown();
-  activity.stop();
   sessions.shutdown(getConfig());
   removeLockIfOwned();
   process.exit(0);

package/session-agents.js

@@ -1,21 +1,4 @@
-function sendJson(res, status, payload) {
-  res.writeHead(status, { 'Content-Type': 'application/json' });
-  res.end(JSON.stringify(payload));
-}
-
-function isLoopback(req) {
-  const addr = req.socket?.remoteAddress || '';
-  return addr === '::1' || addr === '127.0.0.1' || addr.startsWith('127.') || addr.startsWith('::ffff:127.');
-}
-
-function sameProject(a, b) {
-  return (a.projectId || null) === (b.projectId || null);
-}
-
-function projectName(projects, projectId) {
-  if (!projectId) return 'No project';
-  return projects.find(p => p.id === projectId)?.name || projectId;
-}
+const { sendJson, isLoopback, sameProject, projectName } = require('./http-util');
 
 function agentRow(id, s, callerId, projects) {
   const project = projectName(projects, s.projectId);

package/session-ask.js

@@ -1,4 +1,5 @@
 const transcript = require('./transcript');
+const { sendJson, isLoopback, sameProject, projectName } = require('./http-util');
 
 const MAX_BODY = 2 * 1024 * 1024;
 const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
@@ -6,11 +7,6 @@ const MAX_TIMEOUT_MS = 60 * 60 * 1000;
 const BRACKETED_PASTE_START = '\x1b[200~';
 const BRACKETED_PASTE_END = '\x1b[201~';
 
-function sendJson(res, status, payload) {
-  res.writeHead(status, { 'Content-Type': 'application/json' });
-  res.end(JSON.stringify(payload));
-}
-
 function readJson(req) {
   return new Promise((resolve, reject) => {
     let body = '';
@@ -35,26 +31,12 @@ function jsonError(message, status = 400) {
   return err;
 }
 
-function isLoopback(req) {
-  const addr = req.socket?.remoteAddress || '';
-  return addr === '::1' || addr === '127.0.0.1' || addr.startsWith('127.') || addr.startsWith('::ffff:127.');
-}
-
 function normalizeTimeout(ms) {
   const n = Number(ms || DEFAULT_TIMEOUT_MS);
   if (!Number.isFinite(n) || n <= 0) return DEFAULT_TIMEOUT_MS;
   return Math.min(Math.round(n), MAX_TIMEOUT_MS);
 }
 
-function sameProject(a, b) {
-  return (a.projectId || null) === (b.projectId || null);
-}
-
-function projectName(projects, projectId) {
-  if (!projectId) return 'No project';
-  return projects.find(p => p.id === projectId)?.name || projectId;
-}
-
 function parseScopedTarget(target) {
   const text = String(target || '').trim();
   if (!text.startsWith('@')) return null;

package/sessions.js

@@ -8,11 +8,12 @@ const transcript = require('./transcript');
 const telemetry = require('./telemetry-receiver');
 const opencodeBridge = require('./opencode-bridge');
 const plugins = require('./plugin-loader');
+const { presetForCommand } = require('./preset-utils');
+const { stripAnsi } = require('./ansi-utils');
 
 const THEMES = require('./themes');
 const MAX_BUFFER = 2 * 1024 * 1024;
 const { PORT, localUrl } = require('./runtime');
-const ANSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]|\x1b\].*?(?:\x07|\x1b\\)|\x1b./g;
 const PRESETS = JSON.parse(require('fs').readFileSync(join(__dirname, 'agent-presets.json'), 'utf8'));
 for (const p of PRESETS) if (p.presetId === 'shell') p.command = defaultShell;
 const { DATA_DIR } = require('./paths');
@@ -37,6 +38,9 @@ function broadcast(msg) {
   const raw = JSON.stringify(msg);
   for (const c of clients) if (c.readyState === 1) c.send(raw);
   if (msg.type === 'session.status') {
+    // Status broadcasts currently also apply the local state transition. This is
+    // intentional for now but couples transport with session state; if this area
+    // changes, split it into a dedicated setSessionStatus() transition first.
     const s = sessions.get(msg.id);
     if (s) {
       s.working = !!msg.working;
@@ -59,14 +63,7 @@ function broadcast(msg) {
 
 // --- Spawn a PTY and wire up a session ---
 
-function presetForCommand(cmd) {
-  if (cmd?.presetId) {
-    const preset = PRESETS.find(p => p.presetId === cmd.presetId);
-    if (preset) return preset;
-  }
-  const bin = binName(cmd?.command);
-  return PRESETS.find(p => binName(p.command) === bin);
-}
+function matchPreset(cmd) { return presetForCommand(cmd, PRESETS); }
 
 function commandEnv(cmd) {
   const env = {};
@@ -78,7 +75,7 @@ function commandEnv(cmd) {
 }
 
 function buildTelemetryEnv(id, cmd) {
-  const preset = presetForCommand(cmd);
+  const preset = matchPreset(cmd);
   const telemetryEnabled = cmd.telemetryEnabled ?? (preset?.presetId === 'claude-code');
   const env = { CLIDECK_SESSION_ID: id, CLIDECK_PORT: String(PORT), CLIDECK_URL: localUrl() };
   if (!preset?.telemetryEnv || !telemetryEnabled) return env;
@@ -114,7 +111,7 @@ function spawnSession(id, cmd, parts, cwd, name, themeId, commandId, savedToken,
   }
 
   const sessionIdRe = cmd.sessionIdPattern ? new RegExp(cmd.sessionIdPattern, 'i') : null;
-  const preset = presetForCommand(cmd);
+  const preset = matchPreset(cmd);
   const session = { name, themeId, commandId, cwd, pty: term, chunks: [], chunksSize: 0, sessionToken: savedToken || null, projectId: projectId || null, presetId: preset?.presetId || 'shell', working: undefined };
   sessions.set(id, session);
   transcript.setFinalizeOnIdle(id, ['claude-code', 'codex', 'gemini-cli', 'opencode', 'clideck-agent'].includes(session.presetId) ? session.presetId : null);
@@ -134,7 +131,7 @@ function spawnSession(id, cmd, parts, cwd, name, themeId, commandId, savedToken,
     // Capture session ID from output
     if (sessionIdRe && !session.sessionToken) {
       const joined = session.chunks.join('');
-      const match = joined.match(sessionIdRe) || joined.replace(ANSI_RE, '').match(sessionIdRe);
+      const match = joined.match(sessionIdRe) || stripAnsi(joined).match(sessionIdRe);
       if (match) {
         session.sessionToken = match[1];
         console.log(`Session ${id.slice(0, 8)}: captured token via output regex: ${match[1].slice(0, 12)}…`);
@@ -196,12 +193,12 @@ function create(msg, ws, cfg) {
     return;
   }
 
-  const createdPresetId = presetForCommand(cmd)?.presetId || 'shell';
+  const createdPresetId = matchPreset(cmd)?.presetId || 'shell';
   const installId = msg.installId || undefined;
   broadcast({ type: 'created', id, name, themeId, commandId: cmd.id, presetId: createdPresetId, projectId, installId });
 
   // Immediate setup notification if config not detected
-  const preset = presetForCommand(cmd);
+  const preset = matchPreset(cmd);
   if (preset && (preset.telemetrySetup || preset.bridge) && !(cmd.telemetryEnabled && cmd.telemetryStatus?.ok)) {
     broadcast({ type: 'session.needsSetup', id });
   }
@@ -228,7 +225,7 @@ function createProgrammatic(opts, cfg) {
   const s = sessions.get(id);
   if (s && opts.ephemeral) s.ephemeral = true;
 
-  const presetId = presetForCommand(cmd)?.presetId || 'shell';
+  const presetId = matchPreset(cmd)?.presetId || 'shell';
   broadcast({ type: 'created', id, name, themeId, commandId: cmd.id, presetId, projectId });
   return { id };
 }
@@ -278,7 +275,7 @@ function resume(msg, ws, cfg) {
   resumable = resumable.filter(s => s.id !== id);
   broadcast({ type: 'sessions.resumable', list: getResumable(cfg) });
 
-  const resumePresetId = presetForCommand(cmd)?.presetId || saved.presetId || 'shell';
+  const resumePresetId = matchPreset(cmd)?.presetId || saved.presetId || 'shell';
   broadcast({ type: 'created', id, name: saved.name, themeId: saved.themeId || saved.profileId || 'default', commandId: saved.commandId, presetId: resumePresetId, projectId: saved.projectId || null, muted: !!saved.muted, resumed: true, lastPreview: saved.lastPreview || '' });
 }
 
@@ -422,7 +419,7 @@ function getResumable(cfg) {
     if (s.presetId) return s;
     const cmd = (cfg.commands || []).find(c => c.id === s.commandId);
     if (!cmd) return { ...s, presetId: 'shell' };
-    const preset = presetForCommand(cmd);
+    const preset = matchPreset(cmd);
     return { ...s, presetId: preset?.presetId || 'shell' };
   });
 }

package/telemetry-receiver.js

@@ -2,7 +2,8 @@
 // CLI agents export telemetry events here; we capture agent session IDs
 // (for resume) and detect whether telemetry is configured (setup prompts).
 
-const ioActivity = require('./activity');
+const { updateClaudeSessionToken } = require('./claude-session');
+
 const activity = new Map(); // sessionId → has received events
 const lastEvent = new Map(); // sessionId → last OTEL event name (+ kind)
 const pendingSetup = new Map(); // sessionId → timer (waiting for first event)
@@ -10,21 +11,14 @@ const codexMenuPoll = new Map(); // sessionId → interval (polling for menu aft
 const codexPendingStop = new Map(); // sessionId → ts (notify hook arrived; wait for next response.completed)
 const codexOutputDone = new Map(); // sessionId → ts (fallback if notify never fires)
 const codexPendingIdle = new Map(); // sessionId → timer (tiny settle before committing idle)
+// Codex does not currently expose one reliable "fully idle" signal across streamed
+// output, tool calls, and approval menus. This state machine is the best available
+// approach for now; do not add more timing patches without fixture tests from real
+// Codex event sequences.
 const codexToolPhasePending = new Set(); // sessionId set once Codex has announced a tool-call phase, cleared when the phase resolves
 const codexPendingTools = new Map(); // sessionId → Set(callId) for approved Codex tool calls still awaiting a result
 let broadcastFn = null;
 let sessionsFn = null;
-const CLAUDE_SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-
-function updateClaudeSessionToken(sess, token, clideckId) {
-  const next = String(token || '').trim();
-  if (!sess || sess.presetId !== 'claude-code' || !CLAUDE_SESSION_ID_RE.test(next)) return false;
-  if (sess.sessionToken === next) return false;
-  const prev = sess.sessionToken;
-  sess.sessionToken = next;
-  console.log(`Telemetry: updated Claude session ID for ${clideckId.slice(0, 8)}: ${prev ? prev.slice(0, 12) + '... -> ' : ''}${next.slice(0, 12)}...`);
-  return true;
-}
 
 function getPendingToolSet(id) {
   let set = codexPendingTools.get(id);
@@ -218,7 +212,7 @@ function handleLogs(req, res) {
           : (attrs['session.id'] || attrs['conversation.id']);
         if (agentSessionId && sess) {
           if (serviceName === 'claude-code') {
-            updateClaudeSessionToken(sess, agentSessionId, resolvedId);
+            updateClaudeSessionToken(sess, agentSessionId, resolvedId, { label: 'Telemetry' });
             continue;
           }
           // Prefer interactive session ID (Gemini sends non-interactive init events first)
@@ -289,14 +283,6 @@ function markCodexStart(id, source = 'hook') {
   broadcastFn?.({ type: 'session.status', id, working: true, source });
 }
 
-function markCodexIdle(id, source = 'hook') {
-  codexPendingStop.delete(id);
-  codexOutputDone.delete(id);
-  codexToolPhasePending.delete(id);
-  clearPendingTools(id);
-  scheduleCodexIdle(id, source);
-}
-
 function scheduleCodexIdle(id, source) {
   cancelCodexPendingIdle(id);
   const timer = setTimeout(() => {
@@ -326,9 +312,4 @@ function clear(id) {
 
 function getLastEvent(id) { return lastEvent.get(id) || ''; }
 
-// Returns true if we've received telemetry events for this session
-function hasEvents(id) {
-  return activity.has(id);
-}
-
-module.exports = { init, handleLogs, clear, hasEvents, getLastEvent, cancelCodexMenuPoll, watchSession, armCodexStop, markCodexStart, markCodexIdle };
+module.exports = { init, handleLogs, clear, getLastEvent, cancelCodexMenuPoll, watchSession, armCodexStop, markCodexStart };

package/transcript.js

@@ -4,9 +4,9 @@ const { DATA_DIR } = require('./paths');
 const builder = require('./transcript-normalizer');
 const parser = require('./transcript-parser');
 const candidate = require('./transcript-candidate');
+const { stripAnsi } = require('./ansi-utils');
 
 const DIR = join(DATA_DIR, 'transcripts');
-const ANSI_RE = /\x1b[\[\]()#;?]*[0-9;]*[a-zA-Z@`~]|\x1b\].*?(?:\x07|\x1b\\)|\x1b.|\r|\x07/g;
 const MAX_CACHE = 50 * 1024;
 const LEGACY_SUFFIXES = ['-parsed.jsonl', '.screen'];
 
@@ -153,7 +153,7 @@ function trackOutput(id, data) {
 function flush(id) {
   const buf = outputBuf[id];
   if (!buf?.text) return;
-  const clean = buf.text.replace(ANSI_RE, '').replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, '');
+  const clean = stripAnsi(buf.text).replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, '');
   const lines = clean.split('\n').map(l => l.trim()).filter(l => l.length > 2);
   buf.text = '';
   if (lines.length) store(id, 'agent', lines.join('\n'));