create-walle 0.9.13 → 0.9.15

package/template/claude-task-manager/lib/session-stream.js

@@ -1,4 +1,5 @@
 'use strict';
+const crypto = require('crypto');
 const fsp = require('fs/promises');
 const EventEmitter = require('events');
 const { looksLikeCompactContinuation } = require('./compact-stitch');
@@ -312,11 +313,16 @@ class SessionStream extends EventEmitter {
     }
 
     if (!displayPromptEntry) displayPromptEntry = lastPromptEntry;
+    const promptSnapshot = this._promptCacheSnapshot(st);
+    const latestPrompt = this._buildPromptPayload(lastPromptEntry);
+    const displayPrompt = this._buildPromptPayload(displayPromptEntry);
     const summaryRecord = this._usableSummary(st.cachedSummary);
-    const summary = summaryRecord?.text || (st.cachedSummary?.model === 'fallback' ? st.cachedSummary.text : null);
-    const intent = this._buildIntent(summaryRecord, displayPromptEntry, lastPromptEntry);
+    const aiSummary = this._buildAiSummary(st.cachedSummary, summaryRecord, promptSnapshot, sessionId);
+    const currentTask = this._buildCurrentTask(aiSummary, latestPrompt, displayPrompt);
+    const summary = aiSummary.text || (st.cachedSummary?.model === 'fallback' ? st.cachedSummary.text : null);
+    const intent = this._buildIntent(currentTask, displayPromptEntry, lastPromptEntry);
     const progress = this._buildProgress(st, intent);
