clideck 1.27.0 → 1.29.0

package/telemetry-receiver.js

@@ -6,10 +6,11 @@ const ioActivity = require('./activity');
 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)
-const pendingIdle = new Map(); // sessionId → timer (PTY silence → idle)
 const codexMenuPoll = new Map(); // sessionId → interval (polling for menu after response.completed)
-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)
+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)
+const escPendingIdle = new Map(); // sessionId → timer (Esc interrupt → short grace before forcing idle)
 let broadcastFn = null;
 let sessionsFn = null;
 
@@ -76,33 +77,70 @@ function handleLogs(req, res) {
 
         // 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} ${attrs['event.kind'] ? 'kind=' + attrs['event.kind'] : ''} ${attrs['tool'] ? 'tool=' + attrs['tool'] : ''} session=${resolvedId.slice(0,8)}`);
+        // if (serviceName === 'codex_cli_rs' && eventName) {
+        //   const details = Object.entries(attrs)
+        //     .filter(([k]) => k !== 'event.name')
+        //     .map(([k, v]) => `${k}=${JSON.stringify(v)}`)
+        //     .join(' ');
+        //   console.log(`[telemetry:codex] ${eventName} session=${resolvedId.slice(0,8)}${details ? ' ' + details : ''}`);
+        // }
         // if (serviceName === 'gemini-cli' && eventName) console.log(`[telemetry:gemini] ${eventName}`);
 
         // Track last event per session (used by menu detection validation)
         if (eventName) lastEvent.set(resolvedId, eventName + (attrs['event.kind'] ? ':' + attrs['event.kind'] : ''));
 
-        // Status: user_prompt → working
-        // Claude uses hooks; Codex uses notify hook; Gemini uses PTY heuristic
-        const startEvents = new Set(['gemini_cli.user_prompt', 'codex.user_prompt']);
-        if (startEvents.has(eventName)) {
-          cancelPendingIdle(resolvedId);
+        // Codex can emit a brief completion between tool phases. Keep idle
+        // pending for a tiny settle window and cancel it on any fresh Codex
+        // activity before the idle is committed to UI/notifications.
+        if (serviceName === 'codex_cli_rs' && eventName) {
+          const isTrustedCompletion = eventName === 'codex.sse_event' && attrs['event.kind'] === 'response.completed';
+          if (!isTrustedCompletion) cancelCodexPendingIdle(resolvedId);
+        }
+
+        // Status: Codex user_prompt → working. Claude and Gemini use hooks.
+        if (eventName === 'codex.user_prompt') {
+          codexPendingStop.delete(resolvedId);
+          codexOutputDone.delete(resolvedId);
           broadcastFn?.({ type: 'session.status', id: resolvedId, working: true, source: 'telemetry' });
-          // Gemini uses PTY silence heuristic for idle; Codex idle comes from notify hook
-          if (serviceName !== 'codex_cli_rs') startPendingIdle(resolvedId, serviceName);
         }
 
-        // Codex: response.completed → poll for menu until found or timeout
+        // Fallback: when notify does not fire, require an output item to finish
+        // before treating the next response.completed as a real end-of-turn.
+        if (eventName === 'codex.websocket_event' && attrs['event.kind'] === 'response.output_item.done') {
+          codexOutputDone.set(resolvedId, Date.now());
+        }
+
+        // Codex: after notify hook arms a pending stop, the next response.completed commits idle.
+        // Also poll briefly for a visible choice menu.
         if (eventName === 'codex.sse_event' && attrs['event.kind'] === 'response.completed') {
+          const pendingStopAt = codexPendingStop.get(resolvedId);
+          if (pendingStopAt && Date.now() - pendingStopAt <= 5000) {
+            // console.log(`[codex] complete matched pending-stop session=${resolvedId.slice(0,8)} age=${Date.now() - pendingStopAt}ms`);
+            codexPendingStop.delete(resolvedId);
+            codexOutputDone.delete(resolvedId);
+            scheduleCodexIdle(resolvedId, 'telemetry-stop');
+          } else {
+            const outputDoneAt = codexOutputDone.get(resolvedId);
+            if (outputDoneAt && Date.now() - outputDoneAt <= 5000) {
+              // console.log(`[codex] complete matched output-item.done fallback session=${resolvedId.slice(0,8)} age=${Date.now() - outputDoneAt}ms`);
+              codexOutputDone.delete(resolvedId);
+              scheduleCodexIdle(resolvedId, 'telemetry-fallback');
+            } else {
+              // console.log(`[codex] response.completed with no notify-stop and no output-item.done fallback session=${resolvedId.slice(0,8)} outputDone=${outputDoneAt ? Date.now() - outputDoneAt + 'ms' : 'none'}`);
+            }
+          }
           startCodexMenuPoll(resolvedId);
         }
         // Codex: tool_decision → user approved, cancel menu poll, back to working
         if (eventName === 'codex.tool_decision') {
+          codexPendingStop.delete(resolvedId);
+          codexOutputDone.delete(resolvedId);
           cancelCodexMenuPoll(resolvedId);
           broadcastFn?.({ type: 'session.status', id: resolvedId, working: true, source: 'telemetry' });
         }
         // Codex: user_prompt or next sse_event cancels menu poll
         if ((eventName === 'codex.user_prompt' || (eventName === 'codex.sse_event' && attrs['event.kind'] !== 'response.completed'))) {
+          codexOutputDone.delete(resolvedId);
           cancelCodexMenuPoll(resolvedId);
         }
 
@@ -147,55 +185,14 @@ function cancelPendingSetup(sessionId) {
   }
 }
 
-// PTY activity monitor: 2s silent → idle, 2s active or user_prompt → working.
-// Used by Gemini only — Claude uses hooks, Codex uses sse_event completion.
-// Agent working indicators in PTY output.
-const GEMINI_WORKING_RE = /[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/;
-
-function startPendingIdle(id, agent) {
-  if (pendingIdle.has(id)) return; // already monitoring
-  let isIdle = false;
-  let activeStart = 0;
-  const check = setInterval(() => {
-    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 (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);
-}
-
-function cancelPendingIdle(id) {
-  const timer = pendingIdle.get(id);
-  if (timer) { clearInterval(timer); pendingIdle.delete(id); }
-}
-
-// Codex: after response.completed, poll screen capture every 500ms for up to 3s
+// Codex: after response.completed, poll terminal capture every 500ms for up to 3s
 function startCodexMenuPoll(id) {
   cancelCodexMenuPoll(id);
   const started = Date.now();
   const poll = setInterval(() => {
     if (Date.now() - started > 3000) { cancelCodexMenuPoll(id); return; }
-    broadcastFn?.({ type: 'screen.capture', id });
+    // console.log(`[terminal.capture] session=${id.slice(0,8)} source=codex-menu-poll`);
+    broadcastFn?.({ type: 'terminal.capture', id });
   }, 500);
   codexMenuPoll.set(id, poll);
 }
@@ -205,42 +202,48 @@ function cancelCodexMenuPoll(id) {
   if (timer) { clearInterval(timer); codexMenuPoll.delete(id); }
 }
 
+function armCodexStop(id) {
+  codexPendingStop.set(id, Date.now());
+  codexOutputDone.delete(id);
+  // console.log(`[codex] pending-stop armed session=${id.slice(0,8)}`);
+}
+
+function scheduleCodexIdle(id, source) {
+  cancelCodexPendingIdle(id);
+  const timer = setTimeout(() => {
+    codexPendingIdle.delete(id);
+    broadcastFn?.({ type: 'session.status', id, working: false, source });
+  }, 300);
+  codexPendingIdle.set(id, timer);
+}
+
+function cancelCodexPendingIdle(id) {
+  const timer = codexPendingIdle.get(id);
+  if (timer) { clearTimeout(timer); codexPendingIdle.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);
+  const timer = setTimeout(() => {
+    escPendingIdle.delete(id);
+    broadcastFn?.({ type: 'session.status', id, working: false, source: 'esc' });
+  }, 350);
+  escPendingIdle.set(id, timer);
 }
 
 function cancelEscIdle(id) {
   const timer = escPendingIdle.get(id);
-  if (timer) { clearInterval(timer); escPendingIdle.delete(id); }
+  if (timer) { clearTimeout(timer); escPendingIdle.delete(id); }
 }
 
 function clear(id) {
   activity.delete(id);
   lastEvent.delete(id);
-  cancelPendingIdle(id);
   cancelCodexMenuPoll(id);
+  cancelCodexPendingIdle(id);
+  codexPendingStop.delete(id);
+  codexOutputDone.delete(id);
   cancelEscIdle(id);
-  escSuppressUntil.delete(id);
   const pending = pendingSetup.get(id);
   if (pending) { clearTimeout(pending.timer); pendingSetup.delete(id); }
 }
@@ -252,4 +255,4 @@ function hasEvents(id) {
   return activity.has(id);
 }
 
-module.exports = { init, handleLogs, clear, hasEvents, getLastEvent, cancelCodexMenuPoll, watchSession, startPendingIdle, startEscIdle };
+module.exports = { init, handleLogs, clear, hasEvents, getLastEvent, cancelCodexMenuPoll, watchSession, startEscIdle, armCodexStop };

package/tools/merge-jsonl-roles.mjs

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+
+import { readFileSync, writeFileSync } from 'fs';
+
+const isCodex = process.argv.includes('--codex');
+const file = process.argv.filter(a => !a.startsWith('--'))[2];
+if (!file) {
+  console.error('Usage: node merge-jsonl-roles.mjs <file.jsonl> [--codex]');
+  process.exit(1);
+}
+
+const lines = readFileSync(file, 'utf8').trim().split('\n').map(l => JSON.parse(l));
+const merged = [];
+const SPINNER_WORD = 'Working';
+const SPINNER_TAIL = 's • esc to interrupt)';
+const SPINNER_PREFIXES = ['Working', 'Workin', 'Worki', 'Work', 'Wor', 'Wo', 'W'];
+const SPINNER_SUFFIXES = ['Working', 'orking', 'rking', 'king', 'ing', 'ng', 'g'];
+const SPINNER_OUTRO = /^\d+s • esc to interr?upt\)/;
+
+for (const entry of lines) {
+  const prev = merged[merged.length - 1];
+  if (prev && prev.role === entry.role && entry.role === 'user') {
+    prev.text += '\n' + entry.text;
+  } else {
+    merged.push({ ...entry });
+  }
+}
+
+function cleanText(text) {
+  const extra = isCodex ? '\u2022\u203a' : '';
+  const re = new RegExp(`[^a-zA-Z0-9.,;:!?'"()\\-/\\s@#$%&*+=<>\\[\\]{}\\\\|_~\`^${extra}]`, 'g');
+
+  let out = text;
+  if (isCodex) {
+    out = collapseCodexSpinner(out);
+    // collapse consecutive • (with optional whitespace between) into one
+    out = out.replace(/\u2022(?:\s*\u2022)+/g, '\u2022');
+  }
+
+  return out
+    .replace(re, ' ')
+    .replace(/[ \t]+/g, ' ')
+    .replace(/\n(?:[ \t]*\n)+/g, '\n')
+    .trim();
+}
+
+function collapseCodexSpinner(text) {
+  let out = '';
+  for (let i = 0; i < text.length;) {
+    const buildLen = consumeSpinnerBuildUp(text, i);
+    if (buildLen > 0) {
+      out += '\u2022';
+      i += buildLen;
+      continue;
+    }
+
+    const fragmentLen = consumeSpinnerFragments(text, i);
+    if (fragmentLen > 0) {
+      out += '\u2022';
+      i += fragmentLen;
+      continue;
+    }
+
+    out += text[i];
+    i += 1;
+  }
+  return out;
+}
+
+function consumeSpinnerBuildUp(text, start) {
+  if (text[start] !== '\u2022') return 0;
+
+  let i = start + 1;
+  let matched = 0;
+  while (matched < SPINNER_WORD.length && text[i] === SPINNER_WORD[matched]) {
+    i += 1;
+    matched += 1;
+  }
+
+  if (matched === 0) return 0;
+  if (matched < SPINNER_WORD.length) return i - start;
+  if (text[i] !== '(') return i - start;
+
+  i += 1;
+  while (/[0-9]/.test(text[i] || '')) i += 1;
+
+  let tail = 0;
+  while (tail < SPINNER_TAIL.length && text[i] === SPINNER_TAIL[tail]) {
+    i += 1;
+    tail += 1;
+  }
+
+  return i - start;
+}
+
+function consumeSpinnerFragments(text, start) {
+  let i = start;
+  let tokens = 0;
+  let sawBullet = false;
+  let startsWithBulletPrefix = false;
+
+  while (true) {
+    const bulletPrefix = text[i] === '\u2022' ? matchSpinnerPart(text, i + 1, SPINNER_PREFIXES) : '';
+    if (bulletPrefix) {
+      startsWithBulletPrefix ||= tokens === 0;
+      sawBullet = true;
+      i += 1 + bulletPrefix.length;
+      tokens += 1;
+      continue;
+    }
+
+    const suffix = matchSpinnerPart(text, i, SPINNER_SUFFIXES);
+    if (suffix && text[i + suffix.length] === '\u2022') {
+      sawBullet = true;
+      i += suffix.length + 1;
+      tokens += 1;
+      continue;
+    }
+
+    const prefix = matchSpinnerPart(text, i, SPINNER_PREFIXES);
+    if (prefix) {
+      i += prefix.length;
+      tokens += 1;
+      continue;
+    }
+
+    if (suffix) {
+      i += suffix.length;
+      tokens += 1;
+      continue;
+    }
+
+    const outro = text.slice(i).match(SPINNER_OUTRO)?.[0];
+    if (outro) {
+      sawBullet = true;
+      i += outro.length;
+      tokens += 1;
+      continue;
+    }
+
+    const digits = text.slice(i).match(/^\d+/)?.[0];
+    if (digits) {
+      i += digits.length;
+      tokens += 1;
+      continue;
+    }
+
+    break;
+  }
+
+  if (startsWithBulletPrefix) return i - start;
+  return sawBullet && tokens >= 2 ? i - start : 0;
+}
+
+function matchSpinnerPart(text, start, parts) {
+  return parts.find(part => text.startsWith(part, start)) || '';
+}
+
+function splitCodexAgentEntry(entry) {
+  if (!isCodex || entry.role !== 'agent') return [entry];
+
+  const work = { ...entry, role: 'agent_work' };
+  const cut = entry.text.lastIndexOf('\u2022');
+  if (cut === -1) return [work];
+
+  const output = cleanAgentOutput(entry.text.slice(cut + 1));
+  if (!output) return [work];
+
+  return [work, { ts: entry.ts, role: 'agent_output', text: output }];
+}
+
+function cleanAgentOutput(text) {
+  const out = text.trim();
+  const footer = out.lastIndexOf('\u203a');
+  return (footer === -1 ? out : out.slice(0, footer)).trim();
+}
+
+const cleaned = merged.map(e => ({ ...e, text: cleanText(e.text) }));
+const transformed = cleaned.flatMap(splitCodexAgentEntry);
+const out = transformed.map(e => JSON.stringify(e)).join('\n') + '\n';
+writeFileSync(file, out);
+console.log(`${lines.length} lines → ${merged.length} lines`);

package/transcript-builder.js

@@ -0,0 +1,53 @@
+function cleanAgentText(presetId, text) {
+  let out = String(text || '').split('\n').map(l => l.replace(/[ \t]+$/g, '')).join('\n').trim();
+  out = out.replace(/\n\n─{5,}\s*$/u, '').trim();
+  if (presetId === 'codex' || presetId === 'claude-code') {
+    const cut = Math.max(out.lastIndexOf('›'), out.lastIndexOf('❯'));
+    if (cut !== -1) out = out.slice(0, cut).trim();
+  }
+  if (presetId === 'gemini-cli') {
+    const cut = out.lastIndexOf('\n >');
+    if (cut !== -1) out = out.slice(0, cut).trim();
+    out = out.replace(/\n\s*[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]?\s*Executing Hook:[\s\S]*$/, '').trim();
+  }
+  if (presetId === 'claude-code') {
+    out = out.replace(/\n\s*.*\(running stop hook\)[\s\S]*$/, '').trim();
+    out = out.replace(/\n\s*\?\s*for shortcuts[\s\S]*$/, '').trim();
+    out = out.replace(/\n\s*esc to interrupt[\s\S]*$/, '').trim();
+    out = out.replace(/\n\s*[✻✢✣✤✥✦✧]\s+[^\n]*$/, '').trim();
+  }
+  return out;
+}
+
+function normalizeEntry(entry, presetId) {
+  const text = entry.role === 'agent'
+    ? cleanAgentText(presetId, entry.text)
+    : String(entry.text || '').trim();
+  return text ? { ...entry, text } : null;
+}
+
+function addEntry(entries, entry, presetId) {
+  const next = normalizeEntry(entry, presetId);
+  if (!next) return entries;
+  const prev = entries[entries.length - 1];
+  if (prev && prev.role === 'user' && next.role === 'user') {
+    prev.text += '\n' + next.text;
+    prev.ts = next.ts;
+    return entries;
+  }
+  if (prev && prev.role === 'agent' && next.role === 'agent') {
+    prev.text = next.text;
+    prev.ts = next.ts;
+    return entries;
+  }
+  entries.push(next);
+  return entries;
+}
+
+function compactEntries(entries, presetId) {
+  const out = [];
+  for (const entry of entries || []) addEntry(out, entry, presetId);
+  return out;
+}
+
+module.exports = { addEntry, compactEntries, cleanAgentText };

package/transcript-parser.js

@@ -0,0 +1,135 @@
+function parseTurns(presetId, lines, users) {
+  const parser = parsers[presetId];
+  return collapseAgentTurns(parser ? parser(lines, users) : anchorParse(lines, users));
+}
+
+function parseLastAgentOnly(presetId, lines) {
+  const turns = collapseAgentTurns((parsers[presetId] || (() => null))(lines, null));
+  if (!turns?.length) return null;
+  const last = [...turns].reverse().find(t => t.role === 'agent');
+  return last || null;
+}
+
+const parsers = {
+  'claude-code': (lines, users) => {
+    const known = users?.length ? new Set(users) : null;
+    const turns = [];
+    let current = null;
+    for (const line of lines) {
+      const agent = line.match(/^(?:[│ ]\s*)?[⏺•●]\s(.*)$/);
+      if (agent) {
+        if (current) { current.text = current.text.replace(/\n+$/, ''); turns.push(current); }
+        current = { role: 'agent', text: agent[1] };
+        continue;
+      }
+      const userM = line.match(/^(?:[│ ]\s*)?[❯›]\s(.*)$/);
+      if (userM && (known ? known.has(userM[1].trim()) : true)) {
+        if (current) { current.text = current.text.replace(/\n+$/, ''); turns.push(current); }
+        current = { role: 'user', text: userM[1] };
+        continue;
+      }
+      if (!current) continue;
+      let cont = line;
+      if (cont.startsWith('│ ')) cont = cont.slice(2);
+      else if (cont.startsWith('  ')) cont = cont.slice(2);
+      current.text += '\n' + cont;
+    }
+    if (current) { current.text = current.text.replace(/\n+$/, ''); turns.push(current); }
+    return turns.length >= 2 ? turns : null;
+  },
+  codex: (lines, users) => {
+    const known = users?.length ? new Set(users) : null;
+    const turns = [];
+    let current = null;
+    for (const line of lines) {
+      const agent = line.match(/^(?:│\s*)?•\s(.*)$/);
+      if (agent) {
+        if (current) { current.text = current.text.replace(/\n+$/, ''); turns.push(current); }
+        current = { role: 'agent', text: agent[1] };
+        continue;
+      }
+      const userM = line.match(/^(?:│\s*)?›\s(.*)$/);
+      if (userM && (known ? known.has(userM[1].trim()) : true)) {
+        if (current) { current.text = current.text.replace(/\n+$/, ''); turns.push(current); }
+        current = { role: 'user', text: userM[1] };
+        continue;
+      }
+      if (!current) continue;
+      let cont = line;
+      if (cont.startsWith('│ ')) cont = cont.slice(2);
+      else if (cont.startsWith('  ')) cont = cont.slice(2);
+      current.text += '\n' + cont;
+    }
+    if (current) { current.text = current.text.replace(/\n+$/, ''); turns.push(current); }
+    return turns.length >= 2 ? turns : null;
+  },
+  'gemini-cli': (lines, users) => {
+    const known = users?.length ? new Set(users) : null;
+    const isChrome = t => {
+      const s = t.trim();
+      return /^shift\+tab to accept/i.test(s)
+        || /^(Type your message|@path\/to\/)/i.test(s)
+        || /^(\/\w+ |no sandbox|\/model )/i.test(s)
+        || /^[~\/\\].*\(main[*]?\)\s*$/i.test(s)
+        || /^(Logged in with|Plan:|Tips for getting started)/i.test(s)
+        || /^\d+\.\s+(Ask questions|Be specific|Create GEMINI)/i.test(s)
+        || /^ℹ\s/.test(s);
+    };
+    const turns = [];
+    let current = null;
+    for (const line of lines) {
+      if (isChrome(line)) continue;
+      const isAgent = line.startsWith('✦ ');
+      const userM = line.startsWith(' > ') ? line.slice(3) : null;
+      const isUser = userM && (known ? known.has(userM.trim()) : true);
+      if (isUser || isAgent) {
+        if (current) { current.text = current.text.replace(/\n+$/, ''); turns.push(current); }
+        current = { role: isUser ? 'user' : 'agent', text: isUser ? userM : line.slice(2) };
+        continue;
+      }
+      if (!current) continue;
+      current.text += '\n' + line;
+    }
+    if (current) { current.text = current.text.replace(/\n+$/, ''); turns.push(current); }
+    return turns.length >= 2 ? turns : null;
+  },
+};
+
+function anchorParse(lines, users) {
+  if (!users?.length) return null;
+  const isPrompt = (line, text) => { const t = line.trim(); return t.endsWith(text) && t.length - text.length <= 6; };
+  const lastUser = users[users.length - 1];
+  let lastIdx = -1;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (isPrompt(lines[i], lastUser)) { lastIdx = i; break; }
+  }
+  if (lastIdx < 0) return null;
+  const anchors = [{ idx: lastIdx, text: lastUser }];
+  for (let u = users.length - 2; u >= 0 && anchors.length < 3; u--) {
+    for (let i = anchors[anchors.length - 1].idx - 1; i >= 0; i--) {
+      if (isPrompt(lines[i], users[u])) { anchors.push({ idx: i, text: users[u] }); break; }
+    }
+  }
+  anchors.reverse();
+  const turns = [];
+  for (let p = 0; p < anchors.length; p++) {
+    turns.push({ role: 'user', text: anchors[p].text });
+    const start = anchors[p].idx + 1;
+    const end = p + 1 < anchors.length ? anchors[p + 1].idx : lines.length;
+    const agentLines = lines.slice(start, end).filter(l => l.trim());
+    if (agentLines.length) turns.push({ role: 'agent', text: agentLines.join('\n') });
+  }
+  return turns.length >= 2 && turns[turns.length - 1].role === 'agent' ? turns : null;
+}
+
+function collapseAgentTurns(turns) {
+  if (!turns?.length) return turns;
+  const out = [];
+  for (let i = 0; i < turns.length; i++) {
+    if (turns[i].role === 'agent' && i + 1 < turns.length && turns[i + 1].role === 'agent') continue;
+    out.push(turns[i]);
+  }
+  return out;
+}
+
+module.exports = { parseTurns, parseLastAgentOnly };