runtime-inspector 0.1.0

package/src/agent/attentionInfer.js

@@ -0,0 +1,149 @@
+// Attention inference — deterministic rules that flag sessions needing attention.
+// Produces session.attention = { level: "ok"|"warn"|"alert", reasons: [] }
+// Also computes the global "safe to leave" signal.
+
+/**
+ * Add attention inference to all sessions. Mutates in place.
+ * Run after addProgressInference() and addStateInference().
+ */
+export function addAttentionInference(sessions) {
+  for (const session of sessions) {
+    const reasons = [];
+    let level = 'ok';
+    const cpu = session.cpu || 0;
+    const hasFileProgress = session.repoActivity?.filesChangedLast2m > 0;
+    const elapsed = session.durationSeconds || 0;
+
+    // Rule 1: Waiting for input (shell command finished, prompt is up)
+    if (session.waitingForInput && session.commandState === 'completed') {
+      if (session.lastCommandExitCode !== 0 && session.lastCommandExitCode != null) {
+        reasons.push({
+          rule: 'failedCommand',
+          message: `Last command failed (exit ${session.lastCommandExitCode})`,
+          severity: 'alert',
+        });
+      } else {
+        reasons.push({
+          rule: 'waitingForInput',
+          message: 'Waiting for next command',
+          severity: 'warn',
+        });
+      }
+    }
+
+    // tmux output freshness — only meaningful when tmux data exists
+    const hasTmux = session.tmux && session.tmux.lastPaneOutputAt;
+    const tmuxOutputAge = hasTmux
+      ? (Date.now() - session.tmux.lastPaneOutputAt) / 1000
+      : null;
+    const hasFreshTmuxOutput = tmuxOutputAge !== null && tmuxOutputAge < 60;
+
+    // Rule 2: Possibly stuck — high CPU, no file output, long running
+    // If tmux shows fresh output, downgrade from alert to ok
+    const rs = session.runtimeState || '';
+    if (rs === 'stuck' || rs === 'possibly-stuck') {
+      if (hasFreshTmuxOutput) {
+        // tmux pane is active — override stuck signal, it's actually progressing
+        session.runtimeState = 'progressing';
+      } else {
+        // Only use tmux output staleness to escalate when tmux data exists
+        const noTmuxOutputLong = tmuxOutputAge !== null && tmuxOutputAge > 600; // 10 min
+        reasons.push({
+          rule: 'possiblyStuck',
+          message: rs === 'stuck'
+            ? 'Process appears stuck' + (hasTmux ? ' — no terminal output for ' + formatAge(tmuxOutputAge) : '')
+            : 'May be stuck — no output or file changes',
+          severity: (cpu > 5 && !hasFileProgress && noTmuxOutputLong) ? 'alert' : 'warn',
+        });
+      }
+    }
+
+    // Rule 2b: AI agent waiting for input (tmux-enhanced)
+    // ai-agent + commandState running + cpu < 1% + no repo activity + no tmux change for 3m
+    // Only apply tmux staleness check when tmux data exists; without tmux, use other signals
+    const tmuxStaleLong = tmuxOutputAge !== null && tmuxOutputAge > 180;
+    const noTmuxButIdle = tmuxOutputAge === null && cpu < 1 && elapsed > 300;
+    if (session.type === 'ai-agent' && session.commandState === 'running' && cpu < 1
+        && !hasFileProgress && (tmuxStaleLong || noTmuxButIdle) && !reasons.some(r => r.rule === 'possiblyStuck')) {
+      reasons.push({
+        rule: 'waitingForInput',
+        message: hasTmux
+          ? 'AI agent may be waiting for input — idle ' + formatAge(tmuxOutputAge)
+          : 'AI agent may be waiting for input — low CPU, no file changes',
+        severity: 'warn',
+      });
+    }
+
+    // Rule 3: Duplicate AI agents in same repo
+    if (session.type === 'ai-agent' && session.cwd) {
+      const sameRepoAgents = sessions.filter(
+        s => s.type === 'ai-agent' && s.cwd === session.cwd && s.id !== session.id
+      );
+      if (sameRepoAgents.length > 0) {
+        reasons.push({
+          rule: 'duplicateAgents',
+          message: `${sameRepoAgents.length + 1} AI agents in same repo`,
+          severity: 'warn',
+        });
+      }
+    }
+
+    // Rule 4: Long running with no progress signal
+    // Only count fresh tmux output as a positive signal; absence of tmux is not negative
+    if (elapsed > 1800 && !hasFileProgress && cpu < 2 && !session.isWrapped && !hasFreshTmuxOutput && (hasTmux || !session.tmux)) {
+      reasons.push({
+        rule: 'longRunningIdle',
+        message: 'Running 30+ min with no file activity' + (session.tmux ? ' or terminal output' : '') + ' or CPU',
+        severity: 'warn',
+      });
+    }
+
+    // Rule 5: Failed wrapped process
+    if (session.isWrapped && rs === 'failed') {
+      reasons.push({
+        rule: 'wrappedFailed',
+        message: 'Wrapped command failed',
+        severity: 'alert',
+      });
+    }
+
+    // Compute level from highest severity
+    for (const r of reasons) {
+      if (r.severity === 'alert') { level = 'alert'; break; }
+      if (r.severity === 'warn') level = 'warn';
+    }
+
+    session.attention = { level, reasons };
+  }
+
+  return sessions;
+}
+
+function formatAge(seconds) {
+  if (!isFinite(seconds)) return 'unknown';
+  if (seconds < 60) return Math.round(seconds) + 's';
+  if (seconds < 3600) return Math.round(seconds / 60) + 'm';
+  return Math.round(seconds / 3600) + 'h';
+}
+
+/**
+ * Compute global "safe to leave" summary from sessions.
+ * Returns { safeToLeave, needsAttentionCount, needsAttention[] }
+ */
+export function computeSafeToLeave(sessions) {
+  const needsAttention = sessions.filter(
+    s => s.attention && s.attention.level !== 'ok'
+  ).map(s => ({
+    id: s.id,
+    title: s.title,
+    icon: s.icon,
+    level: s.attention.level,
+    reasons: s.attention.reasons.map(r => r.message),
+  }));
+
+  return {
+    safeToLeave: needsAttention.filter(s => s.level === 'alert').length === 0,
+    needsAttentionCount: needsAttention.length,
+    needsAttention,
+  };
+}