create-walle 0.9.13 → 0.9.14

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

@@ -0,0 +1,409 @@
+'use strict';
+
+const { normalizeAttention } = require('./standup-attention');
+
+const LANE_DEFS = [
+  {
+    id: 'needs_user',
+    title: 'Needs User',
+    description: 'Approvals, questions, blockers, or failed work that need operator attention.',
+  },
+  {
+    id: 'ready_review',
+    title: 'Ready Review',
+    description: 'Sessions with reviewable work, finished changes, or worktree cleanup to handle.',
+  },
+  {
+    id: 'running',
+    title: 'Running',
+    description: 'Active sessions that are still producing work.',
+  },
+  {
+    id: 'continue_later',
+    title: 'Continue Later',
+    description: 'Idle sessions worth preserving for context reuse.',
+  },
+];
+
+const LANE_ORDER = new Map(LANE_DEFS.map((lane, index) => [lane.id, index]));
+const STALE_AFTER_MS = 30 * 60 * 1000;
+
+function truncateText(value, max = 180) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  if (!text) return '';
+  if (text.length <= max) return text;
+  return `${text.slice(0, Math.max(0, max - 1)).trim()}...`;
+}
+
+function valueText(value) {
+  if (!value) return '';
+  if (typeof value === 'string') return value;
+  if (typeof value === 'object') {
+    return value.text || value.summary || value.phase || value.next || '';
+  }
+  return String(value);
+}
+
+function progressText(progress) {
+  if (!progress) return '';
+  if (typeof progress === 'string') return progress;
+  if (typeof progress === 'object') {
+    return progress.summary || progress.next || progress.phase || '';
+  }
+  return String(progress);
+}
+
+function toMs(value) {
+  if (!value) return 0;
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  const parsed = Date.parse(String(value));
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function toIso(value) {
+  const ms = toMs(value);
+  return ms ? new Date(ms).toISOString() : null;
+}
+
+function ageLabel(now, value) {
+  const ms = toMs(value);
+  if (!ms) return '';
+  const age = Math.max(0, now - ms);
+  if (age < 60 * 1000) return 'just now';
+  const minutes = Math.round(age / (60 * 1000));
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 48) return `${hours}h ago`;
+  const days = Math.round(hours / 24);
+  return `${days}d ago`;
+}
+
+function normalizeStatus(status) {
+  const text = String(status || '').toLowerCase();
+  if (!text) return 'unknown';
+  if (text === 'busy') return 'running';
+  if (text === 'waiting_input') return 'waiting_input';
+  if (text === 'waiting-for-input') return 'waiting';
+  if (['running', 'waiting', 'idle', 'exited', 'unknown'].includes(text)) return text;
+  return text;
+}
+
+function addIndexEntries(map, item) {
+  if (!item || typeof item !== 'object') return;
+  for (const key of ['id', 'sessionId', 'ctmSessionId', 'agentSessionId', 'claudeSessionId']) {
+    const value = item[key];
+    if (value) map.set(String(value), item);
+  }
+}
+
+function buildIndex(items) {
+  const map = new Map();
+  for (const item of items || []) addIndexEntries(map, item);
+  return map;
+}
+
+function lookupForSession(index, session) {
+  if (!index || !session) return null;
+  const ids = [
+    session.id,
+    session.sessionId,
+    session.ctmSessionId,
+    session.agentSessionId,
+    session.claudeSessionId,
+  ];
+  for (const id of ids) {
+    if (id && index.has(String(id))) return index.get(String(id));
+  }
+  return null;
+}
+
+function statusForSession(session, status, summary) {
+  if (session?.waitingForInput) return 'waiting_input';
+  const candidates = [
+    session?.standupStatus,
+    session?.liveStatus,
+    session?.computedStatus,
+    session?.state,
+    status?.captureStatus,
+    status?.status,
+    summary?.captureStatus,
+    summary?.status,
+    session?.serverState,
+    session?.status,
+  ];
+  for (const candidate of candidates) {
+    const normalized = normalizeStatus(candidate);
+    if (normalized && normalized !== 'unknown') return normalized;
+  }
+  return 'unknown';
+}
+
+function isWalleSession(session) {
+  return session?.type === 'walle' || session?.agentType === 'walle' || session?.agent === 'walle';
+}
+
+function standupStatusForSession(session, status, summary) {
+  const normalized = statusForSession(session, status, summary);
+  // A quiet Wall-E chat is available for the next message, not blocked on
+  // operator input. Older live projections used "waiting" for that idle state.
+  if (normalized === 'waiting' && isWalleSession(session) && !session?.waitingForInput) return 'idle';
+  return normalized;
+}
+
+function worktreeEvidence(worktree) {
+  if (!worktree) return '';
+  const dirtyFiles = Number(worktree.dirtyFiles || 0);
+  const unmergedCommits = Number(worktree.unmergedCommits || 0);
+  const parts = [];
+  if (dirtyFiles) parts.push(`${dirtyFiles} dirty`);
+  if (unmergedCommits) parts.push(`${unmergedCommits} unmerged`);
+  if (!parts.length && worktree.summary) parts.push(worktree.summary);
+  return parts.length ? `worktree ${parts.join(', ')}` : '';
+}
+
+function hasReviewableWork(session, summaryText, progress) {
+  const worktree = session?.worktreeStatus || session?.worktree || null;
+  if (worktree) {
+    if (worktree.needsAttention) return true;
+    if (Number(worktree.dirtyFiles || 0) > 0) return true;
+    if (Number(worktree.unmergedCommits || 0) > 0) return true;
+  }
+  const text = `${summaryText || ''} ${progressText(progress)}`.toLowerCase();
+  return /\b(done|completed|complete|verified|passed|ready for review|all work done)\b/.test(text);
+}
+
+function hasFailureSignal(summaryText, progress) {
+  const text = `${summaryText || ''} ${progressText(progress)}`.toLowerCase();
+  return /\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/.test(text);
+}
+
+function attentionForSession(session, summary) {
+  return normalizeAttention(summary?.attention || session?.attention || null);
+}
+
+function prependEvidence(evidence, items) {
+  const out = [];
+  for (const item of items || []) {
+    const text = truncateText(item, 90);
+    if (text && !out.some(existing => existing.toLowerCase() === text.toLowerCase())) out.push(text);
+  }
+  for (const item of evidence || []) {
+    const text = truncateText(item, 90);
+    if (text && !out.some(existing => existing.toLowerCase() === text.toLowerCase())) out.push(text);
+  }
+  return out.slice(0, 5);
+}
+
+function baseEvidence({ session, status, summary, now, intentText, progress }) {
+  const evidence = [];
+  if (status === 'waiting_input') evidence.push('waiting input');
+  else if (status === 'waiting') evidence.push('waiting');
+  else if (status === 'running') evidence.push('running');
+  const branch = session?.branch || session?.gitBranch || session?.worktreeStatus?.branch || '';
+  if (branch) evidence.push(`branch ${branch}`);
+  const wtEvidence = worktreeEvidence(session?.worktreeStatus || session?.worktree);
+  if (wtEvidence) evidence.push(wtEvidence);
+  const age = ageLabel(now, latestActivity(session, summary));
+  if (age) evidence.push(`last activity ${age}`);
+  if (intentText && summary?.intent?.source === 'prompt-fallback') {
+    evidence.push(`prompt: ${truncateText(intentText, 80)}`);
+  }
+  const progressPhase = progress && typeof progress === 'object' ? progress.phase : '';
+  if (progressPhase && !['unknown', status].includes(String(progressPhase))) {
+    evidence.push(`phase ${progressPhase}`);
+  }
+  return evidence.slice(0, 5);
+}
+
+function latestActivity(session, summary) {
+  const values = [
+    summary?.lastActivity,
+    summary?.progress?.updatedAt,
+    summary?.intent?.updatedAt,
+    session?.lastPtyActivity,
+    session?.lastActivity,
+    session?.modifiedAt,
+    session?.fileModifiedAt,
+    session?.createdAt,
+  ];
+  let latest = 0;
+  for (const value of values) {
+    const ms = toMs(value);
+    if (ms > latest) latest = ms;
+  }
+  return latest;
+}
+
+function classifySessionStandup(session, signals = {}, now = Date.now()) {
+  const summary = signals.summary || {};
+  const streamStatus = signals.status || {};
+  const status = standupStatusForSession(session, streamStatus, summary);
+  const intent = summary.intent || summary.summary || summary.displayPrompt || summary.lastPrompt || session?.label || '';
+  const intentString = truncateText(valueText(intent), 160);
+  const progress = summary.progress || '';
+  const progressString = truncateText(progressText(progress), 180);
+  const summaryText = valueText(summary.summary) || intentString;
+  const lastActivityMs = latestActivity(session, summary);
+  const ageMs = lastActivityMs ? Math.max(0, now - lastActivityMs) : null;
+  const waitingReason = session?.waitingReason || streamStatus?.reason || summary?.statusEvidence?.[0] || '';
+  const reviewable = hasReviewableWork(session, summaryText, progress);
+  const attention = attentionForSession(session, summary);
+  const hasStructuredAttention = !!(summary?.attention || session?.attention);
+  const attentionSeverity = attention?.severity || 'none';
+  const failed = attentionSeverity === 'failure'
+    || (!hasStructuredAttention && hasFailureSignal(summaryText, progress));
+  const warning = attentionSeverity === 'warning';
+  const isWaiting = status === 'waiting_input' || status === 'waiting';
+  const isRunning = status === 'running' || status === 'busy';
+
+  let lane = 'continue_later';
+  let actionKind = 'resume';
+  let actionLabel = 'Continue';
+  let recommendation = 'Session is idle; reuse this context when you have the next instruction.';
+  let confidence = 'medium';
+
+  if (isWaiting) {
+    lane = 'needs_user';
+    actionKind = status === 'waiting_input' || /approval|choice|input/i.test(waitingReason)
+      ? 'approval_needed'
+      : 'needs_input';
+    actionLabel = 'Respond';
+    recommendation = actionKind === 'approval_needed'
+      ? 'Approval or input is waiting in the terminal.'
+      : 'The session appears to need user input before it can continue.';
+    confidence = 'high';
+  } else if (isRunning) {
+    lane = 'running';
+    actionKind = 'watch';
+    actionLabel = 'Open';
+    recommendation = 'Work is still running; no operator action is needed yet.';
+    confidence = status === 'running' ? 'high' : 'medium';
+  } else if (failed) {
+    lane = 'needs_user';
+    actionKind = 'investigate';
+    actionLabel = 'Inspect';
+    recommendation = attention?.recommendation || 'A current blocker or failure appears to need attention.';
+    confidence = attention?.confidence || 'medium';
+  } else if (warning) {
+    lane = 'needs_user';
+    actionKind = 'warning';
+    actionLabel = 'Review';
+    recommendation = attention?.recommendation || 'A current warning appears to need attention.';
+    confidence = attention?.confidence || 'medium';
+  } else if (reviewable) {
+    lane = 'ready_review';
+    actionKind = 'review';
+    actionLabel = 'Review';
+    recommendation = 'Review the session output or finish the worktree changes.';
+    confidence = session?.worktreeStatus ? 'high' : 'medium';
+  } else if (ageMs != null && ageMs > STALE_AFTER_MS) {
+    lane = 'continue_later';
+    actionKind = 'resume';
+    actionLabel = 'Resume';
+    recommendation = 'Session is quiet; resume it only if this preserved context is still useful.';
+    confidence = 'medium';
+  }
+
+  let evidence = baseEvidence({ session, status, summary, now, intentText: intentString, progress });
+  if ((failed || warning) && attention?.evidence?.length) {
+    evidence = prependEvidence(evidence, attention.evidence);
+  }
+  if (failed && !isRunning && !evidence.some(item => /failed|blocked|blocker|error|failure/i.test(item))) {
+    evidence.unshift('possible blocker');
+  }
+  if (warning && !isRunning && !evidence.some(item => /warn|caution|risk|attention/i.test(item))) {
+    evidence.unshift('warning');
+  }
+
+  const title = truncateText(
+    session?.label || summary?.displayPrompt || summary?.lastPrompt || intentString || session?.id || 'Session',
+    90
+  );
+
+  return {
+    id: session?.id || session?.sessionId || '',
+    agentSessionId: session?.agentSessionId || session?.claudeSessionId || null,
+    title,
+    agent: session?.agentType || session?.agent || session?.type || 'session',
+    provider: session?.model_provider || session?.provider || '',
+    model: session?.model_id || session?.model || '',
+    cwd: session?.cwd || '',
+    project: session?.project || session?.cwd || '',
+    branch: session?.branch || session?.gitBranch || session?.worktreeStatus?.branch || '',
+    status,
+    lane,
+    actionKind,
+    actionLabel,
+    recommendation,
+    confidence,
+    evidence,
+    attention: attention && attention.severity !== 'none' ? attention : null,
+    intent: intentString,
+    progress: progressString,
+    lastActivity: toIso(lastActivityMs),
+    ageMs,
+    worktree: session?.worktreeStatus || session?.worktree || null,
+    capabilities: session?.agentCapabilities || session?.capabilities || {},
+    priority: LANE_ORDER.get(lane) ?? 99,
+  };
+}
+
+function sortCards(a, b) {
+  if (a.priority !== b.priority) return a.priority - b.priority;
+  const actionOrder = {
+    approval_needed: 0,
+    needs_input: 1,
+    investigate: 2,
+    warning: 3,
+    review: 4,
+    watch: 5,
+    resume: 6,
+    archive: 7,
+  };
+  const ao = actionOrder[a.actionKind] ?? 99;
+  const bo = actionOrder[b.actionKind] ?? 99;
+  if (ao !== bo) return ao - bo;
+  return (toMs(b.lastActivity) || 0) - (toMs(a.lastActivity) || 0);
+}
+
+function buildSessionStandupSnapshot({ sessions = [], summaries = [], statuses = [], now = Date.now() } = {}) {
+  const summaryIndex = buildIndex(summaries);
+  const statusIndex = buildIndex(statuses);
+  const cards = sessions
+    .map(session => classifySessionStandup(session, {
+      summary: lookupForSession(summaryIndex, session),
+      status: lookupForSession(statusIndex, session),
+    }, now))
+    .filter(card => card.id)
+    .sort(sortCards);
+
+  const counts = { total: cards.length };
+  for (const lane of LANE_DEFS) counts[lane.id] = 0;
+  for (const card of cards) counts[card.lane] = (counts[card.lane] || 0) + 1;
+
+  const lanes = LANE_DEFS.map(lane => ({
+    ...lane,
+    count: counts[lane.id] || 0,
+    sessions: cards.filter(card => card.lane === lane.id),
+  }));
+
+  return {
+    generatedAt: new Date(now).toISOString(),
+    counts,
+    lanes,
+    sessions: cards,
+  };
+}
+
+module.exports = {
+  LANE_DEFS,
+  classifySessionStandup,
+  buildSessionStandupSnapshot,
+  _private: {
+    normalizeStatus,
+    standupStatusForSession,
+    latestActivity,
+    truncateText,
+    hasFailureSignal,
+  },
+};

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;