clideck 1.27.1 → 1.29.1

package/README.md

@@ -72,6 +72,13 @@ clideck auto-detects whether each agent is working or idle:
 
 Claude Code works out of the box. Other agents need a one-time setup that clideck walks you through.
 
+Minimum supported agent versions:
+
+- Gemini CLI `v0.36.0+`
+- OpenAI Codex `v0.118.0+`
+- Claude Code `v2.1.90+`
+- OpenCode `v1.2.26+`
+
 ## How It Works
 
 Each agent runs in a real terminal (PTY) on your machine. clideck receives lightweight status signals via OpenTelemetry — it knows *that* an agent is working, not *what* it's working on.

package/agent-presets.json

@@ -4,6 +4,7 @@
     "name": "Claude Code",
     "icon": "/img/claude-code.png",
     "command": "claude",
+    "minVersion": "2.1.90",
     "installCmd": "npm install -g @anthropic-ai/claude-code",
     "isAgent": true,
     "canResume": true,
@@ -28,6 +29,7 @@
     "name": "Codex",
     "icon": "/img/codex.png",
     "command": "codex --no-alt-screen",
+    "minVersion": "0.118.0",
     "installCmd": "npm install -g @openai/codex",
     "isAgent": true,
     "canResume": true,
@@ -41,7 +43,7 @@
       "OTEL_EXPORTER_OTLP_ENDPOINT": "http://localhost:{{port}}",
       "OTEL_LOGS_EXPORT_INTERVAL": "2000"
     },
-    "telemetrySetup": "For best experience, add to ~/.codex/config.toml:\n\n[otel]\nexporter = { otlp-http = { endpoint = \"http://localhost:{{port}}/v1/logs\", protocol = \"json\" } }",
+    "telemetrySetup": "For best experience, add to ~/.codex/config.toml:\n\n[otel]\nexporter = { otlp-http = { endpoint = \"http://localhost:{{port}}\", protocol = \"json\" } }",
     "telemetryAutoSetup": {
       "label": "Configure automatically"
     }
@@ -51,6 +53,7 @@
     "name": "Gemini CLI",
     "icon": "/img/gemini.png",
     "command": "gemini",
+    "minVersion": "0.36.0",
     "installCmd": "npm install -g @google/gemini-cli",
     "isAgent": true,
     "canResume": true,
@@ -58,15 +61,9 @@
     "sessionIdPattern": "Session ID:\\s+([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})",
     "outputMarker": "\u2726",
     "telemetryConfigPath": "~/.gemini/settings.json",
-    "telemetryEnv": {
-      "GEMINI_TELEMETRY_ENABLED": "true",
-      "GEMINI_TELEMETRY_TARGET": "local",
-      "GEMINI_TELEMETRY_OTLP_ENDPOINT": "http://localhost:{{port}}",
-      "GEMINI_TELEMETRY_OTLP_PROTOCOL": "http"
-    },
-    "telemetrySetup": "For best experience, add to ~/.gemini/settings.json:\n\n{\n  \"telemetry\": {\n    \"enabled\": true,\n    \"target\": \"local\",\n    \"otlpEndpoint\": \"http://localhost:{{port}}/v1/logs\",\n    \"otlpProtocol\": \"http\",\n    \"logPrompts\": true\n  }\n}",
+    "telemetrySetup": "Required for working/idle status, resume, Autopilot, notifications, and mobile remote.\n\nCliDeck will add BeforeAgent/AfterAgent/SessionEnd/BeforeTool hooks to ~/.gemini/settings.json.",
     "telemetryAutoSetup": {
-      "label": "Configure automatically"
+      "label": "Patch Gemini"
     }
   },
   {
@@ -74,6 +71,7 @@
     "name": "OpenCode",
     "icon": "/img/opencode.png",
     "command": "opencode",
+    "minVersion": "1.2.26",
     "installCmd": "npm install -g opencode-ai",
     "isAgent": true,
     "canResume": true,

package/bin/claude-hook.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+const http = require('http');
+
+const port = parseInt(process.argv[2], 10);
+const route = process.argv[3];
+if (!port || !route) process.exit(0);
+
+let stdin = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => { stdin += chunk; });
+process.stdin.on('end', () => {
+  let hook = {};
+  try { hook = stdin ? JSON.parse(stdin) : {}; } catch {}
+  const body = JSON.stringify({
+    clideck_id: process.env.CLIDECK_SESSION_ID || '',
+    session_id: hook.session_id || '',
+    payload: stdin.trim() || undefined,
+  });
+  const req = http.request({
+    hostname: 'localhost',
+    port,
+    path: `/hook/claude/${route}`,
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+    timeout: 2000,
+  });
+  req.on('error', () => {});
+  req.end(body);
+});
+process.stdin.resume();

