clideck 1.31.16 → 1.31.18

package/sessions.js

@@ -7,12 +7,14 @@ const activity = require('./activity');
 const transcript = require('./transcript');
 const telemetry = require('./telemetry-receiver');
 const opencodeBridge = require('./opencode-bridge');
+const piBridge = require('./pi-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 +39,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 +64,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 +76,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,10 +112,10 @@ 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);
+  transcript.setFinalizeOnIdle(id, ['claude-code', 'codex', 'gemini-cli', 'opencode', 'pi', 'clideck-agent'].includes(session.presetId) ? session.presetId : null);
 
   // Always watch telemetry-backed agents so OTLP fallback matching can attach
   // early events to this session even when the agent omits clideck.session_id.
@@ -134,7 +132,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)}…`);
@@ -153,6 +151,7 @@ function spawnSession(id, cmd, parts, cwd, name, themeId, commandId, savedToken,
     activity.clear(id);
     telemetry.clear(id);
     opencodeBridge.clear(id);
+    piBridge.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) {
@@ -196,12 +195,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 +227,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 +277,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 || '' });
 }
 
@@ -305,9 +304,13 @@ function input(msg) {
     // manual flows.
     if (!plugins.shouldAutoApproveMenu(msg.id)) s._resolvedMenuKey = s._menuKey;
     if (s._menuActiveVersion) s._menuConsumedVersion = s._menuActiveVersion;
+    const menuStartsWork = s._menuStartsWork !== false;
     s._menuKey = '';
+    s._menuStartsWork = undefined;
     broadcast({ type: 'session.menu', id: msg.id, choices: [] });
-    broadcast({ type: 'session.status', id: msg.id, working: true, source: 'menu-input' });
+    if (menuStartsWork) {
+      broadcast({ type: 'session.status', id: msg.id, working: true, source: 'menu-input' });
+    }
     return;
   }
   writeSessionInput(msg.id, data);
@@ -337,7 +340,7 @@ function setMute(id, muted) {
 
 function close(msg, cfg) {
   const s = sessions.get(msg.id);
-  if (s) { s.pty.kill(); telemetry.clear(msg.id); transcript.clear(msg.id); plugins.clearStatus(msg.id); sessions.delete(msg.id); broadcast({ type: 'closed', id: msg.id }); }
+  if (s) { s.pty.kill(); telemetry.clear(msg.id); opencodeBridge.clear(msg.id); piBridge.clear(msg.id); transcript.clear(msg.id); plugins.clearStatus(msg.id); sessions.delete(msg.id); broadcast({ type: 'closed', id: msg.id }); }
   // Also remove from resumable list if present
   const before = resumable.length;
   resumable = resumable.filter(r => r.id !== msg.id);
@@ -370,6 +373,7 @@ function restart(msg, ws, cfg) {
   activity.clear(id);
   telemetry.clear(id);
   opencodeBridge.clear(id);
+  piBridge.clear(id);
   transcript.clear(id);
 
   s.pty.kill();
@@ -395,6 +399,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,
+    working: !!s.working,
     // Last preview text for sidebar display on reconnect
     lastPreview: s.lastPreview || '', lastActivityAt: s.lastActivityAt || null,
     menu: s._menuKey ? JSON.parse(s._menuKey) : undefined,
@@ -422,7 +427,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' };
   });
 }
@@ -434,7 +439,7 @@ function sendBuffers(ws) {
       ws.send(JSON.stringify({ type: 'output', id, data, replay: true }));
       continue;
     }
-    if (['claude-code', 'codex', 'gemini-cli', 'opencode', 'clideck-agent'].includes(s.presetId) && !s.working) {
+    if (['claude-code', 'codex', 'gemini-cli', 'opencode', 'pi', 'clideck-agent'].includes(s.presetId) && !s.working) {
       const text = transcript.getReplayText(id, s.presetId);
       if (text) {
         ws.send(JSON.stringify({ type: 'session.history', id, text, replay: true }));

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'));
@@ -238,6 +238,7 @@ function getReplayText(id, presetId) {
     codex: { user: '›', agent: '•' },
     'gemini-cli': { user: '>', agent: '✦' },
     opencode: { user: '›', agent: '•' },
+    pi: { user: '›', agent: '•' },
   }[presetId] || { user: '›', agent: '•' };
   return entries.map(e => `${e.role === 'user' ? marks.user : marks.agent} ${e.text}`).join('\n\n');
 }

package/skills/autonomous-session/SKILL.md

@@ -1,211 +0,0 @@
----
-name: autonomous-session
-description: Run one agent session autonomously until a clearly defined goal is achieved or truly blocked. Use when the user wants the agent to keep working without repeated check-ins, across coding, research, writing, analysis, marketing, planning, or other general session work.
----
-
-# Autonomous Session
-
-Use this skill when the user wants one agent session to keep working toward a goal without stopping for routine confirmation.
-
-This skill is general-purpose. It is not limited to coding. It applies to research, writing, planning, analysis, marketing, documentation, and other session-based work.
-
-## Core Contract
-
-You are not waiting for permission after every step.
-
-- Understand the goal precisely.
-- Keep working until the goal is achieved or truly blocked.
-- Do not stop just to ask whether you should continue.
-- Do not produce filler progress updates instead of real work.
-- Do not redefine the goal casually once work has started.
-
-## First Check: Can This Session Actually Run Autonomously?
-
-Before doing substantial work, verify that the session can proceed without routine approval interruptions.
-
-If the environment clearly requires recurring user approval for normal work, stop immediately and tell the user, in plain language, that autonomous mode cannot work until approvals are removed or auto-approval is enabled.
-
-Do not try to fake autonomy in a session that will keep pausing for user approval.
-
-## Goal Setup
-
-Before starting the main work, convert the user request into a concrete internal brief.
-
-Your internal brief must include:
-
-- Goal: what outcome must exist at the end.
-- Constraints: what must not happen.
-- Definition of done: how you will recognize completion.
-- Open questions: only the questions that would materially change the work.
-
-If the goal is already clear enough, do not ask questions. Start working.
-
-If the goal is not clear enough to work effectively, ask a small batch of targeted clarifying questions first. Ask only what is necessary to remove ambiguity. Do not interrogate the user unnecessarily.
-
-Examples of when to ask questions first:
-
-- The user wants research but has not said what decision the research is meant to support.
-- The user wants writing but has not said audience, tone, or deliverable type.
-- The user wants implementation but has not said what behavior should change.
-- The user wants “improve this” but there is no clear success condition.
-
-Examples of when not to ask questions first:
-
-- The user already gave a concrete task, constraints, and acceptance bar.
-- You can infer a safe, reasonable working interpretation without risking the wrong output.
-
-## Goal Memory
-
-If the task involves a real project or working directory, create and maintain a short session memory file early in the process.
-
-Preferred filename:
-
-```text
-autonomous-session.md
-```
-
-Keep it concise and practical. It should contain:
-
-- Goal
-- Constraints
-- Definition of done
-- Key decisions
-- What has been completed
-- Remaining gaps
-
-If a different filename is more natural in the project, use that instead.
-
-If there is no meaningful project directory or file-based workflow, maintain the same structure mentally and in your session responses instead of forcing a file.
-
-Update this memory whenever the goal changes materially or when major decisions are made. Keep it short. It is a working anchor, not a diary.
-
-## Operating Rules
-
-### 1. Work Forward
-
-After the goal is clear, move directly into execution.
-
-- Prefer real progress over commentary.
-- Prefer concrete artifacts over abstract planning.
-- Prefer finishing a meaningful chunk before reporting back.
-
-### 2. Do Not Stop Early
-
-Do not ask:
-
-- “Should I continue?”
-- “Do you want me to keep going?”
-- “Is this enough for now?”
-
-The default is to continue until done or blocked.
-
-### 3. Use Judgment, Not Blind Persistence
-
-Autonomy does not mean mindless looping.
-
-If an approach is not working:
-
-- reassess,
-- read the available context again,
-- change tactics,
-- keep moving.
-
-Do not repeat the same failing pattern without learning from it.
-
-### 4. Respect the Actual Task
-
-Do not turn every task into implementation work.
-
-- For research tasks, gather, compare, synthesize, and conclude.
-- For writing tasks, produce and refine the requested deliverable.
-- For planning tasks, produce the plan and then, if appropriate, execute it.
-- For coding tasks, inspect, implement, verify, and refine.
-
-Stay aligned with the actual requested outcome.
-
-### 5. Completion Must Be Real
-
-Only stop when one of these is true:
-
-- The goal is achieved.
-- The remaining blocker genuinely requires user input, approval, credentials, or a missing external dependency.
-- The request is fundamentally ambiguous and cannot be resolved safely without clarification.
-
-When stopping, say which of those is true.
-
-## Blockers
-
-A blocker is real only if you cannot reasonably move forward without the user.
-
-Examples of real blockers:
-
-- Missing credentials, API keys, access, or required permissions.
-- A strategic choice the user must make because it changes the deliverable substantially.
-- Multiple valid directions remain and choosing one would be risky or expensive without user preference.
-- The environment prevents autonomous execution through approval prompts or missing capabilities.
-
-Examples of non-blockers:
-
-- You are unsure which tactic is best.
-- The first attempt failed.
-- More reading is needed.
-- The work is tedious.
-- You can make a reasonable assumption and continue.
-
-## Interruptions And Mid-Task User Messages
-
-If the user sends a new message during the work:
-
-- incorporate it,
-- update the goal brief if needed,
-- continue from the new state.
-
-Do not stubbornly follow an outdated plan when the user has clarified or redirected the work.
-
-If the new message changes the goal materially, update the session memory file.
-
-## Reporting Style
-
-Use sparse, meaningful updates.
-
-Good updates:
-
-- major completed milestone,
-- important decision,
-- real blocker,
-- final completion summary.
-
-Bad updates:
-
-- empty status chatter,
-- repeated reassurance,
-- asking for permission to continue.
-
-## Completion Message
-
-When the goal is done, report:
-
-- what was accomplished,
-- any important decisions or tradeoffs,
-- any residual risks or follow-up items.
-
-Keep it concise and outcome-focused.
-
-## Behavior Summary
-
-If this skill is active, your default behavior is:
-
-1. Check whether autonomous execution is actually possible.
-2. Clarify the goal only if necessary.
-3. Create a short working brief or memory file when appropriate.
-4. Work continuously toward the goal.
-5. Adapt when an approach fails.
-6. Stop only when done or truly blocked.
-
-## Hard Rules
-
-- Do not ask “should I continue?”
-- Do not stop because of ordinary uncertainty.
-- Do not continue blindly when the goal is unclear.
-- Do not pretend a blocker exists when you can still make progress.
-- Do not treat a status update as completion.