clideck 1.31.16 → 1.31.18

package/README.md

@@ -18,9 +18,9 @@
   <img src="assets/clideck-themes.jpg" width="720" alt="clideck dashboard">
 </p>
 
-clideck is a local app for running multiple AI coding agents without juggling terminals. Claude Code, Codex, Gemini CLI, and OpenCode all live in one browser window with a chat-style sidebar, live status, message previews, session resume, and projects to keep things organized. an autopilot routes work between agents automatically, and an E2E encrypted mobile relay gives full control over all agents from a phone.
+clideck is a local app for running multiple AI coding agents without juggling terminals. Claude Code, Codex, Gemini CLI, OpenCode, and Pi all live in one browser window with a chat-style sidebar, live status, message previews, session resume, and projects to keep things organized. an autopilot routes work between agents automatically, and an E2E encrypted mobile relay gives full control over all agents from a phone.
 
-the main problem with using multiple agents is not starting them. it is managing them. terminals pile up, finished work gets missed, good sessions disappear after a restart. clideck does not sit in the middle rewriting prompts or output - it only watches lightweight status signals (OpenTelemetry) so it can tell which agent is working, which is idle, and which is waiting. everything runs locally, no data leaves your machine.
+the main problem with using multiple agents is not starting them. it is managing them. terminals pile up, finished work gets missed, good sessions disappear after a restart. clideck does not sit in the middle rewriting prompts or output - it only watches lightweight status signals from each agent so it can tell which agent is working, which is idle, and which is waiting. everything runs locally, no data leaves your machine.
 
 ## Why this exists
 
@@ -47,7 +47,7 @@ clideck --port 4001
 
 ## What makes it useful
 
-**Live status** - see which agent is working and which is waiting. Status detection for Claude Code, Codex, Gemini CLI, and OpenCode.
+**Live status** - see which agent is working and which is waiting. Status detection for Claude Code, Codex, Gemini CLI, OpenCode, and Pi.
 
 **Session resume** - close the lid, reopen tomorrow, pick up where things left off. each agent's session ID is captured automatically.
 
@@ -79,7 +79,7 @@ If project or session names contain spaces, quote the whole target. The target i
 
 ## Supported agents
 
-Claude Code, Codex, Gemini CLI, OpenCode, Shell, and any other terminal tool.
+Claude Code, Codex, Gemini CLI, OpenCode, Pi, Shell, and any other terminal tool.
 
 ## Also
 

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/agent-presets.json

@@ -12,7 +12,7 @@
     "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": "⏺",
     "telemetryConfigPath": "~/.claude/settings.json",
-    "telemetrySetup": "Required for working/idle status, Autopilot, notifications, and mobile remote.\n\nCliDeck will add start/stop hooks to ~/.claude/settings.json. Claude will ask for one-time approval on next launch.",
+    "telemetrySetup": "Required for working/idle status, Autopilot, notifications, and mobile remote.\n\nCliDeck will add lifecycle hooks to ~/.claude/settings.json. Claude will ask for one-time approval on next launch.",
     "telemetryAutoSetup": {
       "label": "Patch Claude"
     },
@@ -85,6 +85,24 @@
       "label": "Install plugin"
     }
   },
