clideck 1.25.8 → 1.26.2

package/sessions.js

@@ -29,7 +29,11 @@ function addBroadcastListener(fn) { broadcastListeners.push(fn); }
 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') plugins.notifyStatus(msg.id, msg.working);
+  if (msg.type === 'session.status') {
+    const s = sessions.get(msg.id);
+    if (s) s.working = !!msg.working;
+    plugins.notifyStatus(msg.id, msg.working, msg.source);
+  }
   for (const fn of broadcastListeners) try { fn(msg); } catch {}
 }
 
@@ -74,7 +78,7 @@ function spawnSession(id, cmd, parts, cwd, name, themeId, commandId, savedToken,
   const sessionIdRe = cmd.sessionIdPattern ? new RegExp(cmd.sessionIdPattern, 'i') : null;
   const bin = binName(cmd.command);
   const preset = PRESETS.find(p => binName(p.command) === bin);
-  const session = { name, themeId, commandId, cwd, pty: term, chunks: [], chunksSize: 0, sessionToken: savedToken || null, projectId: projectId || null, presetId: preset?.presetId || 'shell' };
+  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);
 
   // Watch for telemetry — if config isn't set up, frontend will prompt
@@ -82,6 +86,18 @@ function spawnSession(id, cmd, parts, cwd, name, themeId, commandId, savedToken,
   if (preset?.bridge === 'opencode') opencodeBridge.watchSession(id, cwd);
 
   term.onData((data) => {
+    // Inject role prompt once after agent starts producing output
+    if (session.pendingRolePrompt && !session._rolePromptTimer) {
+      session._rolePromptTimer = setTimeout(() => {
+        if (session.pendingRolePrompt) {
+          term.write(session.pendingRolePrompt);
+          setTimeout(() => term.write('\r'), 150);
+          console.log(`Session ${id.slice(0, 8)}: injected role prompt`);
+          delete session.pendingRolePrompt;
+          delete session._rolePromptTimer;
+        }
+      }, 3000);
+    }
     session.chunks.push(data);
     session.chunksSize += data.length;
     while (session.chunksSize > MAX_BUFFER && session.chunks.length > 1) {
@@ -104,14 +120,30 @@ function spawnSession(id, cmd, parts, cwd, name, themeId, commandId, savedToken,
 
   term.onExit(() => {
     // Skip cleanup if this PTY was replaced by a restart
-    if (sessions.get(id)?.pty !== term) return;
+    const s = sessions.get(id);
+    if (s?.pty !== term) return;
     activity.clear(id);
     telemetry.clear(id);
     opencodeBridge.clear(id);
-    transcript.clear(id);
     plugins.clearStatus(id);
+    // If resumable and token captured, move to resumable list (keep transcript for search)
+    if (!s.ephemeral && cmd.canResume && cmd.resumeCommand && s.sessionToken) {
+      resumable.push({
+        id, name: s.name, commandId: s.commandId, presetId: s.presetId || 'shell', cwd: s.cwd,
+        themeId: s.themeId, sessionToken: s.sessionToken, projectId: s.projectId, muted: !!s.muted,
+        roleName: s.roleName || null,
+        lastPreview: s.lastPreview || '', lastActivityAt: s.lastActivityAt || null,
+        savedAt: new Date().toISOString(),
+      });
+      console.log(`Session ${id.slice(0, 8)}: moved to resumable on exit (token: ${s.sessionToken.slice(0, 12)}…)`);
+    } else {
+      transcript.clear(id);
+    }
     sessions.delete(id);
     broadcast({ type: 'closed', id });
+    if (!s.ephemeral && cmd.canResume && s.sessionToken) {
+      broadcast({ type: 'sessions.resumable', list: getResumable() });
+    }
   });
 
   return null;
@@ -137,6 +169,18 @@ function create(msg, ws, cfg) {
     return;
   }
 
+  // If a role was selected, store identity on session and queue prompt injection
+  if (msg.roleId) {
+    const role = (cfg.roles || []).find(r => r.id === msg.roleId);
+    if (role) {
+      const s = sessions.get(id);
+      if (s) {
+        s.roleName = role.name;
+        if (role.instructions) s.pendingRolePrompt = role.instructions;
+      }
+    }
+  }
+
   const createdPresetId = PRESETS.find(p => binName(p.command) === binName(cmd.command))?.presetId || 'shell';
   const installId = msg.installId || undefined;
   broadcast({ type: 'created', id, name, themeId, commandId: cmd.id, presetId: createdPresetId, projectId, installId });
@@ -149,6 +193,33 @@ function create(msg, ws, cfg) {
   }
 }
 
+// --- Programmatic session creation (for plugins / internal use) ---
+
+function createProgrammatic(opts, cfg) {
+  const id = crypto.randomUUID();
+  let cmd;
+  if (opts.presetId) cmd = cfg.commands.find(c => c.presetId === opts.presetId);
+  else if (opts.commandId) cmd = cfg.commands.find(c => c.id === opts.commandId);
+  if (!cmd) return { error: 'Command not found' };
+
+  const parts = parseCommand(cmd.command);
+  const cwd = resolveValidDir(opts.cwd || cmd.defaultPath || cfg.defaultPath);
+  const themeId = opts.themeId || cfg.defaultTheme || 'default';
+  const name = opts.name || cmd.label;
+  const projectId = opts.projectId || null;
+
+  const err = spawnSession(id, cmd, parts, cwd, name, themeId, cmd.id, null, projectId);
+  if (err) return { error: err.message };
+
+  const s = sessions.get(id);
+  if (s && opts.roleName) s.roleName = opts.roleName;
+  if (s && opts.ephemeral) s.ephemeral = true;
+
+  const presetId = PRESETS.find(p => binName(p.command) === binName(cmd.command))?.presetId || 'shell';
+  broadcast({ type: 'created', id, name, themeId, commandId: cmd.id, presetId, projectId });
+  return { id };
+}
+
 // --- Resume a persisted session ---
 
 function resume(msg, ws, cfg) {
@@ -185,7 +256,11 @@ function resume(msg, ws, cfg) {
     return;
   }
 
-  if (saved.muted) { const s = sessions.get(id); if (s) s.muted = true; }
+  const s = sessions.get(id);
+  if (s) {
+    if (saved.muted) s.muted = true;
+    if (saved.roleName) s.roleName = saved.roleName;
+  }
 
   // Remove from resumable list and notify all clients
   resumable = resumable.filter(s => s.id !== id);
@@ -202,6 +277,11 @@ function input(msg) {
   activity.trackIn(msg.id, data.length);
   transcript.trackInput(msg.id, data);
   sessions.get(msg.id)?.pty.write(data);
+  if (data === '\x1b') {
+    const s = sessions.get(msg.id);
+    console.log(`[esc] session=${msg.id.slice(0,8)} working=${s?.working}`);
+    if (s?.working) telemetry.startEscIdle(msg.id);
+  }
 }
 function resize(msg) { sessions.get(msg.id)?.pty.resize(msg.cols, msg.rows); }
 
@@ -280,6 +360,7 @@ function restart(msg, ws, cfg) {
 function list() {
   return [...sessions].map(([id, s]) => ({
     id, name: s.name, themeId: s.themeId, commandId: s.commandId, presetId: s.presetId || 'shell', projectId: s.projectId, muted: !!s.muted,
+    roleName: s.roleName || null,
     // Last preview text for sidebar display on reconnect
     lastPreview: s.lastPreview || '', lastActivityAt: s.lastActivityAt || null,
     menu: s._menuKey ? JSON.parse(s._menuKey) : undefined,
@@ -325,6 +406,7 @@ function saveSessions(cfg) {
   let skippedNoToken = 0;
   const live = [...sessions]
     .filter(([, s]) => {
+      if (s.ephemeral) return false;
       const cmd = cfg.commands.find(c => c.id === s.commandId);
       if (!cmd?.canResume || !cmd.resumeCommand) return false;
       // If resume needs a session ID, we must have captured one
@@ -337,6 +419,7 @@ function saveSessions(cfg) {
     .map(([id, s]) => ({
       id, name: s.name, commandId: s.commandId, presetId: s.presetId || 'shell', cwd: s.cwd,
       themeId: s.themeId, sessionToken: s.sessionToken, projectId: s.projectId, muted: !!s.muted,
+      roleName: s.roleName || null,
       lastPreview: s.lastPreview || '', lastActivityAt: s.lastActivityAt || null,
       savedAt: new Date().toISOString(),
     }));
@@ -387,7 +470,7 @@ function shutdown(cfg) {
 
 module.exports = {
   clients, broadcast, addBroadcastListener, getSessions: () => sessions,
-  create, resume, restart, input, resize, rename, setTheme, setMute, setProject, setPreview, close,
+  create, createProgrammatic, resume, restart, input, resize, rename, setTheme, setMute, setProject, setPreview, close,
   list, getResumable, sendBuffers,
   loadSessions, startAutoSave, shutdown,
 };

package/telemetry-receiver.js

@@ -5,7 +5,9 @@
 const ioActivity = require('./activity');
 const activity = new Map(); // sessionId → has received events
 const pendingSetup = new Map(); // sessionId → timer (waiting for first event)
-const pendingIdle = new Map(); // sessionId → timer (api_request → confirm idle after output silence)
+const pendingIdle = new Map(); // sessionId → timer (PTY silence → idle)
+const escPendingIdle = new Map(); // sessionId → timer (Esc interrupt → confirm idle after output silence)
+const escSuppressUntil = new Map(); // sessionId → ts (briefly ignore telemetry reassertions after Esc)
 let broadcastFn = null;
 let sessionsFn = null;
 
@@ -65,47 +67,22 @@ function handleLogs(req, res) {
     if (firstEvent) console.log(`Telemetry: first event from ${agent} (${resolvedId.slice(0, 8)})`);
 
     // Process each log record — capture session ID for resume
-    let captured = false;
     for (const sl of rl.scopeLogs || []) {
       for (const lr of sl.logRecords || []) {
         const attrs = parseAttrs(lr.attributes);
-
         const eventName = attrs['event.name'];
+
         // Debug telemetry logs — uncomment as needed, do not delete
         // if (serviceName === 'claude-code' && eventName) console.log(`[telemetry:claude] ${eventName}`);
-        // if (serviceName === 'codex_cli_rs' && eventName) console.log(`[telemetry:codex] ${eventName}`);
+        // if (serviceName === 'codex_cli_rs' && eventName) console.log(`[telemetry:codex] ${eventName} session=${resolvedId.slice(0,8)} working=${sessionsFn?.()?.get(resolvedId)?.working}`);
         // if (serviceName === 'gemini-cli' && eventName) console.log(`[telemetry:gemini] ${eventName}`);
 
-        // Telemetry-based status
+        // Status: user_prompt → working + start PTY silence monitor for idle
         const startEvents = new Set(['user_prompt', 'gemini_cli.user_prompt', 'codex.user_prompt']);
         if (startEvents.has(eventName)) {
+          cancelPendingIdle(resolvedId);
           broadcastFn?.({ type: 'session.status', id: resolvedId, working: true, source: 'telemetry' });
-        }
-        // Claude: telemetry-only status. api_request → pending idle (confirm after 1s output silence, expire after 6s).
-        if (serviceName === 'claude-code' && eventName) {
-          if (eventName === 'api_request') {
-            startPendingIdle(resolvedId);
-          } else if (eventName !== 'user_prompt') {
-            cancelPendingIdle(resolvedId);
-            broadcastFn?.({ type: 'session.status', id: resolvedId, working: true, source: 'telemetry' });
-          }
-        }
-        // Codex: telemetry-only status. codex.user_prompt/any event → working, codex.sse_event → idle.
-        if (serviceName === 'codex_cli_rs' && eventName) {
-          if (eventName === 'codex.sse_event') {
-            broadcastFn?.({ type: 'session.status', id: resolvedId, working: false, source: 'telemetry' });
-          } else if (eventName !== 'codex.user_prompt') {
-            broadcastFn?.({ type: 'session.status', id: resolvedId, working: true, source: 'telemetry' });
-          }
-        }
-        // Gemini: telemetry-only status. Whitelisted events → working, api_response (role=main) → idle.
-        if (serviceName === 'gemini-cli' && eventName) {
-          if (eventName === 'gemini_cli.api_response' && attrs['role'] === 'main') {
-            broadcastFn?.({ type: 'session.status', id: resolvedId, working: false, source: 'telemetry' });
-          } else if (eventName === 'gemini_cli.api_request' || eventName === 'gemini_cli.model_routing'
-            || (eventName === 'gemini_cli.api_response' && attrs['role'] !== 'main')) {
-            broadcastFn?.({ type: 'session.status', id: resolvedId, working: true, source: 'telemetry' });
-          }
+          startPendingIdle(resolvedId, serviceName);
         }
 
         const agentSessionId = attrs['session.id'] || attrs['conversation.id'];
@@ -115,7 +92,6 @@ function handleLogs(req, res) {
           if (!sess.sessionToken || dominated) {
             sess.sessionToken = agentSessionId;
             console.log(`Telemetry: captured session ID ${agentSessionId} for ${agent} (${resolvedId.slice(0, 8)})`);
-            captured = true;
           }
         }
       }
@@ -147,16 +123,44 @@ function cancelPendingSetup(sessionId) {
   }
 }
 
-// Pending idle: api_request starts a check loop. Confirm idle after 1s of output silence. Expire after 6s.
-function startPendingIdle(id) {
-  cancelPendingIdle(id);
-  const started = Date.now();
+// PTY activity monitor: 2s silent → idle, 2s active or user_prompt → working.
+// Agent working indicators in PTY output.
+const CLAUDE_WORKING_RE = /[✳✽✢✻·]|Working…|thinking/;
+const CODEX_WORKING_RE = /Working|•/;
+const GEMINI_WORKING_RE = /[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/;
+
+function startPendingIdle(id, agent) {
+  if (pendingIdle.has(id)) return; // already monitoring
+  const isClaude = agent === 'claude-code';
+  const isCodex = agent === 'codex_cli_rs';
+  const isGemini = agent === 'gemini-cli';
+  let isIdle = false;
+  let activeStart = 0;
   const check = setInterval(() => {
-    const elapsed = Date.now() - started;
-    if (elapsed > 6000) { cancelPendingIdle(id); return; }
-    if (Date.now() - Math.max(started, ioActivity.lastOutputAt(id)) >= 1000) {
-      cancelPendingIdle(id);
+    const lastOut = ioActivity.lastOutputAt(id);
+    const lastIn = ioActivity.lastInputAt(id);
+    // Ignore echo: if last output is within 100ms of last input, treat as silent
+    const agentOut = (lastIn && lastOut - lastIn >= 0 && lastOut - lastIn < 100) ? 0 : lastOut;
+    let silent = (Date.now() - agentOut) >= 2000;
+    // Agent override: if recent output has spinner/working chars, not silent
+    if (silent && (Date.now() - lastOut) < 2000) {
+      const chunk = ioActivity.lastChunk(id);
+      if (isClaude && CLAUDE_WORKING_RE.test(chunk)) silent = false;
+      if (isCodex && CODEX_WORKING_RE.test(chunk)) silent = false;
+      if (isGemini && GEMINI_WORKING_RE.test(chunk)) silent = false;
+    }
+    if (silent && !isIdle) {
+      isIdle = true;
+      activeStart = 0;
       broadcastFn?.({ type: 'session.status', id, working: false, source: 'telemetry' });
+    } else if (!silent && isIdle) {
+      if (!activeStart) activeStart = Date.now();
+      if (Date.now() - activeStart >= 2000) {
+        isIdle = false;
+        broadcastFn?.({ type: 'session.status', id, working: true, source: 'telemetry' });
+      }
+    } else if (!silent) {
+      activeStart = 0;
     }
   }, 250);
   pendingIdle.set(id, check);
@@ -167,9 +171,40 @@ function cancelPendingIdle(id) {
   if (timer) { clearInterval(timer); pendingIdle.delete(id); }
 }
 
+function startEscIdle(id) {
+  cancelEscIdle(id);
+  const started = Date.now();
+  const ignoreUntil = started + 500;
+  console.log(`[escIdle] start session=${id.slice(0,8)}`);
+  const check = setInterval(() => {
+    const lastOut = ioActivity.lastOutputAt(id);
+    const silence = Date.now() - Math.max(ignoreUntil, lastOut);
+    const elapsed = Date.now() - started;
+    if (elapsed > 10000) {
+      console.log(`[escIdle] timeout session=${id.slice(0,8)} silence=${silence}ms`);
+      cancelEscIdle(id);
+      return;
+    }
+    if (silence >= 2000) {
+      console.log(`[escIdle] idle session=${id.slice(0,8)} silence=${silence}ms`);
+      escSuppressUntil.set(id, Date.now() + 2000);
+      cancelEscIdle(id);
+      broadcastFn?.({ type: 'session.status', id, working: false, source: 'esc' });
+    }
+  }, 250);
+  escPendingIdle.set(id, check);
+}
+
+function cancelEscIdle(id) {
+  const timer = escPendingIdle.get(id);
+  if (timer) { clearInterval(timer); escPendingIdle.delete(id); }
+}
+
 function clear(id) {
   activity.delete(id);
   cancelPendingIdle(id);
+  cancelEscIdle(id);
+  escSuppressUntil.delete(id);
   const pending = pendingSetup.get(id);
   if (pending) { clearTimeout(pending.timer); pendingSetup.delete(id); }
 }
@@ -179,4 +214,4 @@ function hasEvents(id) {
   return activity.has(id);
 }
 
-module.exports = { init, handleLogs, clear, hasEvents, watchSession };
+module.exports = { init, handleLogs, clear, hasEvents, watchSession, startPendingIdle, startEscIdle };

package/transcript.js

@@ -254,15 +254,27 @@ function anchorParse(id, lines) {
   return turns;
 }
 
+// For consecutive agent turns, keep only the last one (strips tool output, keeps conversational response).
+function collapseAgentTurns(turns) {
+  if (!turns?.length) return turns;
+  const result = [];
+  for (let i = 0; i < turns.length; i++) {
+    if (turns[i].role === 'agent' && i + 1 < turns.length && turns[i + 1].role === 'agent') continue;
+    result.push(turns[i]);
+  }
+  return result;
+}
+
 // Parse .screen into structured turns — use agent-specific parser if available, else anchor fallback.
-function getScreenTurns(id, agent) {
+// opts.raw: if true, preserve trailing user turn (needed by autopilot for freshness checks).
+function getScreenTurns(id, agent, opts) {
   const screen = getScreen(id);
   if (!screen) return null;
   const lines = screen.split('\n');
   const parser = agentParsers[agent];
-  const turns = parser ? parser(lines, id) : anchorParse(id, lines);
+  const turns = collapseAgentTurns(parser ? parser(lines, id) : anchorParse(id, lines));
   // Drop trailing user turn — it's the empty prompt or unanswered input
-  if (turns?.length && turns[turns.length - 1].role === 'user') turns.pop();
+  if (!opts?.raw && turns?.length && turns[turns.length - 1].role === 'user') turns.pop();
   return turns?.length >= 2 ? turns : null;
 }