create-walle 0.9.21 → 0.9.23

package/template/claude-task-manager/workers/session-integrity-worker.js

@@ -1,60 +1,16 @@
-// --- Session Integrity Worker Thread ---
-// Runs session-integrity scans off the main event loop.
+'use strict';
 
-const { parentPort, workerData } = require('worker_threads');
-const path = require('path');
-
-const dbModule = require(path.join(workerData.ctmDir, 'db'));
-dbModule.connectDb(workerData.dbPath);
-
-const sessionIntegrity = require(path.join(workerData.ctmDir, 'session-integrity'));
-const { getAllSessionFiles } = require(path.join(workerData.ctmDir, 'session-utils'));
-
-let running = false;
-let closing = false;
-let closed = false;
-
-function closeDbAndAck() {
-  if (closed) return;
-  closed = true;
-  try { dbModule.closeDb({ checkpointMode: 'PASSIVE' }); } catch {}
-  parentPort.postMessage({ type: 'closed' });
-  setImmediate(() => process.exit(0));
-}
+const { parentPort } = require('node:worker_threads');
 
 parentPort.on('message', (msg) => {
-  if (msg.type === 'close') {
-    closing = true;
-    if (!running) closeDbAndAck();
-    return;
-  }
-  if (msg.type !== 'run') return;
-  if (closing) {
-    parentPort.postMessage({ type: 'error', requestId: msg.requestId, dur: 0, error: 'worker closing' });
+  if (msg?.type === 'close') {
+    parentPort.postMessage({ type: 'closed' });
     return;
   }
-  if (running) {
-    parentPort.postMessage({ type: 'done', requestId: msg.requestId, dur: 0, result: { skipped: 'already_running' } });
-    return;
-  }
-  running = true;
-  const t0 = Date.now();
-  try {
-    const result = sessionIntegrity.runIntegrityCheck({
-      db: dbModule.getDb(),
-      getAllSessionFiles,
-      telemetry: null,
-      autoRecover: true,
-    });
-    parentPort.postMessage({ type: 'done', requestId: msg.requestId, dur: Date.now() - t0, result: result || { checked: true } });
-  } catch (e) {
-    parentPort.postMessage({ type: 'error', requestId: msg.requestId, dur: Date.now() - t0, error: e.message });
-  } finally {
-    running = false;
-    if (closing) closeDbAndAck();
-  }
-});
-
-process.on('exit', () => {
-  try { dbModule.closeDb({ checkpointMode: 'NONE' }); } catch {}
+  parentPort.postMessage({
+    type: 'error',
+    requestId: msg?.requestId,
+    dur: 0,
+    error: 'session integrity DB work is owned by the CTM DB owner worker',
+  });
 });

package/template/claude-task-manager/workers/state-detectors/base.js

@@ -16,6 +16,13 @@
 // A detector MAY also opt into custom waiting-input detection by providing
 // a `detectWaitingInput(text)` hook, but most providers get that for free
 // via providers/<id>.detect() which is already wired into approval-agent.
+//
+// A detector MAY also provide `detectTurnFinished(text)`: positive evidence the
+// agent returned to its ready prompt (e.g. a TUI repainting its idle composer
+// with no in-progress status line). Distinct from detectWaitingInput — finished
+// means Idle (nothing needed), not Needs-You. Hookless TUIs like Codex rely on
+// this to close their active turn; without it a finished session would ride the
+// long open-turn "running" hold. server.js _idlePromptDetections consumes it.
 
 const DEFAULT_IDLE_DEBOUNCE_MS = 1500;
 
@@ -26,7 +33,17 @@ const TRIVIAL_CHUNK_RE = /^[\s\x1b\[\]\d;A-Za-z⠁⠂⠄⠈⠐⠠⡀⢀\\|/\-─
 
 function stripAnsi(data) {
   return String(data || '')
-    .replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, '')
+    // `<=>` covers private-parameter CSI like modifyOtherKeys "\x1b[>4;0m"
+    // and kitty keyboard queries "\x1b[>7u" — without them the prefix byte
+    // survives and "[>4;0m[>7u" reads as printable content.
+    .replace(/\x1b\[[0-9;?<=>]*[a-zA-Z]/g, '')
+    // CSI sequences with intermediate bytes (0x20-0x2F) before the final byte —
+    // e.g. DECSCUSR cursor-shape "\x1b[0 q" (note the space). The rule above
+    // requires the final byte immediately after the params, so it misses these
+    // and leaves a stray "q"/"0 q" that reads as printable content (which made
+    // composer-cursor repaints score as activity). Additive: only matches the
+    // intermediate form the rule above cannot.
+    .replace(/\x1b\[[0-9;?]*[ -/]+[@-~]/g, '')
     .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, '')
     .replace(/[\x00-\x1f\x7f]/g, '');
 }

package/template/claude-task-manager/workers/state-detectors/claude-code.js

@@ -9,7 +9,10 @@
 const { baseDetector, stripAnsi } = require('./base');
 
 const CLAUDE_STATUS_FRAGMENT_RE = /^(?:[✻✳✢✶◐◓◑◒⏺●○■□✔✓]+|Run|Runn|Runni|Runnin|Running\.{0,3}|unning|Thinking\.{0,3}|\(?ctrl\+o\s*to\s*expand\)?|>?\s*esc\s+to\s+interrupt|[⏵>]+\s*(?:accept edits|auto mode)\s+on\s+\(shift\+tab\s+to\s+cycle\)(?:\s*·\s*esc\s+to\s+interrupt)?(?:\s*·\s*ctrl\+t\s+to\s+(?:show|hide)\s+task)?|ctrl\+t\s+to\s+show\s+tasks?|\?\s+for\s+shortcuts|Native installation exists but .*? is not in your PATH\. Run:|echo\s+['"]export\s+PATH=.*)$/i;
-const CLAUDE_TOOL_OUTPUT_RE = /\b(?:Bash|Edit|Edited|Error|Failed|Grep|Glob|MultiEdit|NotebookEdit|Read|Recalled|Search|Searched|Task|TodoWrite|Update|Updated|WebFetch|WebSearch|Write|Wrote)\b/i;
+const CLAUDE_PROMPT_LINE_RE = /^(?:›|❯|>)\s*(?:\S.*)?$/;
+const CLAUDE_IDLE_FOOTER_LINE_RE = /(?:accept edits|auto mode)\s+on\s+\(shift\+tab\s+to\s+cycle\)|\besc\s+to\s+interrupt\b|\bctrl\+t\s+to\s+(?:show|hide)\s+tasks?\b|\bctrl\+o\s+to\s+expand\b|\?\s+for\s+shortcuts/i;
+const CLAUDE_WORKED_LINE_RE = /^[*•]?\s*Worked for\s+\d/i;
+const CLAUDE_PASSIVE_BORDER_LINE_RE = /^[\s─━═│┃┌┐└┘├┤┬┴┼╭╮╰╯]+$/u;
 
 function isClaudeRedraw(data) {
   const s = String(data || '');
@@ -17,6 +20,169 @@ function isClaudeRedraw(data) {
     /\x1b\[[0-9]+A/.test(s) && /\x1b\[[0-9;?]*J/.test(s)
   ) || (
     /\x1b\[[0-9]+;[0-9]+H/.test(s) && /\x1b\[[0-9;?]*[KJ]/.test(s)
+  ) || /\x1b\[\?2026h/.test(s);
+}
+
+function stripAnsiPreserveLines(data) {
+  return String(data || '')
+    .replace(/\x1b\[[0-9]+;[0-9]+[Hf]/g, '\n')
+    .replace(/\x1b\[[0-9]+[ABCD]/g, '\n')
+    .replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, '')
+    .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, '')
+    .replace(/\r/g, '\n')
+    .replace(/[\x00-\x09\x0b\x0c\x0e-\x1f\x7f]/g, '');
+}
+
+function printableLines(data) {
+  return stripAnsiPreserveLines(data)
+    .replace(/\u00a0/g, ' ')
+    .split(/\n+/)
+    .map(line => line.trim())
+    .filter(Boolean);
+}
+
+function isClaudePassivePromptLine(line) {
+  const text = String(line || '').trim();
+  if (!text) return true;
+  return CLAUDE_PROMPT_LINE_RE.test(text) ||
+    CLAUDE_IDLE_FOOTER_LINE_RE.test(text) ||
+    CLAUDE_WORKED_LINE_RE.test(text) ||
+    CLAUDE_STATUS_FRAGMENT_RE.test(text) ||
+    CLAUDE_PASSIVE_BORDER_LINE_RE.test(text);
+}
+
+function isClaudeIdlePromptRedraw(data) {
+  if (!isClaudeRedraw(data)) return false;
+  const lines = printableLines(data);
+  if (!lines.length) return false;
+  const hasPrompt = lines.some(line => CLAUDE_PROMPT_LINE_RE.test(line));
+  const hasFooter = lines.some(line => CLAUDE_IDLE_FOOTER_LINE_RE.test(line));
+  if (!hasPrompt || !hasFooter) return false;
+  return lines.every(isClaudePassivePromptLine);
+}
+
+// Live Claude approval/choice widget shapes. A real prompt highlights a
+// selection row (❯ 1. Yes / ❯ Allow / ❯ Run) and/or asks an approval question
+// with a confirm footer. These parallel approval-agent.js's LIVE_SELECTION_CURSOR_RE
+// / LIVE_PROMPT_FOOTER_RE (which serve the auto-approver); kept here so the banner
+// path's "at a live prompt?" answer comes from the provider detector, not from
+// global content regexes tested over the whole tail.
+// Leading box-frame border ("│ ❯ 1. …") — a menu rendered inside a bordered widget
+// prefixes each row with a vertical rule. It is allowed (optional) before the cursor
+// so a boxed AskUserQuestion reads like a borderless one; without it the menu rows
+// fail to match and the whole widget classifies as `none`, stranding a stale banner.
+const CLAUDE_BOX_BORDER = '(?:[│┃║▏▕|]\\s*)?';
+const CLAUDE_SELECTION_CURSOR_RE = new RegExp('^\\s*' + CLAUDE_BOX_BORDER + '[❯▸›▶➤◆→]\\s*(?:\\d+[.)]\\s*)?(?:yes\\b|allow\\b|approve\\b|proceed\\b|accept\\b|run\\b|make edits|don\'?t ask|always)', 'i');
+const CLAUDE_APPROVAL_QUESTION_RE = /\bDo you want to (?:proceed|make this edit|create|run|allow)\b/i;
+const CLAUDE_CONFIRM_FOOTER_RE = /\benter to confirm\b|\besc to (?:cancel|reject|go back)\b|press enter to (?:confirm|continue)/i;
+// Any numbered option row (cursor optional): "❯ 1. X", "  2. Y". Loose on its own —
+// it also matches enumerated PROSE ("2. Double-stat (low): ..."), so it only counts
+// toward a real menu alongside a highlight cursor or a menu nav footer (below).
+const CLAUDE_NUMBERED_OPTION_RE = new RegExp('^\\s*' + CLAUDE_BOX_BORDER + '[❯▸›▶➤◆→]?\\s*\\d+[.)]\\s+\\S');
+// A HIGHLIGHTED numbered option (selection cursor REQUIRED) — present in a real
+// interactive menu ("❯ 1. Investigate"), absent from a prose findings list.
+const CLAUDE_MENU_CURSOR_OPTION_RE = new RegExp('^\\s*' + CLAUDE_BOX_BORDER + '[❯▸▶➤◆→]\\s*\\d+[.)]\\s+\\S');
+// A menu navigation footer ("Enter to select · ↑/↓ to navigate"): the other positive
+// tell that the numbered rows are an interactive selection menu, not prose.
+const CLAUDE_MENU_NAV_FOOTER_RE = /\bto\s+(?:select|navigate)\b|↑\s*\/\s*↓|↑\/↓/i;
+// A yes/no-flavored option — the hallmark of a real yes/no APPROVAL menu (Yes / No /
+// Allow / Deny / …) as opposed to an arbitrary multi-option CHOICE menu. The menu's
+// OPTIONS, not its question text, decide approval-vs-choice: an AskUserQuestion-style
+// menu can ask "...do you want to proceed?" (which matches the approval question regex)
+// yet offer several non-yes/no answers, and it must read as a choice — otherwise the
+// banner renders Approve/Deny (inject '1'/Esc) on it and the approval label path,
+// which hunts for a command, comes back blank.
+const CLAUDE_YESNO_OPTION_RE = /^\s*[❯▸›▶➤◆→]?\s*(?:\d+[.)]\s*)?(?:yes\b|no\b|allow\b|deny\b|approve\b|reject\b|proceed\b|cancel\b|accept\b|always\b|don'?t\b|keep planning\b)/i;
+const CLAUDE_YN_RE = /\(Y\/n\)\s*$/i;
+// The agent's free-text composer: a bare prompt line (›/❯/> with nothing typed).
+// Its presence BELOW an approval/choice anchor is the real "idle, awaiting text"
+// signal — the live approval widget REPLACES this composer. (The idle/working
+// FOOTER — "esc to interrupt", "? for shortcuts" — can still be painted beneath a
+// live approval, so footer presence alone must NOT veto. That blanket veto was the
+// cause of approval cards never appearing live until a restart re-rendered a frame
+// that happened to drop the footer from the captured tail.)
+const CLAUDE_EMPTY_COMPOSER_RE = /^(?:›|❯|>)\s*$/;
+
+// Negative gate: the idle/working composer footer (esc to interrupt, ? for
+// shortcuts, accept edits on …) is on screen, which a live approval widget would
+// have REPLACED — so the agent is at its ready composer, not blocked at a prompt.
+function detectReadyComposer(text) {
+  const lines = printableLines(text);
+  if (!lines.length) return false;
+  return lines.slice(-12).some(line => CLAUDE_IDLE_FOOTER_LINE_RE.test(line));
+}
+
+// "esc to interrupt" is the ONE footer phrase Claude shows exclusively while a
+// turn is generating (or a tool/shell it spawned is still running) — the genuinely
+// idle composer shows "? for shortcuts" / "auto mode on (shift+tab to cycle)" but
+// never "esc to interrupt". So its presence in the tail is decisive evidence the
+// agent is actively working, NOT idle awaiting input. server.js _idlePromptDetections
+// uses this to suppress the bare-`❯`-composer 'input' idle-notify during a long,
+// output-quiet tool turn (which otherwise mislabels the session "Needs You").
+const CLAUDE_GENERATING_FOOTER_RE = /\besc\s+to\s+interrupt\b/i;
+function detectActivelyGenerating(text) {
+  const lines = printableLines(text);
+  if (!lines.length) return false;
+  return lines.slice(-12).some(line => CLAUDE_GENERATING_FOOTER_RE.test(line));
+}
+
+// Positive "blocked at a live approval/choice widget" signal. Returns
+// {reason:'approval'|'choice'} only when a real widget is anchored in the active
+// prompt region and the ready-composer footer is absent; null otherwise.
+function detectWaitingInput(text) {
+  const raw = String(text || '');
+  if (!raw.trim()) return null;
+  const lines = printableLines(raw);
+  if (!lines.length) return null;
+  const tail = lines.slice(-14);
+  // Locate the anchors and the idle free-text composer by POSITION (closest to the
+  // bottom = the active element). A widget is live only when it is not sitting above
+  // a bare composer prompt (which would mean the agent already moved on and the
+  // widget is stale scrollback). Footer text is intentionally NOT consulted here.
+  let selIdx = -1, qIdx = -1, confIdx = -1, ynIdx = -1, composerIdx = -1;
+  let numberedOptCount = 0, lastNumberedOptIdx = -1, hasYesNoOption = false;
+  let hasMenuCursor = false, hasMenuNavFooter = false;
+  for (let i = 0; i < tail.length; i++) {
+    const line = tail[i];
+    if (CLAUDE_SELECTION_CURSOR_RE.test(line)) selIdx = i;
+    if (CLAUDE_APPROVAL_QUESTION_RE.test(line)) qIdx = i;
+    if (CLAUDE_CONFIRM_FOOTER_RE.test(line)) confIdx = i;
+    if (CLAUDE_YN_RE.test(line)) ynIdx = i;
+    if (CLAUDE_EMPTY_COMPOSER_RE.test(line)) composerIdx = i;
+    if (CLAUDE_MENU_NAV_FOOTER_RE.test(line)) hasMenuNavFooter = true;
+    if (CLAUDE_NUMBERED_OPTION_RE.test(line)) {
+      numberedOptCount += 1; lastNumberedOptIdx = i;
+      if (CLAUDE_YESNO_OPTION_RE.test(line)) hasYesNoOption = true;
+      if (CLAUDE_MENU_CURSOR_OPTION_RE.test(line)) hasMenuCursor = true;
+    }
+  }
+  // A multi-option numbered menu whose options are NOT yes/no-flavored is a CHOICE,
+  // even when its question matches the approval phrasing. A genuine yes/no approval
+  // (Yes/No options) keeps hasYesNoOption true and stays an approval below. Require a
+  // positive menu tell — a highlight cursor or a nav footer — so an enumerated PROSE
+  // findings list ("2. ... 3. ... 4. ...") is NOT mistaken for an interactive menu.
+  const multiChoiceMenu = numberedOptCount >= 2 && !hasYesNoOption &&
+    (hasMenuCursor || hasMenuNavFooter);
+  let approvalIdx = -1;
+  if (selIdx >= 0 && (qIdx >= 0 || confIdx >= 0)) approvalIdx = Math.max(selIdx, qIdx, confIdx);
+  else if (qIdx >= 0 && confIdx >= 0 && !multiChoiceMenu) approvalIdx = Math.max(qIdx, confIdx);
+  else if (ynIdx >= 0 && !multiChoiceMenu) approvalIdx = ynIdx;
+  // A bare composer BELOW the anchor ⇒ the widget is stale; the agent is idle at its
+  // composer. No composer-below ⇒ the widget is the live, active prompt.
+  if (approvalIdx >= 0 && !(composerIdx > approvalIdx)) return { reason: 'approval' };
+  // Choice: a highlighted yes/no-style selection cursor (selIdx) OR a non-yes/no
+  // numbered menu (anchored at its last option). Same composer-below staleness gate.
+  const choiceIdx = selIdx >= 0 ? selIdx : (multiChoiceMenu ? lastNumberedOptIdx : -1);
+  if (choiceIdx >= 0 && !(composerIdx > choiceIdx)) return { reason: 'choice' };
+  return null;
+}
+
+function isClaudeStatusRedraw(data) {
+  const stripped = stripAnsi(data).trim();
+  return (
+    stripped.length <= 160 &&
+    CLAUDE_STATUS_FRAGMENT_RE.test(stripped) &&
+    isClaudeRedraw(data)
   );
 }
 
@@ -28,14 +194,21 @@ module.exports = {
   // Base detector's TRIVIAL_CHUNK_RE already covers these.
   isActiveChunk(data) {
     if (!baseDetector.isActiveChunk(data)) return false;
-    const stripped = stripAnsi(data).trim();
-    if (
-      stripped.length <= 160 &&
-      isClaudeRedraw(data) &&
-      CLAUDE_STATUS_FRAGMENT_RE.test(stripped)
-    ) {
-      return false;
-    }
+    if (isClaudeIdlePromptRedraw(data) || isClaudeStatusRedraw(data)) return false;
     return true;
   },
+  isStatusOnlyChunk(data) {
+    return isClaudeIdlePromptRedraw(data) || isClaudeStatusRedraw(data);
+  },
+  isBusyStatusChunk() {
+    return false;
+  },
+  isClaudeIdlePromptRedraw,
+  detectWaitingInput,
+  detectReadyComposer,
+  detectActivelyGenerating,
+  _test: {
+    printableLines,
+    isClaudePassivePromptLine,
+  },
 };

package/template/claude-task-manager/workers/state-detectors/codex.js

@@ -11,12 +11,20 @@
 const { baseDetector, stripAnsi } = require('./base');
 
 const CODEX_STATUS_FRAGMENT_RE = /^[\s\d•◦·∙●○WwOoRrKkIiNnGg]+$/u;
-const CODEX_BUSY_STATUS_LINE_RE = /^(?:working(?:\s*\([^)]*\))?(?:\s*[•◦·∙●○]\s*esc\s+to\s+interrupt)?|(?:working\s*)?esc\s+to\s+interrupt)$/iu;
+const CODEX_BUSY_STATUS_LINE_RE = /^(?:(?:waiting\s+for\s+background\s+terminal\b.*)|working(?:\s*\([^)]*\))?(?:\s*[•◦·∙●○]\s*esc\s+to\s+interrupt)?|(?:working\s*)?esc\s+to\s+interrupt)$/iu;
 const CODEX_BUSY_COMPACT_STATUS_LINE_RE = /^working\s+(?:\d+(?::\d+){0,2}|\d+(?:\.\d+)?\s*(?:ms|s|sec|secs|m|min|mins|h|hr|hrs))$/iu;
 const CODEX_BUSY_WORD = 'working';
 const CODEX_BUSY_HINT_RE = /esc\s+to\s+interrupt/i;
+const CODEX_PROMPT_LINE_RE = /^(?:›|❯|>)\s*(?:\S.*)?$/;
+const CODEX_FOOTER_LINE_RE = /^(?:gpt|claude|codex|gemini|deepseek|kimi|moonshot|qwen|llama|mistral)[\w.+-]*(?:\s+[\w.+-]+){0,8}\s+[·-]\s+(?:~|\/|\.\.?\/)/i;
+const CODEX_SKILL_WARNING_RE = /^(?:⚠\s*)?Skipped loading\s+\d+\s+skill\(s\)\s+due to invalid SKILL\.md files\./i;
+const CODEX_SKILL_DESCRIPTION_RE = /^\/.*\/SKILL\.md:\s+invalid description:\s+exceeds maximum length of\s+\d+\s+characters$/i;
+// An approval/choice widget is pending — NOT a finished turn, even when the
+// model footer is still painted at the bottom of the screen.
+const CODEX_PENDING_PROMPT_RE = /Would you like to run the following command\?|Press enter to confirm or esc to cancel|tell Codex what to do differently|\b\d+\.\s*Yes\b/i;
 
 function hasCodexBusyStatusFragment(text) {
+  if (/waiting\s+for\s+background\s+terminal/i.test(String(text || ''))) return true;
   if (CODEX_BUSY_HINT_RE.test(String(text || ''))) return true;
   const letters = String(text || '').toLowerCase().replace(/[^a-z]/g, '');
   if (letters.length < 3) return false;
@@ -36,6 +44,105 @@ function isCursorAddressedRedraw(data) {
   ) || /\x1b\[\?2026h/.test(s);
 }
 
+function stripAnsiPreserveLines(data) {
+  return String(data || '')
+    .replace(/\x1b\[[0-9]+;[0-9]+[Hf]/g, '\n')
+    .replace(/\x1b\[[0-9]+[ABCD]/g, '\n')
+    .replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, '')
+    .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, '')
+    .replace(/\r/g, '\n')
+    .replace(/[\x00-\x09\x0b\x0c\x0e-\x1f\x7f]/g, '');
+}
+
+function printableLines(data) {
+  return stripAnsiPreserveLines(data)
+    .replace(/\u00a0/g, ' ')
+    .split(/\n+/)
+    .map(line => line.trim())
+    .filter(Boolean);
+}
+
+function isCodexPassiveDiagnosticChunk(data) {
+  const lines = printableLines(data);
+  return !!(lines.length && lines.every(line => (
+    CODEX_SKILL_WARNING_RE.test(line) ||
+    CODEX_SKILL_DESCRIPTION_RE.test(line)
+  )));
+}
+
+function isCodexIdlePromptRedraw(data) {
+  if (!isCursorAddressedRedraw(data)) return false;
+  const lines = printableLines(data);
+  if (!lines.length) return false;
+  const compact = lines.join(' ');
+  // A live busy status line ("Working (5s) • esc to interrupt") means still
+  // working — not an idle composer. Use the PRECISE per-line busy-status check
+  // (same as detectTurnFinished), NOT the loose 3-letter fragment matcher: this
+  // classifier already requires a full composer frame (prompt + footer), so a
+  // coalesced full-screen repaint carries the conversation history above the
+  // composer, and the loose matcher trips on ordinary words (coding / going /
+  // rendering / work → wor/ork/rki/ing). That false-busy match mis-scored the
+  // idle repaint as active and flipped idle Codex sessions to "Running".
+  if (lines.some(line => textHasCodexBusyStatus(line))) return false;
+  const hasPrompt = lines.some(line => CODEX_PROMPT_LINE_RE.test(line)) ||
+    /(?:^|\s)(?:›|❯|>)\s*\S/.test(compact);
+  if (!hasPrompt) return false;
+  const hasFooter = lines.some(line => CODEX_FOOTER_LINE_RE.test(line)) ||
+    /\b(?:gpt-[\w.-]+|claude|sonnet|opus|haiku|deepseek|gemini|qwen|llama|mistral|kimi|moonshot)\b/i.test(compact) &&
+      /(?:\b(?:x?high|medium|low|fast)\b|\s[-·]\s|[~/])/.test(compact);
+  return hasFooter;
+}
+
+// Positive "the turn is over" signal: Codex has repainted its ready composer
+// (prompt line + model footer) with NO live "Working… esc to interrupt" status
+// line. Unlike detectWaitingInput (which means Needs-You), this means the agent
+// finished and is idle. Server uses it to close the active turn so a finished
+// Codex session settles to Idle instead of riding the long open-turn hold.
+// Operates on viewport text (already stripped) or a raw ANSI tail.
+function detectTurnFinished(text) {
+  const raw = String(text || '');
+  if (!raw.trim()) return false;
+  if (CODEX_PENDING_PROMPT_RE.test(raw)) return false;
+  // printableLines preserves line structure (base.stripAnsi strips newlines, so
+  // a whole-buffer busy check would miss the status line). Check busy per line.
+  const lines = printableLines(raw);
+  if (!lines.length) return false;
+  // A live busy status line ("Working (5s) • esc to interrupt") means still
+  // working, even though the composer is also on screen.
+  if (lines.some(line => textHasCodexBusyStatus(line))) return false;
+  const hasPrompt = lines.some(line => CODEX_PROMPT_LINE_RE.test(line));
+  if (!hasPrompt) return false;
+  return lines.some(line => CODEX_FOOTER_LINE_RE.test(line));
+}
+
+// The unambiguous live Codex approval/confirm widgets — the actual interactive
+// prompt text, distinct from prose the agent may print. Kept narrow on purpose
+// (hide-unless-confident): the run-command question and the confirm footer are
+// real widget chrome; a numbered Yes/No PAIR is a menu. We deliberately do NOT
+// fire on "tell Codex/the model what to do differently" alone, since that line
+// also appears in the passive "Conversation interrupted" message after an Esc.
+const CODEX_RUN_APPROVAL_RE = /Would you like to run the following command\?/i;
+const CODEX_CONFIRM_WIDGET_RE = /Press enter to confirm or esc to cancel/i;
+const CODEX_YESNO_MENU_RE = /\b1\.\s*Yes\b[\s\S]{0,80}\b2\.\s*No\b/i;
+
+// Positive "the agent is blocked at a live approval/choice widget" signal.
+// Returns {reason:'approval'|'choice'} ONLY when a real widget is in the active
+// prompt region (bottom of the viewport) and the agent is not mid-work. Returns
+// null otherwise — an idle/finished composer is reported by detectTurnFinished,
+// not here. Operates on viewport text or a raw ANSI tail.
+function detectWaitingInput(text) {
+  const raw = String(text || '');
+  if (!raw.trim()) return null;
+  const lines = printableLines(raw);
+  if (!lines.length) return null;
+  // Still working ("Working (5s) • esc to interrupt") → not waiting on the user.
+  if (lines.some(line => textHasCodexBusyStatus(line))) return null;
+  const tail = lines.slice(-10).join('\n');
+  if (CODEX_RUN_APPROVAL_RE.test(tail)) return { reason: 'approval' };
+  if (CODEX_CONFIRM_WIDGET_RE.test(tail) || CODEX_YESNO_MENU_RE.test(tail)) return { reason: 'choice' };
+  return null;
+}
+
 function isCodexStatusRedraw(data) {
   const stripped = stripAnsi(data).trim();
   return (
@@ -61,6 +168,17 @@ function textHasCodexBusyStatus(text) {
   return clean.split('\n').some((line) => isCodexBusyStatusLine(line));
 }
 
+// The agent is mid-turn when its "Working… • esc to interrupt" status line (or a
+// background-terminal wait) is on screen. server.js's generating-gate uses this to
+// suppress the idle-notify so a long, output-quiet Codex turn whose composer matches
+// a global prompt pattern is not mislabeled "Needs You". Same signal Codex's own
+// detectWaitingInput/detectTurnFinished already trust.
+function detectActivelyGenerating(text) {
+  // Per line: base.stripAnsi (inside textHasCodexBusyStatus) drops newlines, so a
+  // whole-buffer call would miss the status line — mirror detectWaitingInput.
+  return printableLines(text).some((line) => textHasCodexBusyStatus(line));
+}
+
 module.exports = {
   ...baseDetector,
   id: 'codex',
@@ -73,17 +191,47 @@ module.exports = {
 
   isActiveChunk(data) {
     if (!baseDetector.isActiveChunk(data)) return false;
+    if (isCodexIdlePromptRedraw(data) || isCodexPassiveDiagnosticChunk(data)) return false;
     if (isCodexStatusRedraw(data)) {
+      // Tiny status-region redraws (≤160 chars of WORKING-alphabet content):
+      // keep the LOOSE fragment matcher — "Working" routinely splits across
+      // chunk boundaries ("king", "Wo7") and these fragments are the only
+      // busy signal while the tab is hidden. The alphabet pre-filter in
+      // isCodexStatusRedraw bounds the false-positive surface.
       return hasCodexBusyStatusFragment(stripAnsi(data).trim());
     }
+    if (isCursorAddressedRedraw(data)) {
+      // Positive-evidence rule: a cursor-addressed frame/region repaint is
+      // agent work ONLY when a live busy-status line is in it (strict
+      // per-line match — printableLines preserves the row structure that
+      // stripAnsi would flatten). Everything else — MCP startup status,
+      // welcome animation, update nudges, the history half of a split
+      // full-frame repaint — is TUI chrome an IDLE codex paints too, and one
+      // mis-scored chunk holds the sidebar on "Running" for the whole 15s
+      // codex hold. Genuine work keeps its busy row on screen and
+      // repainting, so per-chunk strictness costs nothing (split fragments
+      // are reassembled by the server's rolling busy-evidence buffer).
+      return detectActivelyGenerating(data);
+    }
     return true;
   },
   isStatusOnlyChunk(data) {
-    return isCodexStatusRedraw(data);
+    return isCodexStatusRedraw(data) ||
+      isCodexIdlePromptRedraw(data) ||
+      isCodexPassiveDiagnosticChunk(data) ||
+      (isCursorAddressedRedraw(data) && !detectActivelyGenerating(data));
   },
   isBusyStatusChunk(data) {
     return isCodexStatusRedraw(data) && textHasCodexBusyStatus(data);
   },
   hasCodexBusyStatusFragment,
   textHasCodexBusyStatus,
+  isCodexIdlePromptRedraw,
+  detectTurnFinished,
+  detectWaitingInput,
+  detectActivelyGenerating,
+  _test: {
+    printableLines,
+    isCodexPassiveDiagnosticChunk,
+  },
 };

package/template/claude-task-manager/workers/state-detectors/cursor.js

@@ -0,0 +1,127 @@
+'use strict';
+// Cursor (cursor-agent) TUI state detector.
+//
+// cursor-agent renders an interactive TUI: a prompt/composer region, a status
+// footer (model + workspace), and a spinner/status line while the model works.
+// Like OpenCode, it redraws those regions while sitting idle at the prompt, so
+// those frames must paint but must NOT be treated as model activity. Real tool
+// output, approval widgets, and "generating" status keep the session busy.
+//
+// The footer / prompt / busy regexes below are a grounded first cut; they are
+// tuned against live cursor-agent output during the dev verification pass.
+// Anything we don't recognize falls through to baseDetector, so an unmatched
+// frame is treated as activity (fail-safe: never wrongly idle a working agent).
+
+const { baseDetector } = require('./base');
+
+// Footer: model id + workspace path (e.g. "composer-2.5 · ~/ws/tools").
+const CURSOR_FOOTER_LINE_RE = /^(?:composer|gpt|claude|sonnet|opus|haiku|gemini|o\d|auto)[\w.+-]*(?:\s+[\w.+-]+){0,8}\s+[·|-]\s+(?:~|\/|\.\.?\/)/i;
+// Newer Cursor Agent builds render an idle welcome/composer frame with title,
+// version, help, model, and workspace lines split across rows. These are UI
+// chrome, not agent output, and selecting an idle tab can replay exactly this
+// frame.
+const CURSOR_STATIC_HEADER_LINE_RE = /^Cursor Agent$/i;
+const CURSOR_VERSION_LINE_RE = /^v\d{4}\.\d{2}\.\d{2}[-\w.]*$/i;
+const CURSOR_IDLE_HELP_LINE_RE = /^Use\s+\/plan\b.*\bbefore code changes\.?$/i;
+const CURSOR_IDLE_PLACEHOLDER_RE = /^(?:Plan,\s*)?search,\s*build anything$/i;
+const CURSOR_MODEL_LINE_RE = /^Composer\s+\d+(?:\.\d+)*(?:[-\w.]*)?(?:\s+\w+){0,3}$/i;
+const CURSOR_WORKSPACE_LINE_RE = /^(?:~|\/|\.\.?\/).+\s+[·|-]\s+[\w.+-]+$/;
+// Composer prompt glyphs.
+const CURSOR_PROMPT_LINE_RE = /^(?:>|›|❯|→|▌|\|)\s*(?:\S.*)?$/;
+// Spinner/status while the model is producing output. cursor-agent shows a
+// running verb plus an interrupt hint (esc/ctrl-c) while busy.
+const CURSOR_BUSY_LINE_RE = /^(?:[•●◦▪·*⠿⠷⠯⠟⠻⠽⠾]\s*)?(?:(?:Waiting\s+for\s+background\s+terminal\b.*)|(?:Composing|Generating|Thinking|Working|Reading|Writing|Editing|Running|Searching|Planning|Analyzing|Calling|Using|Processing|Reasoning|Applying|Streaming)\b.*\b(?:esc|interrupt|cancel|stop)\b)/i;
+// Passive status lines that should not hold the session busy.
+const CURSOR_PASSIVE_STATUS_LINE_RE = /^(?:[•●◦▪·*]\s*)?(?:Ready|Waiting|Idle|Stopped|Done|Complete|Completed|Accept|Reject|Run everything|Allowlist)\b/i;
+const CURSOR_CONTROL_HINT_RE = /^(?:esc|ctrl-c|ctrl\+c|tab|enter|press\s+enter)\b.*(?:interrupt|cancel|confirm|send|accept|reject|toggle)/i;
+
+function stripAnsiPreserveLines(data) {
+  return String(data || '')
+    // Cursor-addressed redraws otherwise collapse rows together after stripping
+    // CSI. Preserve row boundaries before removing control codes.
+    .replace(/\x1b\[[0-9]+;[0-9]+[Hf]/g, '\n')
+    .replace(/\x1b\[[0-9]+[ABCD]/g, '\n')
+    .replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, '')
+    .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, '')
+    .replace(/\r/g, '\n')
+    .replace(/[\x00-\x09\x0b\x0c\x0e-\x1f\x7f]/g, '');
+}
+
+function printableLines(data) {
+  return stripAnsiPreserveLines(data)
+    .replace(/\u00a0/g, ' ')
+    .split(/\n+/)
+    .map(line => line.trim())
+    .filter(Boolean);
+}
+
+function isCursorPassiveLine(line) {
+  const text = String(line || '').trim();
+  if (!text) return true;
+  return CURSOR_FOOTER_LINE_RE.test(text) ||
+    CURSOR_STATIC_HEADER_LINE_RE.test(text) ||
+    CURSOR_VERSION_LINE_RE.test(text) ||
+    CURSOR_IDLE_HELP_LINE_RE.test(text) ||
+    CURSOR_IDLE_PLACEHOLDER_RE.test(text) ||
+    CURSOR_MODEL_LINE_RE.test(text) ||
+    CURSOR_WORKSPACE_LINE_RE.test(text) ||
+    CURSOR_PROMPT_LINE_RE.test(text) ||
+    CURSOR_PASSIVE_STATUS_LINE_RE.test(text) ||
+    CURSOR_CONTROL_HINT_RE.test(text);
+}
+
+function isCursorBusyLine(line) {
+  return CURSOR_BUSY_LINE_RE.test(String(line || '').trim());
+}
+
+function detectWaitingInput(text) {
+  const lines = printableLines(text).slice(-10);
+  if (!lines.length) return null;
+  if (lines.some(isCursorBusyLine)) return null;
+  if (!lines.some(line => CURSOR_PROMPT_LINE_RE.test(line))) return null;
+  return { reason: 'input' };
+}
+
+// The agent is mid-turn when its busy/spinner line ("Generating… esc to interrupt")
+// is on screen. server.js's generating-gate uses this to suppress the idle-notify so
+// a long, output-quiet Cursor turn whose composer matches a global prompt pattern is
+// not mislabeled "Needs You". Tail-scoped so a stale spinner up in scrollback doesn't
+// count; same busy signal detectWaitingInput already gates on.
+function detectActivelyGenerating(text) {
+  return printableLines(text).slice(-12).some(isCursorBusyLine);
+}
+
+module.exports = {
+  ...baseDetector,
+  id: 'cursor',
+  // Cursor redraws prompt/footer regions periodically; hold the provider only
+  // for meaningful activity frames, mirroring the OpenCode debounce.
+  idleDebounceMs: 10000,
+
+  isActiveChunk(data) {
+    if (!baseDetector.isActiveChunk(data)) return false;
+    const lines = printableLines(data);
+    if (lines.length && lines.every(line => isCursorPassiveLine(line) && !isCursorBusyLine(line))) {
+      return false;
+    }
+    return true;
+  },
+
+  isStatusOnlyChunk(data) {
+    const lines = printableLines(data);
+    return !!(lines.length && lines.every(line => isCursorPassiveLine(line) || isCursorBusyLine(line)));
+  },
+
+  isBusyStatusChunk(data) {
+    const lines = printableLines(data);
+    return lines.some(isCursorBusyLine);
+  },
+
+  detectWaitingInput,
+  detectActivelyGenerating,
+  _test: {
+    printableLines,
+    isCursorPassiveLine,
+    isCursorBusyLine,
+  },
+};