+  {
+    "presetId": "pi",
+    "name": "Pi",
+    "icon": "/img/pi.svg",
+    "command": "pi",
+    "minVersion": "0.79.3",
+    "installCmd": "npm install -g --ignore-scripts @earendil-works/pi-coding-agent",
+    "isAgent": true,
+    "canResume": true,
+    "resumeCommand": "pi --session {{sessionId}}",
+    "sessionIdPattern": null,
+    "outputMarker": "•",
+    "telemetryConfigPath": "~/.pi/agent/extensions/clideck-bridge.ts",
+    "telemetrySetup": "Required for working/idle status, resume, Autopilot, notifications, and mobile remote.\n\nCliDeck will install a small Pi extension to ~/.pi/agent/extensions/clideck-bridge.ts.",
+    "telemetryAutoSetup": {
+      "label": "Install extension"
+    }
+  },
   {
     "presetId": "clideck-agent",
     "name": "Clideck Agent",

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/bin/claude-hook.js

@@ -15,6 +15,9 @@ process.stdin.on('end', () => {
   const body = JSON.stringify({
     clideck_id: process.env.CLIDECK_SESSION_ID || '',
     session_id: hook.session_id || '',
+    hook_event_name: hook.hook_event_name || '',
+    source: hook.source || '',
+    reason: hook.reason || '',
     payload: stdin.trim() || undefined,
   });
   const req = http.request({

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) {
@@ -20,7 +21,11 @@ function clientPresets() {
 function filterClientCommands(commands) {
   const allowedPresetIds = new Set(clientPresets().map(p => p.presetId));
   const knownPresetIds = new Set(presets.map(p => p.presetId));
-  return (commands || []).filter(cmd => !cmd.presetId || allowedPresetIds.has(cmd.presetId) || !knownPresetIds.has(cmd.presetId));
+  return (commands || []).filter(cmd => {
+    if (cmd.presetId && !allowedPresetIds.has(cmd.presetId) && knownPresetIds.has(cmd.presetId)) return false;
+    const preset = cmd.presetId ? presets.find(p => p.presetId === cmd.presetId) : null;
+    return !(preset?.available === false && String(cmd.command || '').trim() === String(preset.command || '').trim());
+  });
 }
 const transcript = require('./transcript');
 const plugins = require('./plugin-loader');
@@ -72,15 +77,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,10 +93,11 @@ 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');
+  if (preset?.presetId === 'pi') return expandHomePath(env.PI_CODING_AGENT_DIR) || join(os.homedir(), '.pi', 'agent');
   return os.homedir();
 }
 
@@ -177,6 +178,14 @@ function hasExistingHook(arr, hookFile, route) {
   }));
 }
 
+function hasAnyExistingHook(hooks, hookFile) {
+  return Object.values(hooks || {}).some(arr => arr?.some(h => h.hooks?.some(x => {
+    if (!x.command?.includes(hookFile)) return false;
+    const hookPath = extractQuotedPath(x.command, hookFile);
+    return !!hookPath && existsSync(hookPath);
+  })));
+}
+
 function codexHooksFeatureEnabled(content) {
   let inFeatures = false;
   for (const line of String(content || '').split(/\r?\n/)) {
@@ -215,6 +224,23 @@ function opencodeBridgeLooksHealthy() {
   }
 }
 
+function piBridgePath(cmd) {
+  return join(configRootFor({ presetId: 'pi' }, cmd), 'extensions', 'clideck-bridge.ts');
+}
+
+function piBridgeLooksHealthy(cmd) {
+  const bridgePath = piBridgePath(cmd);
+  if (!existsSync(bridgePath)) return false;
+  try {
+    const content = readFileSync(bridgePath, 'utf8');
+    return content.includes('/hook/pi')
+      && content.includes('CLIDECK_SESSION_ID')
+      && content.includes('sessionManager.getSessionId');
+  } catch {
+    return false;
+  }
+}
+
 function detectTelemetryConfig(c) {
   const port = String(PORT);
   let changed = false;
@@ -227,15 +253,23 @@ function detectTelemetryConfig(c) {
       if (!preset) continue;
       let detected = false;
       let reason = '';
+      let repairAllowed = cmd.telemetrySetupConsent === true;
       if (preset.presetId === 'claude-code') {
         try {
           const s = JSON.parse(readFileSync(join(configRootFor(preset, cmd), 'settings.json'), 'utf8'));
           const hooks = s.hooks || {};
+          repairAllowed = repairAllowed || hasAnyExistingHook(hooks, 'claude-hook.js');
           detected = hasExistingHook(hooks.UserPromptSubmit, 'claude-hook.js', 'start')
                   && hasExistingHook(hooks.Stop, 'claude-hook.js', 'stop')
                   && hasExistingHook(hooks.StopFailure, 'claude-hook.js', 'stop')
+                  && hasExistingHook(hooks.SessionStart, 'claude-hook.js', 'session-start')
+                  && hasExistingHook(hooks.SessionEnd, 'claude-hook.js', 'session-end')
                   && hasExistingHook(hooks.PreToolUse, 'claude-hook.js', 'menu')
                   && hooks.Notification?.some(h => h.matcher === 'idle_prompt' && hasExistingHook([h], 'claude-hook.js', 'idle'));
+          if (detected && cmd.telemetrySetupConsent !== true) {
+            cmd.telemetrySetupConsent = true;
+            changed = true;
+          }
           if (!detected) reason = 'Needs re-patch';
         } catch {}
       } else if (preset.presetId === 'codex') {
@@ -258,11 +292,14 @@ function detectTelemetryConfig(c) {
       } else if (preset.presetId === 'opencode') {
         detected = opencodeBridgeLooksHealthy();
         if (!detected) reason = 'Needs re-patch';
+      } else if (preset.presetId === 'pi') {
+        detected = piBridgeLooksHealthy(cmd);
+        if (!detected) reason = 'Needs re-patch';
       } else { continue; }
       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 && repairAllowed && 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) {
@@ -368,6 +405,7 @@ function onConnection(ws) {
           if (choices) transcript.commitAgentCandidate(msg.id, sess.presetId);
           if (key !== (sess._menuKey || '')) {
             sess._menuKey = key;
+            sess._menuStartsWork = !(sess.presetId === 'claude-code' && !msg.menuVersion);
             sessions.broadcast({ type: 'session.menu', id: msg.id, choices: choices || [] });
             if (choices) {
               if (sess.presetId === 'claude-code' && msg.menuVersion) sess._menuActiveVersion = msg.menuVersion;
@@ -391,6 +429,7 @@ function onConnection(ws) {
         checkAvailability();
         if (detectTelemetryConfig(cfg)) config.save(cfg);
         ws.send(JSON.stringify({ type: 'presets', presets: clientPresets() }));
+        ws.send(JSON.stringify({ type: 'config', config: configForClient() }));
         break;
 
       case 'config.update':
@@ -399,6 +438,7 @@ function onConnection(ws) {
         cfg = { ...cfg, ...msg.config };
         detectTelemetryConfig(cfg);
         config.save(cfg);
+        plugins.notifyConfig(cfg);
         sessions.broadcast({ type: 'config', config: configForClient() });
         break;
 
@@ -412,16 +452,28 @@ function onConnection(ws) {
         const targetCmd = msg.commandId ? cfg.commands.find(c => c.id === msg.commandId) : null;
         const preset = targetCmd ? presetForCommand(targetCmd) : presets.find(p => p.presetId === msg.presetId);
         if (!preset?.telemetryAutoSetup) break;
+        if (preset.available === false) {
+          ws.send(JSON.stringify({
+            type: 'telemetry.autosetup.result',
+            presetId: preset.presetId,
+            commandId: msg.commandId || null,
+            success: false,
+            output: `${preset.name} is not installed`,
+          }));
+          break;
+        }
         const result = applyTelemetryConfig(preset, targetCmd);
         for (const cmd of cfg.commands) {
           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 +500,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 +713,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 +721,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) => {
@@ -707,18 +762,28 @@ function applyTelemetryConfig(preset, cmd = null) {
       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')))) {
+      if (hasClideck(hooks.UserPromptSubmit, 'start')
+          && hasClideck(hooks.Stop, 'stop')
+          && hasClideck(hooks.StopFailure, 'stop')
+          && hasClideck(hooks.SessionStart, 'session-start')
+          && hasClideck(hooks.SessionEnd, 'session-end')
+          && 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' };
       }
       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.SessionStart = stripOld(hooks.SessionStart);
+      hooks.SessionEnd = stripOld(hooks.SessionEnd);
       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.SessionStart, 'session-start')) hooks.SessionStart = [...(hooks.SessionStart || []), clideckHook('session-start')];
+      if (!hasClideck(hooks.SessionEnd, 'session-end')) hooks.SessionEnd = [...(hooks.SessionEnd || []), clideckHook('session-end')];
       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;
@@ -795,6 +860,14 @@ function applyTelemetryConfig(preset, cmd = null) {
       return { success: true, message: `Installed bridge plugin to ${opencodePluginDir}` };
     }
 
+    if (preset.presetId === 'pi') {
+      const src = join(__dirname, 'pi-extension', 'clideck-bridge.ts');
+      const dest = piBridgePath(cmd);
+      mkdirSync(dirname(dest), { recursive: true });
+      copyFileSync(src, dest);
+      return { success: true, message: `Installed Pi extension to ${dest}` };
+    }
+
     return { success: false, message: `No auto-setup for ${preset.presetId}` };
   } catch (err) {
     return { success: false, message: err.message };
@@ -809,7 +882,7 @@ function removeTelemetryConfig(preset, cmd = null) {
       let settings = {};
       try { settings = JSON.parse(readFileSync(configPath, 'utf8')); } catch {}
       if (!settings.hooks) return { success: true, message: 'No hooks to remove' };
-      for (const event of ['UserPromptSubmit', 'Stop', 'StopFailure', 'Notification', 'PreToolUse']) {
+      for (const event of ['UserPromptSubmit', 'Stop', 'StopFailure', 'SessionStart', 'SessionEnd', '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/') || x.command?.includes('claude-hook.js')));
@@ -856,6 +929,11 @@ function removeTelemetryConfig(preset, cmd = null) {
       return { success: true, message: 'Removed bridge plugin' };
     }
 
+    if (preset.presetId === 'pi') {
+      try { unlinkSync(piBridgePath(cmd)); } catch {}
+      return { success: true, message: 'Removed Pi extension' };
+    }
+
     return { success: false, message: `No removal logic for ${preset.presetId}` };
   } catch (err) {
     return { success: false, message: err.message };

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.18",
   "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/pi-bridge.js

@@ -0,0 +1,51 @@
+// Pi bridge — receives lifecycle events from the CliDeck Pi extension.
+
+let broadcastFn = null;
+let sessionsFn = null;
+
+function init(broadcast, getSessions) {
+  broadcastFn = broadcast;
+  sessionsFn = getSessions;
+}
+
+function findByToken(token) {
+  if (!token) return null;
+  for (const [id, session] of sessionsFn?.() || []) {
+    if (session.sessionToken === token) return id;
+  }
+  return null;
+}
+
+function capture(id) {
+  setTimeout(() => broadcastFn?.({ type: 'terminal.capture', id }), 500);
+}
+
+function handleEvent(payload) {
+  if (!payload || !payload.event) return;
+  const sessions = sessionsFn?.();
+  if (!sessions) return;
+
+  const clideckId = payload.clideck_id && sessions.has(payload.clideck_id)
+    ? payload.clideck_id
+    : findByToken(payload.session_id);
+  if (!clideckId) return;
+
+  const session = sessions.get(clideckId);
+  if (session && payload.session_id && payload.event !== 'session_shutdown') {
+    session.sessionToken = payload.session_id;
+  }
+
+  if (payload.event === 'agent_start') {
+    broadcastFn?.({ type: 'session.status', id: clideckId, working: true, source: 'hook' });
+    return;
+  }
+
+  if (payload.event === 'agent_end' || payload.event === 'session_start' || payload.event === 'session_shutdown') {
+    broadcastFn?.({ type: 'session.status', id: clideckId, working: false, source: 'hook' });
+    capture(clideckId);
+  }
+}
+
+function clear() {}
+
+module.exports = { init, handleEvent, clear };

package/pi-extension/clideck-bridge.ts

@@ -0,0 +1,34 @@
+// CliDeck bridge extension for Pi.
+// Pi auto-loads this file from ~/.pi/agent/extensions/.
+
+const env = globalThis.process?.env || {};
+const baseUrl = env.CLIDECK_URL || `http://localhost:${env.CLIDECK_PORT || "4000"}`;
+const endpoint = `${baseUrl.replace(/\/$/, "")}/hook/pi`;
+
+function safeCall(fn: (() => string | undefined) | undefined): string | undefined {
+  try { return fn?.(); } catch { return undefined; }
+}
+
+function post(event: any, ctx: any): void {
+  const payload = {
+    event: event?.type || "",
+    reason: event?.reason || "",
+    clideck_id: env.CLIDECK_SESSION_ID || "",
+    session_id: safeCall(() => ctx.sessionManager.getSessionId()) || "",
+    session_file: safeCall(() => ctx.sessionManager.getSessionFile()) || "",
+    cwd: ctx?.cwd || "",
+  };
+
+  fetch(endpoint, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload),
+  }).catch(() => {});
+}
+
+export default function (pi: any): void {
+  pi.on("session_start", (event: any, ctx: any) => post(event, ctx));
+  pi.on("session_shutdown", (event: any, ctx: any) => post(event, ctx));
+  pi.on("agent_start", (event: any, ctx: any) => post(event, ctx));
+  pi.on("agent_end", (event: any, ctx: any) => post(event, ctx));
+}

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/img/pi.svg

@@ -0,0 +1,13 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-label="Pi">
+  <defs>
+    <linearGradient id="pi-bg" x1="10" y1="8" x2="56" y2="58" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#2dd4bf"/>
+      <stop offset="0.5" stop-color="#60a5fa"/>
+      <stop offset="1" stop-color="#a78bfa"/>
+    </linearGradient>
+  </defs>
+  <rect width="64" height="64" rx="18" fill="#0f172a"/>
+  <path d="M15 20.5c5.4-2.6 11.5-3.9 18.3-3.9 6.1 0 11.4 1.1 15.9 3.2" fill="none" stroke="url(#pi-bg)" stroke-width="5.5" stroke-linecap="round"/>
+  <path d="M24 23.5v22M40 23.5v22" fill="none" stroke="#f8fafc" stroke-width="5.5" stroke-linecap="round"/>
+  <path d="M17 45.5h30" fill="none" stroke="url(#pi-bg)" stroke-width="5.5" stroke-linecap="round"/>
+</svg>

package/public/index.html

@@ -236,7 +236,10 @@
       <div class="px-2.5 pb-2.5 flex flex-col gap-2">
         <div class="relative">
           <svg class="absolute left-2.5 top-1/2 -translate-y-1/2 w-4 h-4 text-slate-500 pointer-events-none" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="11" cy="11" r="8"/><path d="m21 21-4.35-4.35"/></svg>
-          <input id="search-input" type="text" placeholder="Search" class="w-full pl-9 pr-3 py-[7px] text-[13px] bg-slate-800/50 rounded-full text-slate-300 placeholder-slate-600 outline-none border border-transparent focus:border-slate-600/60 focus:bg-slate-800/80 transition-all">
+          <input id="search-input" type="text" placeholder="Search" class="w-full pl-9 pr-9 py-[7px] text-[13px] bg-slate-800/50 rounded-full text-slate-300 placeholder-slate-600 outline-none border border-transparent focus:border-slate-600/60 focus:bg-slate-800/80 transition-all">
+          <button id="search-clear" class="hidden absolute right-3 top-1/2 -translate-y-1/2 w-6 h-6 rounded-full border border-slate-700/40 bg-slate-800/40 text-slate-500 hover:text-slate-200 hover:bg-slate-700/60 transition-all flex items-center justify-center" title="Clear search" aria-label="Clear search">
+            <svg class="w-3.5 h-3.5" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2.4" stroke-linecap="round"><path d="M18 6 6 18M6 6l12 12"/></svg>
+          </button>
         </div>
         <div class="flex bg-slate-800/30 rounded-lg p-[3px]">
           <button class="filter-tab flex-1 text-[11px] font-medium py-[5px] rounded-md transition-all bg-slate-700/60 text-slate-200" data-tab="all">All</button>