package/bin/gemini-hook.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+const http = require('http');
+
+const port = parseInt(process.argv[2], 10);
+const route = process.argv[3];
+if (!port || !route) process.exit(0);
+
+let stdin = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => { stdin += chunk; });
+process.stdin.on('end', () => {
+  let hook = {};
+  try { hook = stdin ? JSON.parse(stdin) : {}; } catch {}
+  const body = JSON.stringify({
+    clideck_id: process.env.CLIDECK_SESSION_ID || '',
+    session_id: hook.session_id || process.env.GEMINI_SESSION_ID || '',
+    payload: stdin.trim() || undefined,
+  });
+  const req = http.request({
+    hostname: 'localhost',
+    port,
+    path: `/hook/gemini/${route}`,
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+    timeout: 2000,
+  });
+  req.on('error', () => {});
+  req.end(body);
+});
+process.stdin.resume();

package/bin/notify-helper.js

@@ -5,8 +5,15 @@
 // Port is passed as the first argument by the notify config.
 
 const port = parseInt(process.argv[2], 10);
-const payload = process.argv[process.argv.length - 1];
-if (!port || !payload || payload === String(port)) process.exit(0);
+const raw = process.argv[process.argv.length - 1];
+const clideckId = process.env.CLIDECK_SESSION_ID || '';
+if (!port || !raw || raw === String(port)) process.exit(0);
+
+let payload = raw;
+try {
+  const parsed = JSON.parse(raw);
+  payload = JSON.stringify({ ...parsed, clideck_id: clideckId || undefined });
+} catch {}
 
 const http = require('http');
 const req = http.request({

package/codex-config.js

@@ -0,0 +1,77 @@
+function normalizeCodexToml(content) {
+  return String(content || '')
+    .replace(/\r\n/g, '\n')
+    .replace(/([^\n])(\[(?:projects|notice|plugins)\.[^\n]*\])/g, '$1\n$2')
+    .replace(/([^\n])(\[(?:features|otel)\])/g, '$1\n$2')
+    .replace(/([^\n])(\[\[skills\.[^\n]*\]\])/g, '$1\n$2');
+}
+
+function splitTomlSections(content) {
+  const lines = normalizeCodexToml(content).split('\n');
+  const top = [];
+  const sections = [];
+  let current = null;
+  for (const line of lines) {
+    if (/^\s*\[.*\]\s*$/.test(line)) {
+      current = { header: line.trim(), lines: [] };
+      sections.push(current);
+      continue;
+    }
+    if (current) current.lines.push(line);
+    else top.push(line);
+  }
+  return { top, sections };
+}
+
+function trimBlankEdges(lines) {
+  const out = [...lines];
+  while (out.length && !out[0].trim()) out.shift();
+  while (out.length && !out[out.length - 1].trim()) out.pop();
+  return out;
+}
+
+function upsertCodexConfig(content, nodePath, notifyHelperPath, port) {
+  const { top, sections } = splitTomlSections(content);
+  const notifyLine = `notify = ["${nodePath}", "${notifyHelperPath}", "${port}"]`;
+  const cleanedTop = top.filter(line => !/^\s*notify\s*=/.test(line));
+  const topOut = trimBlankEdges([...cleanedTop, notifyLine]);
+  sections.forEach(section => {
+    section.lines = section.lines.filter(line => !/^\s*notify\s*=/.test(line));
+  });
+
+  const keptSections = sections
+    .map(section => section.header === '[features]'
+      ? { ...section, lines: trimBlankEdges(section.lines.filter(line => !/^\s*codex_hooks\s*=/.test(line))) }
+      : section)
+    .filter(section => section.header !== '[features]' || section.lines.length);
+
+  const otelHeader = '[otel]';
+  const otelBody = [`exporter = { otlp-http = { endpoint = "http://localhost:${port}", protocol = "json" } }`];
+  const withoutOtel = keptSections.filter(s => s.header !== otelHeader);
+  withoutOtel.push({ header: otelHeader, lines: otelBody });
+
+  const out = [];
+  if (topOut.length) out.push(...topOut, '');
+  withoutOtel.forEach((section, idx) => {
+    out.push(section.header, ...trimBlankEdges(section.lines));
+    if (idx < withoutOtel.length - 1) out.push('');
+  });
+  return out.join('\n').trimEnd() + '\n';
+}
+
+function validateCodexConfigToml(content) {
+  const lines = normalizeCodexToml(content).split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const t = line.trim();
+    if (!t || t.startsWith('#')) continue;
+    if (/^\[\[.*\]\]$/.test(t) || /^\[.*\]$/.test(t)) continue;
+    if (!t.includes('=')) return { ok: false, error: `Invalid TOML line ${i + 1}: ${t}` };
+    if (/(?:^|[^\s=])\[(?:projects|notice|plugins)\.|(?:^|[^\s=])\[(?:features|otel)\]|(?:^|[^\s=])\[\[skills\./.test(t)) {
+      return { ok: false, error: `Glued TOML headers on line ${i + 1}` };
+    }
+  }
+  return { ok: true };
+}
+
+module.exports = { upsertCodexConfig, validateCodexConfigToml };

package/config.js

@@ -80,8 +80,10 @@ const DEFAULTS = {
     },
   ],
   confirmClose: true,
+  notifyIdle: true,
   notifySoundEnabled: true,
   notifySound: 'soft-beep',
+  notifyMinWork: 0,
   defaultTheme: 'catppuccin-mocha',
   defaultShell,
   prompts: [],

package/handlers.js

@@ -10,6 +10,7 @@ const { listDirs, binName, defaultShell } = require('./utils');
 for (const p of presets) if (p.presetId === 'shell') p.command = defaultShell;
 const transcript = require('./transcript');
 const plugins = require('./plugin-loader');
+const { upsertCodexConfig, validateCodexConfigToml } = require('./codex-config');
 
 const opencodePluginDir = join(
   process.platform === 'win32' ? (process.env.APPDATA || join(os.homedir(), 'AppData', 'Roaming')) : join(os.homedir(), '.config'),
@@ -33,6 +34,28 @@ let remoteUpdateCache = null;
 let remoteUpdateCheckedAt = 0;
 const REMOTE_UPDATE_INTERVAL = 3600000;
 
+function compareVersions(a, b) {
+  const pa = String(a || '').split('.').map(n => parseInt(n, 10) || 0);
+  const pb = String(b || '').split('.').map(n => parseInt(n, 10) || 0);
+  const len = Math.max(pa.length, pb.length);
+  for (let i = 0; i < len; i++) {
+    const diff = (pa[i] || 0) - (pb[i] || 0);
+    if (diff) return diff;
+  }
+  return 0;
+}
+
+function parseVersion(text) {
+  const m = String(text || '').match(/\b(\d+\.\d+\.\d+)\b/);
+  return m ? m[1] : '';
+}
+
+function getInstalledVersion(bin) {
+  try { return parseVersion(execFileSync(bin, ['--version'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] })); } catch {}
+  try { return parseVersion(execFileSync(bin, ['-v'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] })); } catch {}
+  return '';
+}
+
 function checkRemoteUpdate(ws) {
   const now = Date.now();
   if (remoteUpdateCache && now - remoteUpdateCheckedAt < REMOTE_UPDATE_INTERVAL) {
@@ -46,7 +69,7 @@ function checkRemoteUpdate(ws) {
     require('child_process').execFile('npm', ['view', 'clideck-remote', 'version'], { shell: shellOpt, timeout: 10000 }, (err2, stdout2) => {
       if (err2) return;
       const latest = stdout2.trim();
-      remoteUpdateCache = { installed, latest, available: latest !== installed };
+      remoteUpdateCache = { installed, latest, available: compareVersions(latest, installed) > 0 };
       remoteUpdateCheckedAt = now;
       if (remoteUpdateCache.available) ws.send(JSON.stringify({ type: 'remote.update', ...remoteUpdateCache }));
     });
@@ -57,9 +80,20 @@ function checkRemoteUpdate(ws) {
 const whichCmd = process.platform === 'win32' ? 'where' : 'which';
 function checkAvailability() {
   for (const p of presets) {
-    if (p.presetId === 'shell') { p.available = true; continue; }
-    try { execFileSync(whichCmd, [binName(p.command)], { stdio: 'ignore' }); p.available = true; }
-    catch { p.available = false; }
+    if (p.presetId === 'shell') { p.available = true; p.version = ''; p.versionOk = true; p.health = { ok: true }; continue; }
+    const bin = binName(p.command);
+    try {
+      execFileSync(whichCmd, [bin], { stdio: 'ignore' });
+      p.available = true;
+      p.version = getInstalledVersion(bin);
+      p.versionOk = !p.minVersion || (p.version && compareVersions(p.version, p.minVersion) >= 0);
+      p.health = p.versionOk ? { ok: true } : { ok: false, reason: `Update required (${p.minVersion}+)` };
+    } catch {
+      p.available = false;
+      p.version = '';
+      p.versionOk = true;
+      p.health = { ok: false, reason: 'Not installed' };
+    }
   }
 }
 checkAvailability();
@@ -67,43 +101,95 @@ checkAvailability();
 let cfg = config.load();
 if (detectTelemetryConfig(cfg)) config.save(cfg);
 
+function extractQuotedPath(command, needle) {
+  if (!command || !needle) return '';
+  const parts = String(command).match(/"([^"]+)"/g) || [];
+  for (const part of parts) {
+    const value = part.slice(1, -1);
+    if (value.includes(needle)) return value;
+  }
+  return '';
+}
+
+function hasExistingHook(arr, hookFile, route) {
+  return !!arr?.some(h => h.hooks?.some(x => {
+    if (!x.command?.includes(hookFile) || !x.command?.includes(` ${route}`)) return false;
+    const hookPath = extractQuotedPath(x.command, hookFile);
+    return !!hookPath && existsSync(hookPath);
+  }));
+}
+
+function codexConfigLooksHealthy(content, port) {
+  if (!content.includes('[otel]') || !content.includes(`localhost:${port}`)) return false;
+  const notifyLine = content.match(/^\s*notify\s*=\s*\[(.+)\]\s*$/m)?.[1] || '';
+  if (!notifyLine.includes('notify-helper')) return false;
+  const quoted = [...notifyLine.matchAll(/"([^"]+)"/g)].map(m => m[1]);
+  const helperPath = quoted.find(v => v.includes('notify-helper'));
+  return !!helperPath && existsSync(helperPath);
+}
+
 function detectTelemetryConfig(c) {
   const home = os.homedir();
   const port = '4000';
   let changed = false;
+  let repairedAny = false;
   for (const cmd of c.commands || []) {
     const bin = binName(cmd.command);
     const preset = presets.find(p => binName(p.command) === bin);
     if (!preset) continue;
     let detected = false;
+    let reason = '';
     if (preset.presetId === 'claude-code') {
       try {
         const s = JSON.parse(readFileSync(join(home, '.claude', 'settings.json'), 'utf8'));
         const hooks = s.hooks || {};
-        const has = (arr, path) => arr?.some(h => h.hooks?.some(x => x.url?.includes('/hook/claude/' + path)));
-        detected = has(hooks.UserPromptSubmit, 'start') && has(hooks.Stop, 'stop') && has(hooks.StopFailure, 'stop')
-                && has(hooks.PreToolUse, 'menu')
-                && hooks.Notification?.some(h => h.matcher === 'idle_prompt' && h.hooks?.some(x => x.url?.includes('/hook/claude/idle')));
+        detected = hasExistingHook(hooks.UserPromptSubmit, 'claude-hook.js', 'start')
+                && hasExistingHook(hooks.Stop, 'claude-hook.js', 'stop')
+                && hasExistingHook(hooks.StopFailure, 'claude-hook.js', 'stop')
+                && hasExistingHook(hooks.PreToolUse, 'claude-hook.js', 'menu')
+                && hooks.Notification?.some(h => h.matcher === 'idle_prompt' && hasExistingHook([h], 'claude-hook.js', 'idle'));
+        if (!detected) reason = 'Needs re-patch';
       } catch {}
     } else if (preset.presetId === 'codex') {
       try {
         const content = readFileSync(join(home, '.codex', 'config.toml'), 'utf8');
-        detected = content.includes('[otel]') && content.includes(`localhost:${port}`) && content.includes('notify-helper');
+        detected = codexConfigLooksHealthy(content, port);
+        if (!detected) reason = 'Needs re-patch';
       } catch {}
     } else if (preset.presetId === 'gemini-cli') {
       try {
         const s = JSON.parse(readFileSync(join(home, '.gemini', 'settings.json'), 'utf8'));
-        detected = !!s.telemetry?.enabled && (s.telemetry?.otlpEndpoint || '').includes(`localhost:${port}`);
+        const hooks = s.hooks || {};
+        detected = hasExistingHook(hooks.BeforeAgent, 'gemini-hook.js', 'start')
+                && hasExistingHook(hooks.AfterAgent, 'gemini-hook.js', 'stop')
+                && hasExistingHook(hooks.SessionEnd, 'gemini-hook.js', 'stop')
+                && hasExistingHook(hooks.BeforeTool, 'gemini-hook.js', 'menu');
+        if (!detected) reason = 'Needs re-patch';
       } catch {}
     } else if (preset.presetId === 'opencode') {
       detected = existsSync(join(opencodePluginDir, 'clideck-bridge.js')) || existsSync(join(opencodePluginDir, 'termix-bridge.js'));
+      if (!detected) reason = 'Needs re-patch';
     } else { continue; }
-    if (detected !== !!cmd.telemetryEnabled) {
-      cmd.telemetryEnabled = detected;
-      cmd.telemetryStatus = detected ? { ok: true } : null;
+    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) {
+      const repaired = applyTelemetryConfig(preset);
+      if (repaired.success) {
+        repairedAny = true;
+        continue;
+      }
+    }
+    const nextEnabled = detected || (!!cmd.telemetryEnabled && !reason.startsWith('Update required'));
+    const nextStatus = detected ? { ok: true } : { ok: false, error: reason || 'Needs setup' };
+    if (cmd.telemetryEnabled !== nextEnabled || JSON.stringify(cmd.telemetryStatus || null) !== JSON.stringify(nextStatus)) {
+      cmd.telemetryEnabled = nextEnabled;
+      cmd.telemetryStatus = nextStatus;
       changed = true;
     }
+    preset.health = detected ? { ok: true } : { ok: false, reason: reason || 'Needs setup' };
   }
+  if (repairedAny) return detectTelemetryConfig(c) || true;
   if (changed) console.log('Config: synced telemetry/plugin state from detected config files');
   return changed;
 }
@@ -142,10 +228,16 @@ function onConnection(ws) {
         }
         break;
       case 'terminal.buffer': {
-        require('./transcript').storeBuffer(msg.id, msg.lines);
-        sessions.broadcast({ type: 'screen.updated', id: msg.id });
+        const transcript = require('./transcript');
         const sess = sessions.getSessions().get(msg.id);
         if (sess) {
+          if (!sess.working && sess._finalizeOnIdle) {
+            sess._finalizeOnIdle = false;
+            // if (sess.presetId === 'claude-code') {
+            //   console.log(`[claude] terminal.buffer finalize session=${msg.id.slice(0,8)} lines=${msg.lines?.length || 0}`);
+            // }
+            transcript.captureAgentTurn(msg.id, sess.presetId, msg.lines);
+          }
           let choices = require('./transcript').detectMenu(msg.lines, sess.presetId);
           // Codex: only trust menu detection if last OTEL event was response.completed
           if (choices && sess.presetId === 'codex') {
@@ -157,15 +249,31 @@ function onConnection(ws) {
               console.log(`[codex] menu accepted session=${msg.id.slice(0,8)}`);
             }
           }
+          if (choices && sess.presetId === 'claude-code' && msg.menuVersion && (sess._menuConsumedVersion || 0) >= msg.menuVersion) {
+            // console.log(`[claude] menu ignored stale version=${msg.menuVersion} consumed=${sess._menuConsumedVersion || 0} session=${msg.id.slice(0,8)}`);
+            choices = null;
+          }
+          let key = choices ? JSON.stringify(choices) : '';
+          // Claude can keep rendering the same approval menu briefly after Enter.
+          // Once that exact menu was approved, ignore repeated detections of the
+          // same signature until the next real turn starts.
+          if (choices && sess.presetId === 'claude-code' && key === (sess._resolvedMenuKey || '')) {
+            // console.log(`[claude] menu ignored resolved key session=${msg.id.slice(0,8)}`);
+            choices = null;
+            key = '';
+          }
           // Auto-approve: send Enter immediately when menu detected
           if (choices && plugins.shouldAutoApproveMenu(msg.id)) {
-            sessions.input({ id: msg.id, data: '\r' });
+            setTimeout(() => sessions.input({ id: msg.id, data: '\r' }), 500);
           }
-          const key = choices ? JSON.stringify(choices) : '';
           if (key !== (sess._menuKey || '')) {
             sess._menuKey = key;
             sessions.broadcast({ type: 'session.menu', id: msg.id, choices: choices || [] });
             if (choices) {
+              if (sess.presetId === 'claude-code' && msg.menuVersion) sess._menuActiveVersion = msg.menuVersion;
+              // if (sess.presetId === 'claude-code') {
+              //   console.log(`[claude] menu detected session=${msg.id.slice(0,8)} choices=${choices.length} version=${msg.menuVersion || 0}`);
+              // }
               plugins.notifyMenu(msg.id, choices);
               if (sess.presetId === 'codex') require('./telemetry-receiver').cancelCodexMenuPoll(msg.id);
               sessions.broadcast({ type: 'session.status', id: msg.id, working: false, source: 'menu' });
@@ -184,6 +292,7 @@ function onConnection(ws) {
 
       case 'checkAvailability':
         checkAvailability();
+        if (detectTelemetryConfig(cfg)) config.save(cfg);
         ws.send(JSON.stringify({ type: 'presets', presets }));
         break;
 
@@ -275,6 +384,7 @@ function onConnection(ws) {
         }
         cfg.projects = cfg.projects.filter(p => p.id !== msg.id);
         config.save(cfg);
+        plugins.notifyConfig(cfg);
         sessions.broadcast({ type: 'config', config: configForClient() });
         break;
       }
@@ -369,8 +479,7 @@ function onConnection(ws) {
       }
 
       case 'remote.getHistory': {
-        const turns = transcript.getScreenTurns(msg.id, sessions.getSessions().get(msg.id)?.presetId);
-        ws.send(JSON.stringify({ type: 'remote.history', id: msg.id, turns: turns || [] }));
+        ws.send(JSON.stringify({ type: 'remote.history', id: msg.id, turns: transcript.getLastTurns(msg.id, 20) }));
         break;
       }
 
@@ -409,17 +518,23 @@ function applyTelemetryConfig(preset) {
         try { settings = JSON.parse(readFileSync(configPath, 'utf8')); } catch {}
       }
       const hooks = settings.hooks || {};
-      const endpoint = `http://localhost:${port}/hook/claude`;
-      const clideckHook = (url) => ({ hooks: [{ type: 'http', url }] });
-      const hasClideck = (arr, path) => arr?.some(h => h.hooks?.some(x => x.url?.includes('/hook/claude/' + path)));
-      if (hasClideck(hooks.UserPromptSubmit, 'start') && hasClideck(hooks.Stop, 'stop') && hasClideck(hooks.StopFailure, 'stop') && hasClideck(hooks.PreToolUse, 'menu') && hooks.Notification?.some(h => h.matcher === 'idle_prompt' && h.hooks?.some(x => x.url?.includes('/hook/claude/idle')))) {
+      const hookCmd = (route) => `"${process.execPath.replace(/\\/g, '/')}" "${join(__dirname, 'bin', 'claude-hook.js').replace(/\\/g, '/')}" ${port} ${route}`;
+      const clideckHook = (route) => ({ hooks: [{ type: 'command', command: hookCmd(route) }] });
+      const hasClideck = (arr, path) => arr?.some(h => h.hooks?.some(x => x.command === hookCmd(path)));
+      if (hasClideck(hooks.UserPromptSubmit, 'start') && hasClideck(hooks.Stop, 'stop') && hasClideck(hooks.StopFailure, 'stop') && hasClideck(hooks.PreToolUse, 'menu') && hooks.Notification?.some(h => h.matcher === 'idle_prompt' && h.hooks?.some(x => x.command === hookCmd('idle')))) {
         return { success: true, message: 'Already configured' };
       }
-      if (!hasClideck(hooks.UserPromptSubmit, 'start')) hooks.UserPromptSubmit = [...(hooks.UserPromptSubmit || []), clideckHook(`${endpoint}/start`)];
-      if (!hasClideck(hooks.Stop, 'stop')) hooks.Stop = [...(hooks.Stop || []), clideckHook(`${endpoint}/stop`)];
-      if (!hasClideck(hooks.StopFailure, 'stop')) hooks.StopFailure = [...(hooks.StopFailure || []), clideckHook(`${endpoint}/stop`)];
-      if (!hasClideck(hooks.Notification, 'idle')) hooks.Notification = [...(hooks.Notification || []), { matcher: 'idle_prompt', ...clideckHook(`${endpoint}/idle`) }];
-      if (!hasClideck(hooks.PreToolUse, 'menu')) hooks.PreToolUse = [...(hooks.PreToolUse || []), clideckHook(`${endpoint}/menu`)];
+      const stripOld = (arr) => (arr || []).filter(h => !h.hooks?.some(x => x.url?.includes('/hook/claude/') || x.command?.includes('claude-hook.js')));
+      hooks.UserPromptSubmit = stripOld(hooks.UserPromptSubmit);
+      hooks.Stop = stripOld(hooks.Stop);
+      hooks.StopFailure = stripOld(hooks.StopFailure);
+      hooks.PreToolUse = stripOld(hooks.PreToolUse);
+      hooks.Notification = stripOld(hooks.Notification);
+      if (!hasClideck(hooks.UserPromptSubmit, 'start')) hooks.UserPromptSubmit = [...(hooks.UserPromptSubmit || []), clideckHook('start')];
+      if (!hasClideck(hooks.Stop, 'stop')) hooks.Stop = [...(hooks.Stop || []), clideckHook('stop')];
+      if (!hasClideck(hooks.StopFailure, 'stop')) hooks.StopFailure = [...(hooks.StopFailure || []), clideckHook('stop')];
+      if (!hasClideck(hooks.Notification, 'idle')) hooks.Notification = [...(hooks.Notification || []), { matcher: 'idle_prompt', ...clideckHook('idle') }];
+      if (!hasClideck(hooks.PreToolUse, 'menu')) hooks.PreToolUse = [...(hooks.PreToolUse || []), clideckHook('menu')];
       settings.hooks = hooks;
       mkdirSync(dirname(configPath), { recursive: true });
       writeFileSync(configPath, JSON.stringify(settings, null, 2) + '\n');
@@ -428,27 +543,22 @@ function applyTelemetryConfig(preset) {
 
     if (preset.presetId === 'codex') {
       const configPath = join(home, '.codex', 'config.toml');
+      const hooksPath = join(home, '.codex', 'hooks.json');
       let content = '';
       if (existsSync(configPath)) content = readFileSync(configPath, 'utf8');
       const hasOtel = content.includes('[otel]');
-      const hasNotify = content.includes('notify-helper');
-      if (hasOtel && hasNotify) return { success: true, message: 'Already configured' };
-      if (!hasNotify) {
-        const helperPath = join(__dirname, 'bin', 'notify-helper.js').replace(/\\/g, '/');
-        const notifyLine = `notify = ["${process.execPath.replace(/\\/g, '/')}", "${helperPath}", "${port}"]\n`;
-        // Insert before the first [section] so it stays top-level
-        const firstSection = content.search(/^\[/m);
-        if (firstSection >= 0) {
-          content = content.slice(0, firstSection) + notifyLine + '\n' + content.slice(firstSection);
-        } else {
-          content = content + '\n' + notifyLine;
-        }
-      }
-      if (!hasOtel) {
-        content = content.trimEnd() + `\n\n[otel]\nexporter = { otlp-http = { endpoint = "http://localhost:${port}/v1/logs", protocol = "json" } }\n`;
+      const hasNotify = /^\s*notify\s*=.*notify-helper/m.test(content);
+      const hasWrongOtel = content.includes(`endpoint = "http://localhost:${port}/v1/logs"`);
+      if (hasOtel && hasNotify && !hasWrongOtel && !existsSync(hooksPath) && !/(^|\n)\[features\][\s\S]*?codex_hooks\s*=/.test(content)) {
+        return { success: true, message: 'Already configured' };
       }
+      const notifyHelperPath = join(__dirname, 'bin', 'notify-helper.js').replace(/\\/g, '/');
+      const nextContent = upsertCodexConfig(content, process.execPath.replace(/\\/g, '/'), notifyHelperPath, port);
+      const valid = validateCodexConfigToml(nextContent);
+      if (!valid.ok) return { success: false, message: valid.error };
       mkdirSync(dirname(configPath), { recursive: true });
-      writeFileSync(configPath, content);
+      writeFileSync(configPath, nextContent);
+      if (existsSync(hooksPath)) try { unlinkSync(hooksPath); } catch {}
       return { success: true, message: 'Added otel + notify to ~/.codex/config.toml' };
     }
 
@@ -458,20 +568,26 @@ function applyTelemetryConfig(preset) {
       if (existsSync(configPath)) {
         try { settings = JSON.parse(readFileSync(configPath, 'utf8')); } catch {}
       }
-      if (settings.telemetry?.enabled && settings.telemetry?.otlpEndpoint) {
+      const hooks = settings.hooks || {};
+      const helperPath = join(__dirname, 'bin', 'gemini-hook.js').replace(/\\/g, '/');
+      const nodePath = process.execPath.replace(/\\/g, '/');
+      const geminiHook = (route) => ({
+        matcher: '*',
+        hooks: [{ type: 'command', command: `"${nodePath}" "${helperPath}" ${port} ${route}`, name: `clideck-${route}`, timeout: 5000 }],
+      });
+      const has = (arr, route) => arr?.some(h => h.hooks?.some(x => x.command?.includes('gemini-hook.js') && x.command?.includes(` ${route}`)));
+      if (has(hooks.BeforeAgent, 'start') && has(hooks.AfterAgent, 'stop') && has(hooks.SessionEnd, 'stop') && has(hooks.BeforeTool, 'menu')) {
         return { success: true, message: 'Already configured' };
       }
-      settings.telemetry = {
-        ...settings.telemetry,
-        enabled: true,
-        target: 'local',
-        otlpEndpoint: `http://localhost:${port}/v1/logs`,
-        otlpProtocol: 'http',
-        logPrompts: true,
-      };
+      if (!has(hooks.BeforeAgent, 'start')) hooks.BeforeAgent = [...(hooks.BeforeAgent || []), geminiHook('start')];
+      if (!has(hooks.AfterAgent, 'stop')) hooks.AfterAgent = [...(hooks.AfterAgent || []), geminiHook('stop')];
+      if (!has(hooks.SessionEnd, 'stop')) hooks.SessionEnd = [...(hooks.SessionEnd || []), geminiHook('stop')];
+      if (!has(hooks.BeforeTool, 'menu')) hooks.BeforeTool = [...(hooks.BeforeTool || []), geminiHook('menu')];
+      settings.hooks = hooks;
+      if (settings.telemetry?.target === 'local' && String(settings.telemetry?.otlpEndpoint || '').includes(`localhost:${port}`)) delete settings.telemetry;
       mkdirSync(dirname(configPath), { recursive: true });
       writeFileSync(configPath, JSON.stringify(settings, null, 2) + '\n');
-      return { success: true, message: 'Added telemetry section to ~/.gemini/settings.json' };
+      return { success: true, message: 'Added CliDeck hooks to ~/.gemini/settings.json' };
     }
 
     if (preset.presetId === 'opencode') {
@@ -503,7 +619,7 @@ function removeTelemetryConfig(preset) {
       for (const event of ['UserPromptSubmit', 'Stop', 'StopFailure', 'Notification', 'PreToolUse']) {
         const arr = settings.hooks[event];
         if (!arr) continue;
-        settings.hooks[event] = arr.filter(h => !h.hooks?.some(x => x.url?.includes('/hook/claude/')));
+        settings.hooks[event] = arr.filter(h => !h.hooks?.some(x => x.url?.includes('/hook/claude/') || x.command?.includes('claude-hook.js')));
         if (!settings.hooks[event].length) delete settings.hooks[event];
       }
       if (!Object.keys(settings.hooks).length) delete settings.hooks;
@@ -517,8 +633,11 @@ function removeTelemetryConfig(preset) {
       let content = readFileSync(configPath, 'utf8');
       content = content.replace(/\n?\[otel\][^\[]*/, '');
       content = content.replace(/\n?notify\s*=\s*\[.*?notify-helper.*?\]\s*/g, '');
+      content = content.replace(/\n?codex_hooks\s*=\s*(true|false)\s*/g, '\n');
       writeFileSync(configPath, content.trimEnd() + '\n');
-      return { success: true, message: 'Removed otel + notify from ~/.codex/config.toml' };
+      const hooksPath = join(home, '.codex', 'hooks.json');
+      if (existsSync(hooksPath)) try { unlinkSync(hooksPath); } catch {}
+      return { success: true, message: 'Removed otel + notify from ~/.codex config' };
     }
 
     if (preset.presetId === 'gemini-cli') {
@@ -526,9 +645,16 @@ function removeTelemetryConfig(preset) {
       if (!existsSync(configPath)) return { success: true, message: 'No config file to clean' };
       let settings = {};
       try { settings = JSON.parse(readFileSync(configPath, 'utf8')); } catch {}
-      delete settings.telemetry;
+      for (const event of ['BeforeAgent', 'AfterAgent', 'SessionEnd', 'BeforeTool']) {
+        const arr = settings.hooks?.[event];
+        if (!arr) continue;
+        settings.hooks[event] = arr.filter(h => !h.hooks?.some(x => x.command?.includes('gemini-hook.js')));
+        if (!settings.hooks[event].length) delete settings.hooks[event];
+      }
+      if (settings.hooks && !Object.keys(settings.hooks).length) delete settings.hooks;
+      if (settings.telemetry?.target === 'local' && String(settings.telemetry?.otlpEndpoint || '').includes('localhost:4000')) delete settings.telemetry;
       writeFileSync(configPath, JSON.stringify(settings, null, 2) + '\n');
-      return { success: true, message: 'Removed telemetry section from ~/.gemini/settings.json' };
+      return { success: true, message: 'Removed CliDeck hooks from ~/.gemini/settings.json' };
     }
 
     if (preset.presetId === 'opencode') {