create-walle 0.9.21 → 0.9.23

package/template/claude-task-manager/lib/session-prompt-index.js

@@ -0,0 +1,137 @@
+'use strict';
+
+// Shared "user-prompt index" compute for the Queue Builder prompt-preview. Extracted from
+// server.js so the SAME logic runs on the main thread (live connection, fallback) AND on
+// the read-pool worker (read-only connection) — keeping the SELECT-all-user-rows + sort +
+// exclusions + sha1-per-prompt fingerprint OFF the main event loop (Phase 1). It is a pure
+// read: takes a db handle + already-resolved inputs (sourceIds, exclusion rows, a flag for
+// whether the session has a Codex source) so the worker needs no owner/source resolution.
+//
+// Output is identical by construction to the previous inline path, so moving it off-thread
+// (or falling back to it on main) can never change the prompt list.
+
+const crypto = require('crypto');
+const { sortTimelineMessagesInPlace } = require('./timeline-order');
+const { isProviderGeneratedUserContextText } = require('./provider-user-context');
+
+// Lazy so a require cycle in session-history (large) can't break worker boot.
+let _isCodexSyntheticUserText = null;
+function _codexSynthetic(text) {
+  if (!_isCodexSyntheticUserText) {
+    try { _isCodexSyntheticUserText = require('./session-history').isCodexSyntheticUserText; }
+    catch { _isCodexSyntheticUserText = () => false; }
+  }
+  return _isCodexSyntheticUserText(text);
+}
+
+function _normalizePromptVersionText(text) {
+  return String(text || '').replace(/\s+/g, ' ').trim().slice(0, 500);
+}
+function _promptVersionHash(input) {
+  return crypto.createHash('sha1').update(String(input || '')).digest('hex').slice(0, 16);
+}
+function _sessionMessageTextHash(text) {
+  return crypto.createHash('sha256').update(String(text || '').replace(/\s+/g, ' ').trim()).digest('hex');
+}
+function _msgText(m) { return (m && (m.text || m.content || m.message)) || ''; }
+function _msgTs(m) { return (m && (m.timestamp || m.created_at || m.createdAt)) || ''; }
+
+// Mirrors server.js _applySessionMessageExclusions, but takes already-loaded exclusion rows
+// and the codex-synthetic decision as inputs (no DB / owner resolution needed here).
+function applyExclusions(messages, { exclusionRows = [], filterCodexSynthetic = false } = {}) {
+  if (!Array.isArray(messages) || messages.length === 0) return messages || [];
+  const visible = messages.filter((msg) => {
+    const role = String(msg && msg.role || '').trim();
+    if (role !== 'user') return true;
+    const text = _msgText(msg);
+    if (isProviderGeneratedUserContextText(text)) return false;
+    if (filterCodexSynthetic && _codexSynthetic(text)) return false;
+    return true;
+  });
+  if (!Array.isArray(exclusionRows) || exclusionRows.length === 0) return visible;
+  const exact = new Set();
+  const textOnly = new Set();
+  for (const row of exclusionRows) {
+    const role = String(row && row.role || '').trim();
+    const hash = String(row && row.text_hash || '').trim();
+    const ts = String(row && row.timestamp || '').trim();
+    if (!hash) continue;
+    if (ts) exact.add(`${role}\0${ts}\0${hash}`);
+    else textOnly.add(`${role}\0${hash}`);
+  }
+  if (exact.size === 0 && textOnly.size === 0) return visible;
+  return visible.filter((msg) => {
+    const role = String(msg && msg.role || '').trim();
+    const ts = String(_msgTs(msg)).trim();
+    const hash = _sessionMessageTextHash(_msgText(msg));
+    return !exact.has(`${role}\0${ts}\0${hash}`) && !textOnly.has(`${role}\0${hash}`);
+  });
+}
+
+// Mirrors server.js _promptSummaryFromMessages.
+function summarize(messages, sourceIds = []) {
+  const prompts = (Array.isArray(messages) ? messages : [])
+    .map((message, index) => ({
+      text: _normalizePromptVersionText(_msgText(message)),
+      timestamp: String(_msgTs(message) || ''),
+      index,
+    }))
+    .filter((p) => p.text);
+  const last = prompts.length ? prompts[prompts.length - 1] : null;
+  const promptFingerprint = prompts.length > 0
+    ? _promptVersionHash(prompts.map((p) => [p.index, _promptVersionHash(p.text), p.timestamp].join(':')).join('|'))
+    : '';
+  return {
+    sourceIds,
+    cacheAvailable: prompts.length > 0,
+    userPromptCount: prompts.length,
+    lastPromptPreview: last ? last.text.slice(0, 240) : '',
+    lastPromptTimestamp: last ? last.timestamp : '',
+    promptFingerprint,
+  };
+}
+
+// Which table holds the per-message render rows. The row store (session_message_rows) is the
+// default on current installs; the legacy session_messages index has been RETIRED (dropped by
+// the de-dup migration). Mirrors db.js `_messageFreshnessTable()` so the prompt compute reads the
+// SAME table the freshness key is computed from — otherwise this SELECT throws "no such table:
+// session_messages", the off-thread index returns empty, and every prompt poll falls back to the
+// heavy main-thread timeline projection (the multi-second apiSessionPrompts input-box freeze).
+// Column names differ: the row store uses text/timestamp; the legacy table used content/created_at.
+function _promptRowsSource(d) {
+  let hasRows = false;
+  try { hasRows = !!d.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='session_message_rows'").get(); }
+  catch { hasRows = false; }
+  return hasRows
+    ? { table: 'session_message_rows', cols: 'role, text AS text, timestamp AS timestamp' }
+    : { table: 'session_messages', cols: 'role, content AS text, created_at AS timestamp' };
+}
+
+// Load the raw user-prompt rows for the given source ids from the message index, ordered.
+function loadUserPromptRows(d, sourceIds = []) {
+  const src = _promptRowsSource(d);
+  const stmt = d.prepare(
+    `SELECT ${src.cols}
+       FROM ${src.table}
+      WHERE ctm_session_id = ? AND role = 'user'
+      ORDER BY message_index ASC`
+  );
+  const prompts = [];
+  for (const id of (Array.isArray(sourceIds) ? sourceIds : [])) {
+    for (const row of stmt.all(String(id))) {
+      prompts.push({ role: row.role, text: row.text || '', timestamp: row.timestamp || '' });
+    }
+  }
+  sortTimelineMessagesInPlace(prompts);
+  return prompts;
+}
+
+// The whole index-source compute: load rows → exclusions → summary. Returns the filtered
+// user-prompt messages + the summary. Runs on the read-pool worker (off main) or on main.
+function computeUserPromptIndex(d, { sourceIds = [], exclusionRows = [], filterCodexSynthetic = false } = {}) {
+  const raw = loadUserPromptRows(d, sourceIds);
+  const messages = applyExclusions(raw, { exclusionRows, filterCodexSynthetic });
+  return { messages, summary: summarize(messages, sourceIds) };
+}
+
+module.exports = { computeUserPromptIndex, loadUserPromptRows, applyExclusions, summarize };

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

@@ -1,11 +1,14 @@
 'use strict';
 
 const fs = require('fs');
+const path = require('path');
 const {
   canResumeAgent,
   getResumeSpec: defaultGetResumeSpec,
   normalizeAgentType,
 } = require('./agent-capabilities');
+const { resolveClaudeResumeCwd } = require('./resume-preflight');
+const { normalizeCwd, samePath } = require('./resume-cwd');
 
 function normalizeArgs(args) {
   if (Array.isArray(args)) return args;
@@ -185,6 +188,55 @@ function resolveRestoreArgsFromAgentSessions({
   };
 }
 
+function resolveRestoreCwdFromAgentSession({
+  task,
+  row,
+  agentType,
+  fsExists = fs.existsSync,
+  fsStat = fs.statSync,
+  homeDir,
+  claudeConfigDir,
+} = {}) {
+  const normalizedAgentType = normalizeAgentType(agentType || task?.type || task?.cmd);
+  const fallbackCwd = normalizeCwd(task?.cwd || '');
+  if (normalizedAgentType !== 'claude' || !row) {
+    return {
+      cwd: fallbackCwd,
+      changed: false,
+      reason: '',
+    };
+  }
+
+  const jsonlPath = String(row.jsonl_path || '').trim();
+  const transcriptPath = jsonlPath || (
+    row.agent_project_dir && row.agent_session_id
+      ? path.join(row.agent_project_dir, `${row.agent_session_id}.jsonl`)
+      : ''
+  );
+  if (!transcriptPath) {
+    return { cwd: fallbackCwd, changed: false, reason: '' };
+  }
+
+  const result = resolveClaudeResumeCwd({
+    cwd: fallbackCwd,
+    projectPath: row.project_path || task?.project_path || '',
+    agentRow: row,
+    transcriptPath,
+    fsExists,
+    fsStat,
+    homeDir,
+    claudeConfigDir,
+  });
+  return {
+    cwd: result.cwd || fallbackCwd,
+    changed: !!(result.changed && result.cwd && !samePath(result.cwd, fallbackCwd)),
+    reason: result.reason || '',
+    blocked: !!result.blocked,
+    transcriptProjectDir: result.transcriptProjectDir || '',
+    cwdProjectDir: result.cwdProjectDir || '',
+  };
+}
+
 function resolveCodexLinkRestoreArgs(codexLink, getResumeSpec = defaultGetResumeSpec) {
   const agentSessionId = String(codexLink?.agentSessionId || '').trim();
   if (!agentSessionId) return null;
@@ -201,6 +253,7 @@ function resolveCodexLinkRestoreArgs(codexLink, getResumeSpec = defaultGetResume
 module.exports = {
   orderedAgentRows,
   resolveCodexLinkRestoreArgs,
+  resolveRestoreCwdFromAgentSession,
   resumeSessionIdForRow,
   selectRestoreAgentSession,
   resolveRestoreArgsFromAgentSessions,

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

@@ -20,13 +20,13 @@ const LANE_DEFS = [
   },
   {
     id: 'needs_user',
-    title: 'Needs User',
+    title: 'Needs You',
     description: 'Approvals, questions, blockers, or failed work that need operator attention.',
   },
   {
     id: 'continue_later',
-    title: 'Continue Later',
-    description: 'Idle sessions worth preserving for context reuse.',
+    title: 'Ready',
+    description: 'Idle sessions ready to resume when this preserved context is useful.',
   },
 ];
 
@@ -208,12 +208,13 @@ function ageLabel(now, value) {
 }
 
 function normalizeStatus(status) {
-  const text = String(status || '').toLowerCase();
+  const text = String(status || '').toLowerCase().replace(/[-\s]+/g, '_');
   if (!text) return 'unknown';
-  if (text === 'busy') return 'running';
+  if (text === 'busy' || text === 'active' || text === 'working' || text === 'thinking') return 'running';
+  if (text === 'restoring' || text === 'resuming' || text === 'restore_starting' || text === 'restarting') return 'resuming';
   if (text === 'waiting_input') return 'waiting_input';
-  if (text === 'waiting-for-input') return 'waiting_input';
-  if (['running', 'waiting', 'idle', 'exited', 'unknown'].includes(text)) return text;
+  if (text === 'waiting_for_input') return 'waiting_input';
+  if (['running', 'resuming', 'waiting', 'idle', 'exited', 'unknown'].includes(text)) return text;
   return text;
 }
 
@@ -263,21 +264,16 @@ function inferProviderFromAgent(agent) {
 
 function isWalleOwnedSession(session) {
   if (!session || typeof session !== 'object') return false;
+  if (session.walle_owned === true || session.walleOwned === true) return true;
+  if (session.native_walle_session === true || session.nativeWalleSession === true) return true;
   const explicitProvider = normalizeProvider(session.provider || session.providerId || session._providerId);
   if (explicitProvider === 'walle') return true;
   const explicitAgent = inferProviderFromAgent(session.agentType || session.agent || session.type);
   if (explicitAgent === 'walle') return true;
 
-  const label = String(session.label || session.title || '').trim().toLowerCase();
+  // Labels, branches, and worktree names describe the task, not the runtime owner.
   const cmd = String(session.cmd || '').trim().toLowerCase();
-  const branch = String(session.branch || session.gitBranch || session.worktreeStatus?.branch || '').trim().toLowerCase();
-  const worktreePath = String(session.worktree_path || session.worktreePath || session.worktreeStatus?.worktreePath || session.cwd || '').trim().toLowerCase();
-  const worktreeName = String(session.worktreeStatus?.worktreeName || worktreePath.split('/').filter(Boolean).pop() || '').trim().toLowerCase();
-
-  if (cmd === 'walle coding' || cmd.startsWith('walle coding ')) return true;
-  if (/^(wall-?e|walle)\s+coding\b/.test(label)) return true;
-  if (worktreeName === 'walle-coding' || worktreeName.startsWith('walle-coding-')) return true;
-  if (branch.includes('walle-coding')) return true;
+  if (cmd === 'walle' || cmd === 'walle coding' || cmd.startsWith('walle coding ')) return true;
   return false;
 }
 
@@ -344,7 +340,10 @@ function lookupForSession(index, session) {
 
 function isBlockingWaitingReason(reason) {
   const text = String(reason || '').toLowerCase();
-  return text === 'approval' || text === 'choice';
+  return text === 'approval' ||
+    text === 'choice' ||
+    /\bapproval\b/.test(text) ||
+    /\bpermission\b/.test(text);
 }
 
 function hasUnsubmittedWaitingInput(session) {
@@ -364,6 +363,23 @@ function isStaleNonBlockingWaiting(session, status, summary, now = Date.now()) {
   return !!(waitingAt && (now - waitingAt) > WAITING_INPUT_STALE_MS);
 }
 
+function attentionDismissalForSession(session, now = Date.now()) {
+  const dismissedAt = normalizeObservedTimeMs(
+    session?.attentionDismissedAt ?? session?.attention_dismissed_at,
+    now
+  );
+  const dismissedInputAt = normalizeObservedTimeMs(
+    session?.attentionDismissedInputAt ?? session?.attention_dismissed_input_at,
+    now
+  );
+  const lastUserPromptInputAt = normalizeObservedTimeMs(
+    session?.lastUserPromptInputAt ?? session?.last_user_prompt_input_at,
+    now
+  );
+  const active = dismissedAt > 0 && (!lastUserPromptInputAt || lastUserPromptInputAt <= dismissedInputAt);
+  return { dismissedAt, dismissedInputAt, lastUserPromptInputAt, active };
+}
+
 function statusForSession(session, status, summary, now = Date.now()) {
   if (session?.waitingForInput && !isStaleNonBlockingWaiting(session, status, summary, now)) return 'waiting_input';
   const candidates = [
@@ -406,10 +422,17 @@ function standupStatusForSession(session, status, summary, now = Date.now()) {
 function worktreeEvidence(worktree) {
   if (!worktree) return '';
   const dirtyFiles = Number(worktree.dirtyFiles || 0);
-  const unmergedCommits = Number(worktree.unmergedCommits || 0);
+  const trackedDirtyFiles = worktree.trackedDirtyFiles != null
+    ? Number(worktree.trackedDirtyFiles || 0)
+    : Math.max(0, dirtyFiles - Number(worktree.untrackedFiles || 0));
+  const untrackedFiles = Number(worktree.untrackedFiles || 0);
+  const localCommits = worktree.isMain
+    ? Number(worktree.unpushedCommits || worktree.ahead || worktree.unmergedCommits || 0)
+    : Number(worktree.unmergedCommits || 0);
   const parts = [];
-  if (dirtyFiles) parts.push(`${dirtyFiles} dirty`);
-  if (unmergedCommits) parts.push(`${unmergedCommits} unmerged`);
+  if (trackedDirtyFiles) parts.push(`${trackedDirtyFiles} dirty`);
+  if (untrackedFiles) parts.push(`${untrackedFiles} untracked`);
+  if (localCommits) parts.push(worktree.isMain ? `${localCommits} local` : `${localCommits} unmerged`);
   if (!parts.length && worktree.summary) parts.push(worktree.summary);
   return parts.length ? `worktree ${parts.join(', ')}` : '';
 }
@@ -418,8 +441,12 @@ 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;
+    const trackedDirtyFiles = worktree.trackedDirtyFiles != null
+      ? Number(worktree.trackedDirtyFiles || 0)
+      : Math.max(0, Number(worktree.dirtyFiles || 0) - Number(worktree.untrackedFiles || 0));
+    if (trackedDirtyFiles > 0) return true;
     if (Number(worktree.unmergedCommits || 0) > 0) return true;
+    if (Number(worktree.unpushedCommits || 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);
@@ -539,6 +566,7 @@ function baseEvidence({ session, status, summary, now, intentText, progress, goa
   const evidence = [];
   if (status === 'waiting_input') evidence.push('waiting input');
   else if (status === 'waiting') evidence.push('waiting');
+  else if (status === 'resuming') evidence.push('resuming');
   else if (status === 'running') evidence.push('running');
   const branch = session?.branch || session?.gitBranch || session?.worktreeStatus?.branch || '';
   if (branch) evidence.push(`branch ${branch}`);
@@ -576,10 +604,29 @@ function latestActivity(session, summary, now = Date.now()) {
   return latestObservedTimeMs(values, now);
 }
 
+function latestAgentOutput(session, summary, status, now = Date.now()) {
+  const recentAssistantTurns = Array.isArray(summary?.recentTurns)
+    ? summary.recentTurns
+        .filter(turn => turn?.role === 'assistant')
+        .map(turn => turn.timestamp || turn.updatedAt || turn.createdAt)
+    : [];
+  const values = [
+    summary?.progress?.updatedAt,
+    summary?.progress?.timestamp,
+    session?.lastAgentOutputAt,
+    session?.lastPtyActivity,
+    status?.lastAgentOutputAt,
+    status?.lastPtyActivity,
+    ...(String(status?.status || '').toLowerCase() === 'running' ? [status?.lastActivity] : []),
+    ...recentAssistantTurns,
+  ];
+  return latestObservedTimeMs(values, now);
+}
+
 function classifySessionStandup(session, signals = {}, now = Date.now()) {
   const summary = signals.summary || {};
   const streamStatus = signals.status || {};
-  const status = standupStatusForSession(session, streamStatus, summary, now);
+  let status = standupStatusForSession(session, streamStatus, summary, now);
   const goal = goalForSummary(session, summary);
   const intentString = goal.text;
   const progress = summary.progress || '';
@@ -587,6 +634,7 @@ function classifySessionStandup(session, signals = {}, now = Date.now()) {
   const progressString = progressInfo.text;
   const summaryText = valueText(summary.summary) || intentString;
   const lastActivityMs = latestActivity(session, summary, now);
+  const lastAgentOutputMs = latestAgentOutput(session, summary, streamStatus, now);
   const ageMs = lastActivityMs ? Math.max(0, now - lastActivityMs) : null;
   const waitingReason = session?.waitingReason || streamStatus?.reason || summary?.statusEvidence?.[0] || '';
   const reviewable = hasReviewableWork(session, summaryText, progress);
@@ -598,6 +646,7 @@ function classifySessionStandup(session, signals = {}, now = Date.now()) {
   const warning = attentionSeverity === 'warning';
   const isWaiting = status === 'waiting_input' || status === 'waiting';
   const isRunning = status === 'running' || status === 'busy';
+  const isResuming = status === 'resuming';
 
   let lane = 'continue_later';
   let actionKind = 'resume';
@@ -620,7 +669,13 @@ function classifySessionStandup(session, signals = {}, now = Date.now()) {
     actionKind = 'watch';
     actionLabel = 'Open';
     recommendation = 'Work is still running; no operator action is needed yet.';
-    confidence = status === 'running' ? 'high' : 'medium';
+    confidence = 'high';
+  } else if (isResuming) {
+    lane = 'continue_later';
+    actionKind = 'watch';
+    actionLabel = 'Open';
+    recommendation = 'CTM is restoring this session after restart; it will return to idle unless new provider output arrives.';
+    confidence = 'medium';
   } else if (failed) {
     lane = 'needs_user';
     actionKind = 'investigate';
@@ -658,12 +713,34 @@ function classifySessionStandup(session, signals = {}, now = Date.now()) {
     evidence.unshift('warning');
   }
 
+  const dismissal = attentionDismissalForSession(session, now);
+  let dismissedToIdle = false;
+  if (dismissal.active && lane === 'needs_user') {
+    dismissedToIdle = true;
+    lane = 'continue_later';
+    status = 'idle';
+    actionKind = 'resume';
+    actionLabel = 'Open';
+    recommendation = 'Dismissed from Needs You; open when ready or send a new prompt to continue.';
+    confidence = confidence === 'high' ? 'medium' : confidence;
+    if (!evidence.some(item => String(item || '').toLowerCase() === 'dismissed')) {
+      evidence.unshift('dismissed');
+    }
+  }
+
   const title = truncateText(
     session?.label || summary?.displayPrompt || summary?.lastPrompt || intentString || session?.id || 'Session',
     90
   );
   const provider = inferSessionProvider(session);
   const modelProvider = inferSessionModelProvider(session);
+  const nativeWalleSession = session?.native_walle_session === true
+    || session?.nativeWalleSession === true
+    || session?.type === 'walle';
+  const walleOwned = session?.walle_owned === true
+    || session?.walleOwned === true
+    || isWalleOwnedSession(session);
+  const sessionType = session?.session_type || session?.sessionType || session?.runtime_type || session?.runtimeType || session?.type || '';
 
   const card = {
     id: session?.id || session?.sessionId || '',
@@ -671,6 +748,16 @@ function classifySessionStandup(session, signals = {}, now = Date.now()) {
     title,
     agent: session?.agentType || session?.agent || session?.type || 'session',
     provider,
+    type: session?.type || sessionType || '',
+    session_type: sessionType || '',
+    runtime_type: session?.runtime_type || session?.runtimeType || session?.type || '',
+    walle_owned: !!walleOwned,
+    walleOwned: !!walleOwned,
+    native_walle_session: !!nativeWalleSession,
+    nativeWalleSession: !!nativeWalleSession,
+    agentMode: session?.agentMode || session?.agent_mode || null,
+    agentKind: session?.agentKind || session?.agent_kind || (walleOwned && !nativeWalleSession ? 'walle-coding' : null),
+    taskType: session?.taskType || session?.task_type || (walleOwned && !nativeWalleSession ? 'coding' : null),
     modelProvider,
     model: inferSessionModel(session),
     cwd: session?.cwd || '',
@@ -696,8 +783,16 @@ function classifySessionStandup(session, signals = {}, now = Date.now()) {
     progress: progressString,
     createdAt: toIso(session?.createdAt, now),
     lastActivity: toIso(lastActivityMs, now),
+    lastAgentOutputAt: toIso(lastAgentOutputMs, now),
+    attentionDismissedAt: toIso(dismissal.dismissedAt, now),
+    attentionDismissedInputAt: toIso(dismissal.dismissedInputAt, now),
+    lastUserPromptInputAt: toIso(dismissal.lastUserPromptInputAt, now),
+    attentionDismissedActive: dismissal.active,
+    dismissedToIdle,
+    dismissedToReady: dismissedToIdle,
     ageMs,
     worktree: session?.worktreeStatus || session?.worktree || null,
+    worktreeStatus: session?.worktreeStatus || session?.worktree || null,
     capabilities: session?.agentCapabilities || session?.capabilities || {},
     priority: LANE_ORDER.get(lane) ?? 99,
   };
@@ -709,6 +804,9 @@ function classifySessionStandup(session, signals = {}, now = Date.now()) {
 
 function sortCards(a, b) {
   if (a.priority !== b.priority) return a.priority - b.priority;
+  const agentA = toMs(a.lastAgentOutputAt);
+  const agentB = toMs(b.lastAgentOutputAt);
+  if (agentA !== agentB) return (agentB || 0) - (agentA || 0);
   const actionOrder = {
     approval_needed: 0,
     needs_input: 1,
@@ -776,7 +874,9 @@ module.exports = {
     isWalleOwnedSession,
     standupStatusForSession,
     latestActivity,
+    latestAgentOutput,
     truncateText,
     hasFailureSignal,
+    attentionDismissalForSession,
   },
 };

package/template/claude-task-manager/lib/session-state-bus.js

@@ -6,6 +6,7 @@
 //   - onOutput(sessionId)        — PTY produced output → mark busy; schedule idle debounce
 //   - onApprovalDetected(sessionId) — approval prompt detected → waiting_input
 //   - onApprovalResolved(sessionId) — prompt handled → busy (until idle debounce fires)
+//   - clearWaitingInput(sessionId) — stale/non-current wait evidence cleared → idle
 //   - reset(sessionId)            — forget this session (on close)
 //
 // Output: fires `statechange` events via the EventEmitter interface. Consumers
@@ -51,6 +52,12 @@ class SessionStateBus extends EventEmitter {
     return this._states.get(sessionId)?.state || null;
   }
 
+  getSnapshot(sessionId) {
+    this._reconcileExpiredBusy(sessionId);
+    const cur = this._states.get(sessionId);
+    return cur ? { ...cur } : null;
+  }
+
   register(sessionId, providerId) {
     if (this._states.has(sessionId)) return;
     this._states.set(sessionId, {
@@ -166,6 +173,13 @@ class SessionStateBus extends EventEmitter {
     this._scheduleIdle(sessionId);
   }
 
+  clearWaitingInput(sessionId) {
+    const cur = this._states.get(sessionId);
+    if (!cur || cur.state !== 'waiting_input') return;
+    this._cancelIdleTimer(sessionId);
+    this._transition(sessionId, 'idle', { providerId: cur.providerId || '' });
+  }
+
   reset(sessionId) {
     this._cancelIdleTimer(sessionId);
     this._states.delete(sessionId);