-    if (!summaryRecord && st.cachedSummary?.model === 'fallback') {
+    if (aiSummary.status === 'fallback' || aiSummary.status === 'stale' || aiSummary.status === 'rejected') {
       this._maybeRetryFallbackSummary(sessionId, st);
     }
 
@@ -328,6 +334,9 @@ class SessionStream extends EventEmitter {
       summarySource: summaryRecord?.model || null,
       lastPrompt: this._promptText(lastPromptEntry),
       displayPrompt: this._promptText(displayPromptEntry),
+      latestPrompt,
+      aiSummary,
+      currentTask,
       intent,
       progress,
       turnCount: mergedTurns.length,
@@ -658,6 +667,29 @@ class SessionStream extends EventEmitter {
   }
 
   _processCodexEntry(agentSessionId, st, entry) {
+    if (entry?.type === 'event_msg' && entry.payload?.type === 'task_complete' && entry.payload.last_agent_message) {
+      const timestamp = eventTimestampMs(entry);
+      const rawText = String(entry.payload.last_agent_message || '').trim();
+      const text = rawText.length > MAX_TEXT_LEN ? rawText.slice(0, MAX_TEXT_LEN) + `...truncated (${rawText.length} chars)` : rawText;
+      const evt = decorateStreamEvent({
+        type: 'turn_complete',
+        sessionId: agentSessionId,
+        ctmSessionId: st.ctmSessionId,
+        timestamp,
+        seq: st.seq++,
+        data: {
+          text,
+          turnId: entry.payload.turn_id || '',
+          durationMs: entry.payload.duration_ms || 0,
+        },
+      }, 'codex-jsonl');
+      // Do not append this lifecycle event to the ring buffer. The latest
+      // assistant message should remain the status/summary anchor; this event
+      // exists for Codex terminal recovery subscribers.
+      this._emitEvent(agentSessionId, evt);
+      return true;
+    }
+
     const msg = codexMessageFromEntry(entry);
     if (!msg) return false;
 
@@ -755,6 +787,42 @@ class SessionStream extends EventEmitter {
     return Number.isFinite(entry.timestamp) ? entry.timestamp : 0;
   }
 
+  _buildPromptPayload(entry) {
+    const text = this._promptText(entry);
+    const timestamp = this._promptTimestamp(entry);
+    return {
+      text: text || null,
+      timestamp,
+      isContentRich: this._isContentRich(text),
+    };
+  }
+
+  _promptCacheSnapshot(st) {
+    const entries = (st?.userPromptCache || [])
+      .filter(entry => this._promptText(entry))
+      .map(entry => ({
+        text: this._promptText(entry),
+        timestamp: this._promptTimestamp(entry),
+      }));
+    const prompts = entries.map(entry => entry.text);
+    const latestEntry = entries[entries.length - 1] || null;
+    return {
+      entries,
+      prompts,
+      latestEntry,
+      latestText: latestEntry?.text || '',
+      latestTimestamp: latestEntry?.timestamp || 0,
+      promptCount: prompts.length,
+      promptHash: this._promptCacheHash(prompts),
+    };
+  }
+
+  _promptCacheHash(prompts) {
+    const list = Array.isArray(prompts) ? prompts.filter(Boolean) : [];
+    if (list.length === 0) return '';
+    return crypto.createHash('sha1').update(list.join('\u0000')).digest('hex');
+  }
+
   _computeStatus(st) {
     const now = Date.now();
     // PTY activity within 5s = running
@@ -904,18 +972,150 @@ class SessionStream extends EventEmitter {
     return false;
   }
 
-  _buildIntent(summaryRecord, displayPromptEntry, lastPromptEntry) {
-    const promptEntry = displayPromptEntry || lastPromptEntry;
-    const promptText = this._promptText(promptEntry);
+  _buildAiSummary(cachedSummary, summaryRecord, promptSnapshot, agentSessionId) {
+    const timerPending = this._summaryTimers.has(agentSessionId);
+    const latestTimestamp = promptSnapshot?.latestTimestamp || 0;
+    const currentHash = promptSnapshot?.promptHash || '';
+    const currentCount = promptSnapshot?.promptCount || 0;
+
     if (summaryRecord?.text) {
+      const coveredTimestamp = Number.isFinite(summaryRecord.promptTimestamp)
+        ? summaryRecord.promptTimestamp
+        : (summaryRecord.timestamp || 0);
+      const hasHash = !!summaryRecord.promptHash;
+      const fresh = hasHash
+        ? summaryRecord.promptHash === currentHash
+        : (!latestTimestamp || (summaryRecord.timestamp || 0) >= latestTimestamp);
+      const status = fresh ? 'fresh' : (timerPending ? 'updating' : 'stale');
       return {
         text: summaryRecord.text,
         source: 'ai-summary',
-        confidence: 'high',
-        prompt: promptText || null,
-        fullPrompt: promptText || null,
-        timestamp: this._promptTimestamp(promptEntry),
+        status,
+        freshness: status,
+        model: summaryRecord.model || null,
         updatedAt: summaryRecord.timestamp || 0,
+        promptTimestamp: coveredTimestamp || 0,
+        promptCount: summaryRecord.promptCount || summaryRecord.turnCount || 0,
+        currentPromptCount: currentCount,
+        promptHash: summaryRecord.promptHash || null,
+      };
+    }
+
+    if (cachedSummary?.model === 'fallback') {
+      return {
+        text: this._sanitizeSummary(cachedSummary.text || '') || null,
+        source: 'fallback',
+        status: timerPending ? 'updating' : 'fallback',
+        freshness: timerPending ? 'updating' : 'fallback',
+        model: 'fallback',
+        updatedAt: cachedSummary.timestamp || 0,
+        promptTimestamp: cachedSummary.promptTimestamp || 0,
+        promptCount: cachedSummary.promptCount || cachedSummary.turnCount || 0,
+        currentPromptCount: currentCount,
+        promptHash: cachedSummary.promptHash || null,
+      };
+    }
+
+    if (cachedSummary && cachedSummary.model) {
+      return {
+        text: null,
+        source: 'ai-summary',
+        status: 'rejected',
+        freshness: 'rejected',
+        model: cachedSummary.model || null,
+        updatedAt: cachedSummary.timestamp || 0,
+        promptTimestamp: cachedSummary.promptTimestamp || 0,
+        promptCount: cachedSummary.promptCount || cachedSummary.turnCount || 0,
+        currentPromptCount: currentCount,
+        promptHash: cachedSummary.promptHash || null,
+      };
+    }
+
+    return {
+      text: null,
+      source: 'none',
+      status: timerPending ? 'updating' : 'missing',
+      freshness: timerPending ? 'updating' : 'missing',
+      model: null,
+      updatedAt: 0,
+      promptTimestamp: 0,
+      promptCount: 0,
+      currentPromptCount: currentCount,
+      promptHash: null,
+    };
+  }
+
+  _buildCurrentTask(aiSummary, latestPrompt, displayPrompt) {
+    const freshAi = aiSummary?.text && aiSummary.status === 'fresh';
+    const prompt = (latestPrompt?.isContentRich || !displayPrompt?.text)
+      ? latestPrompt
+      : displayPrompt;
+    const promptText = prompt?.text || null;
+    const promptTimestamp = prompt?.timestamp || 0;
+
+    if (freshAi) {
+      return {
+        text: aiSummary.text,
+        source: 'ai-summary',
+        confidence: 'high',
+        freshness: 'fresh',
+        prompt: promptText,
+        fullPrompt: promptText,
+        timestamp: promptTimestamp,
+        promptTimestamp,
+        updatedAt: aiSummary.updatedAt || 0,
+        aiUpdatedAt: aiSummary.updatedAt || 0,
+      };
+    }
+
+    if (promptText) {
+      const staleAiPresent = aiSummary?.source === 'ai-summary' && aiSummary?.text && aiSummary.status !== 'fresh';
+      const source = staleAiPresent && prompt === latestPrompt ? 'latest-prompt' : 'prompt-fallback';
+      const freshness = staleAiPresent
+        ? (aiSummary.status === 'updating' ? 'updating' : 'stale')
+        : (aiSummary?.status === 'updating' ? 'updating' : 'fallback');
+      return {
+        text: promptText,
+        source,
+        confidence: this._isContentRich(promptText) ? 'medium' : 'low',
+        freshness,
+        prompt: promptText,
+        fullPrompt: promptText,
+        timestamp: promptTimestamp,
+        promptTimestamp,
+        updatedAt: promptTimestamp,
+        aiUpdatedAt: aiSummary?.updatedAt || 0,
+      };
+    }
+
+    return {
+      text: null,
+      source: 'missing',
+      confidence: 'low',
+      freshness: aiSummary?.status || 'missing',
+      prompt: null,
+      fullPrompt: null,
+      timestamp: 0,
+      promptTimestamp: 0,
+      updatedAt: 0,
+      aiUpdatedAt: aiSummary?.updatedAt || 0,
+    };
+  }
+
+  _buildIntent(currentTask, displayPromptEntry, lastPromptEntry) {
+    const promptEntry = displayPromptEntry || lastPromptEntry;
+    const promptText = this._promptText(promptEntry);
+    if (currentTask?.text) {
+      return {
+        text: currentTask.text,
+        source: currentTask.source || 'missing',
+        confidence: currentTask.confidence || 'low',
+        freshness: currentTask.freshness || 'missing',
+        prompt: currentTask.prompt || promptText || null,
+        fullPrompt: currentTask.fullPrompt || promptText || null,
+        timestamp: currentTask.timestamp || this._promptTimestamp(promptEntry),
+        updatedAt: currentTask.updatedAt || currentTask.timestamp || 0,
+        aiUpdatedAt: currentTask.aiUpdatedAt || 0,
       };
     }
     if (promptText) {
@@ -923,20 +1123,24 @@ class SessionStream extends EventEmitter {
         text: promptText,
         source: 'prompt-fallback',
         confidence: this._isContentRich(promptText) ? 'medium' : 'low',
+        freshness: 'fallback',
         prompt: promptText,
         fullPrompt: promptText,
         timestamp: this._promptTimestamp(promptEntry),
         updatedAt: this._promptTimestamp(promptEntry),
+        aiUpdatedAt: 0,
       };
     }
     return {
       text: null,
       source: 'missing',
       confidence: 'low',
+      freshness: 'missing',
       prompt: null,
       fullPrompt: null,
       timestamp: 0,
       updatedAt: 0,
+      aiUpdatedAt: 0,
     };
   }
 
@@ -1056,12 +1260,9 @@ class SessionStream extends EventEmitter {
 
   async _generateSummary(agentSessionId, st) {
     st.lastSummaryAttempt = Date.now();
-    // Use userPromptCache (survives ring buffer churn from tool_result-only events)
-    const userPrompts = st.userPromptCache.map((entry) => this._promptText(entry)).filter(Boolean);
-    if (userPrompts.length === 0) return;
-
-    const turnsText = userPrompts.map((t, i) => `Prompt ${i + 1}: ${t}`).join('\n');
-    const sysPrompt = 'Summarize what the user is working on based on their prompts. 10-15 words. Return ONLY the summary, no quotes or prefix.';
+    const summaryInput = this._buildSummaryInput(st);
+    if (!summaryInput) return;
+    const { turnsText, sysPrompt, promptSnapshot } = summaryInput;
 
     // Tier 0: configured Wall-E provider (DeepSeek/OpenAI/Claude/Gemini/etc.).
     let summaryText = '';
@@ -1085,7 +1286,10 @@ class SessionStream extends EventEmitter {
     if (summaryText) {
       st.cachedSummary = {
         text: truncateText(summaryText, SUMMARY_TEXT_LIMIT),
-        turnCount: userPrompts.length,
+        turnCount: promptSnapshot.promptCount,
+        promptCount: promptSnapshot.promptCount,
+        promptHash: promptSnapshot.promptHash,
+        promptTimestamp: promptSnapshot.latestTimestamp || 0,
         model: usedModel,
         timestamp: Date.now(),
       };
@@ -1102,10 +1306,31 @@ class SessionStream extends EventEmitter {
       this._emitEvent(agentSessionId, summaryEvt);
     } else {
       // Tier 3: heuristic fallback — picks the most recent content-rich prompt
-      st.cachedSummary = this._fallbackSummary(userPrompts);
+      st.cachedSummary = this._fallbackSummary(promptSnapshot.prompts, promptSnapshot);
     }
   }
 
+  _buildSummaryInput(st) {
+    const promptSnapshot = this._promptCacheSnapshot(st);
+    if (promptSnapshot.prompts.length === 0) return null;
+
+    const latest = promptSnapshot.latestText;
+    const recentContext = promptSnapshot.prompts.slice(0, -1).slice(-3);
+    const parts = ['Latest prompt:', latest];
+    if (recentContext.length) {
+      parts.push('', 'Recent context:');
+      recentContext.forEach((text, idx) => {
+        parts.push(`${idx + 1}. ${text}`);
+      });
+    }
+
+    return {
+      turnsText: parts.join('\n'),
+      sysPrompt: "Summarize the user's current task. Prioritize the latest prompt. Use older prompts only as context. Return 8-14 words. Return only the summary, no quotes or prefix.",
+      promptSnapshot,
+    };
+  }
+
   /** Tier 0: CTM-injected Wall-E provider. Returns { text, model } or null. */
   async _tryConfiguredSummary(turnsText, sysPrompt) {
     if (!this._summaryProvider) return null;
@@ -1205,12 +1430,20 @@ class SessionStream extends EventEmitter {
     } catch { return null; }
   }
 
-  _fallbackSummary(userPrompts) {
+  _fallbackSummary(userPrompts, promptSnapshot = null) {
     // Prefer a content-rich prompt over the latest one — "/cmd yes go ahead"
     // tells the user nothing about what the session is doing.
     const picked = this._pickContentRichPrompt(userPrompts) || userPrompts[userPrompts.length - 1] || '';
     const text = this._sanitizeSummary(picked.split('\n')[0].slice(0, 80));
-    return { text, turnCount: userPrompts.length, model: 'fallback', timestamp: Date.now() };
+    return {
+      text,
+      turnCount: userPrompts.length,
+      promptCount: promptSnapshot?.promptCount || userPrompts.length,
+      promptHash: promptSnapshot?.promptHash || this._promptCacheHash(userPrompts),
+      promptTimestamp: promptSnapshot?.latestTimestamp || 0,
+      model: 'fallback',
+      timestamp: Date.now(),
+    };
   }
 
   /**

package/template/claude-task-manager/lib/standup-attention.js

@@ -0,0 +1,200 @@
+'use strict';
+
+const crypto = require('crypto');
+
+const STICKY_ATTENTION_MS = 12 * 60 * 60 * 1000;
+
+function compactText(value) {
+  if (!value) return '';
+  if (typeof value === 'string') return value.replace(/\s+/g, ' ').trim();
+  if (typeof value === 'object') {
+    return compactText(value.text || value.summary || value.phase || value.next || value.reason || '');
+  }
+  return String(value).replace(/\s+/g, ' ').trim();
+}
+
+function truncateText(value, max = 700) {
+  const text = compactText(value);
+  if (text.length <= max) return text;
+  return `${text.slice(0, Math.max(0, max - 1)).trim()}...`;
+}
+
+function normalizeSeverity(value) {
+  const text = String(value || '').toLowerCase().trim();
+  if (text === 'failure' || text === 'fail' || text === 'blocked' || text === 'blocker') return 'failure';
+  if (text === 'warning' || text === 'warn' || text === 'caution' || text === 'risk') return 'warning';
+  return 'none';
+}
+
+function normalizeConfidence(value) {
+  const text = String(value || '').toLowerCase().trim();
+  if (text === 'high' || text === 'medium' || text === 'low') return text;
+  return 'medium';
+}
+
+function normalizeAttention(value, defaults = {}) {
+  if (!value || typeof value !== 'object') return null;
+  const severity = normalizeSeverity(value.severity || value.level || value.kind);
+  const recommendation = truncateText(
+    value.recommendation || value.reason || value.summary || defaults.recommendation || '',
+    220
+  );
+  const evidence = Array.isArray(value.evidence)
+    ? value.evidence.map(item => truncateText(item, 100)).filter(Boolean).slice(0, 3)
+    : [];
+  return {
+    severity,
+    actionLabel: severity === 'failure' ? 'Inspect' : severity === 'warning' ? 'Review' : '',
+    recommendation: recommendation || defaultRecommendation(severity),
+    confidence: normalizeConfidence(value.confidence || defaults.confidence),
+    evidence,
+    source: value.source || defaults.source || 'unknown',
+    model: value.model || defaults.model || '',
+    updatedAt: value.updatedAt || defaults.updatedAt || null,
+    sticky: !!value.sticky,
+  };
+}
+
+function defaultRecommendation(severity) {
+  if (severity === 'failure') return 'A current blocker or failure appears to need attention.';
+  if (severity === 'warning') return 'A current warning appears to need attention.';
+  return '';
+}
+
+function attentionContextHash(text) {
+  return crypto.createHash('sha1').update(String(text || '')).digest('hex');
+}
+
+function buildStandupAttentionContext({ session = {}, summary = {}, status = {} } = {}) {
+  const evidence = Array.isArray(summary.statusEvidence) ? summary.statusEvidence : [];
+  const progress = summary.progress || {};
+  const lines = [
+    `Title: ${compactText(session.label || summary.displayPrompt || summary.lastPrompt || session.id || '')}`,
+    `Agent: ${compactText(session.agentType || session.agent || session.type || '')}`,
+    `Status: ${compactText(session.standupStatus || session.liveStatus || session.serverState || status.status || summary.status || '')}`,
+    `Waiting: ${compactText(session.waitingReason || status.reason || '')}`,
+    `Intent: ${compactText(summary.intent || summary.displayPrompt || summary.lastPrompt || '')}`,
+    `Summary: ${compactText(summary.summary || '')}`,
+    `Progress: ${compactText(progress)}`,
+    `Evidence: ${evidence.map(compactText).filter(Boolean).join('; ')}`,
+  ].filter(line => !/:\s*$/.test(line));
+  const text = truncateText(lines.join('\n'), 2500);
+  return {
+    text,
+    hash: attentionContextHash(text),
+    hasAttentionLanguage: hasAttentionLanguage(text),
+  };
+}
+
+function hasAttentionLanguage(text) {
+  return /\b(warn(?:ing|ed)?|caution|risk|blocked|blocker|failed|failing|failure|error|exception|permission denied|cannot proceed|stuck|needs attention)\b/i.test(String(text || ''));
+}
+
+function hasResolutionSignal(text) {
+  return /\b(resolved|fixed|cleared|no longer|not blocked|not a blocker|no blockers?|not a failure|no failures?|not an error|no errors?|no warnings?|unblocked|passed|verified|working now|succeeded|successful|recovered)\b/i.test(String(text || ''));
+}
+
+function heuristicStandupAttention(context) {
+  const text = String(context?.text || context || '');
+  const lower = text.toLowerCase();
+  const resolved = hasResolutionSignal(lower);
+  const hardFailure = /\b(cannot proceed|blocked|blocker|stuck|permission denied|fatal|panic|segmentation fault|uncaught|unhandled exception|traceback|command failed|build failed|tests? failed|npm err!)\b/i.test(lower);
+  const warning = /\b(warn(?:ing|ed)?|caution|risk|heads up|possible issue|needs attention)\b/i.test(lower);
+  const weakFailure = /\b(failed|failing|failure|error|exception)\b/i.test(lower);
+
+  if (resolved && !warning && !hardFailure) {
+    return normalizeAttention({ severity: 'none', source: 'heuristic', confidence: 'medium' });
+  }
+  if (hardFailure && !resolved) {
+    return normalizeAttention({
+      severity: 'failure',
+      recommendation: 'A current blocker or failure appears to need attention.',
+      evidence: [firstMatchingPhrase(text, /(cannot proceed|blocked|blocker|stuck|permission denied|fatal|unhandled exception|command failed|build failed|tests? failed)/i)],
+      source: 'heuristic',
+      confidence: 'medium',
+    });
+  }
+  if (warning) {
+    return normalizeAttention({
+      severity: 'warning',
+      recommendation: 'A current warning appears to need attention.',
+      evidence: [firstMatchingPhrase(text, /(warn(?:ing|ed)?|caution|risk|possible issue|needs attention)/i)],
+      source: 'heuristic',
+      confidence: 'medium',
+    });
+  }
+  if (weakFailure && !resolved) {
+    return normalizeAttention({
+      severity: 'warning',
+      recommendation: 'Failure or error language appears in the latest context; review whether it is still relevant.',
+      evidence: [firstMatchingPhrase(text, /(failed|failing|failure|error|exception)/i)],
+      source: 'heuristic',
+      confidence: 'low',
+    });
+  }
+  return normalizeAttention({ severity: 'none', source: 'heuristic', confidence: 'medium' });
+}
+
+function firstMatchingPhrase(text, regex) {
+  const match = String(text || '').match(regex);
+  return match ? match[0] : '';
+}
+
+function parseStandupAttentionResult(text, defaults = {}) {
+  const raw = String(text || '').trim();
+  if (!raw) return null;
+  const cleaned = raw
+    .replace(/^```(?:json)?\s*/i, '')
+    .replace(/\s*```$/i, '')
+    .trim();
+  const start = cleaned.indexOf('{');
+  const end = cleaned.lastIndexOf('}');
+  if (start === -1 || end === -1 || end <= start) return null;
+  try {
+    return normalizeAttention(JSON.parse(cleaned.slice(start, end + 1)), defaults);
+  } catch {
+    return null;
+  }
+}
+
+function mergeStickyStandupAttention(previous, next, contextText, now = Date.now(), opts = {}) {
+  const stickyMs = Number.isFinite(opts.stickyMs) ? opts.stickyMs : STICKY_ATTENTION_MS;
+  const normalizedNext = normalizeAttention(next, { updatedAt: new Date(now).toISOString() })
+    || normalizeAttention({ severity: 'none', source: 'none' }, { updatedAt: new Date(now).toISOString() });
+  const normalizedPrevious = normalizeAttention(previous);
+
+  if (normalizedNext.severity === 'failure' || normalizedNext.severity === 'warning') {
+    return {
+      ...normalizedNext,
+      updatedAt: normalizedNext.updatedAt || new Date(now).toISOString(),
+      sticky: false,
+    };
+  }
+
+  if (!normalizedPrevious || !['failure', 'warning'].includes(normalizedPrevious.severity)) {
+    return normalizedNext;
+  }
+
+  if (hasResolutionSignal(contextText)) return normalizedNext;
+
+  const previousMs = Date.parse(normalizedPrevious.updatedAt || '') || now;
+  if (now - previousMs > stickyMs) return normalizedNext;
+
+  return {
+    ...normalizedPrevious,
+    updatedAt: normalizedPrevious.updatedAt || new Date(now).toISOString(),
+    sticky: true,
+  };
+}
+
+module.exports = {
+  STICKY_ATTENTION_MS,
+  buildStandupAttentionContext,
+  hasAttentionLanguage,
+  hasResolutionSignal,
+  heuristicStandupAttention,
+  mergeStickyStandupAttention,
+  normalizeAttention,
+  normalizeSeverity,
+  parseStandupAttentionResult,
+};

package/template/claude-task-manager/lib/status-hooks.js

@@ -12,12 +12,18 @@
 const { SessionStateBus } = require('./session-state-bus');
 const { runHook, buildHookEnv } = require('./hook-executor');
 const { resolveHooks, commandForState } = require('./status-hooks-config');
+const { listStateDetectors } = require('../workers/state-detectors');
 
 const _sessionMeta = new Map(); // sessionId -> { providerId, cwd, branch, tabTitle }
 
 const bus = new SessionStateBus();
-// Default per the user spec: 1500ms for Claude Code (gap #4).
-bus.setProviderDebounce('claude-code', 1500);
+// Default per the user spec: 1500ms for Claude Code (gap #4). Provider
+// detectors can widen this for bursty TUIs such as Codex.
+for (const detector of listStateDetectors()) {
+  if (detector && Number.isFinite(detector.idleDebounceMs)) {
+    bus.setProviderDebounce(detector.providerId, detector.idleDebounceMs);
+  }
+}
 bus.setDefaultDebounce(1500);
 
 let _dbModule = null;