@dmsdc-ai/aigentry-telepty 0.1.96 → 0.1.98

package/cli.js

@@ -682,7 +682,9 @@ async function manageInteractive() {
         console.log('\x1b[1mAvailable Sessions:\x1b[0m');
         sessions.forEach(s => {
           const hostLabel = formatHostLabel(s.host);
-          console.log(`  - \x1b[36m${s.id}\x1b[0m (\x1b[33m${hostLabel}\x1b[0m) [${s.command}] - Status: ${s.healthStatus || 'UNKNOWN'} - Clients: ${s.active_clients}`);
+          const stEmoji = s.autoState ? s.autoState.emoji : '';
+          const stLabel = s.autoState ? s.autoState.state : '';
+          console.log(`  - \x1b[36m${s.id}\x1b[0m (\x1b[33m${hostLabel}\x1b[0m) [${s.command}] - ${s.healthStatus || 'UNKNOWN'}${stLabel ? ` ${stEmoji} ${stLabel}` : ''} - Clients: ${s.active_clients}`);
         });
       }
       console.log('\n');
@@ -858,7 +860,9 @@ async function main() {
         console.log(`  - ID: \x1b[36m${s.id}\x1b[0m`);
         console.log(`    Host: ${formatHostLabel(s.host)}`);
         console.log(`    Command: ${s.command}`);
-        console.log(`    Status: ${formatSessionHealth(s)}`);
+        const autoEmoji = s.autoState ? s.autoState.emoji : '';
+      const autoLabel = s.autoState ? s.autoState.state : '';
+      console.log(`    Status: ${formatSessionHealth(s)}${autoLabel ? ` ${autoEmoji} ${autoLabel}` : ''}`);
         console.log(`    Terminal: ${formatSessionTerminal(s)}`);
         console.log(`    CWD: ${s.cwd}`);
         console.log(`    Clients: ${s.active_clients}`);
@@ -1775,17 +1779,21 @@ async function main() {
 
       // Color-coded state display
       const stateColors = {
-        running: '\x1b[32m',       // green
-        idle: '\x1b[33m',          // yellow
-        thinking: '\x1b[36m',      // cyan
-        stuck: '\x1b[31m',         // red
-        waiting_input: '\x1b[35m', // magenta
+        starting: '\x1b[33m',      // yellow
+        idle: '\x1b[32m',          // green
+        working: '\x1b[36m',       // cyan
+        thinking: '\x1b[35m',      // magenta
+        waiting: '\x1b[33m',       // yellow
+        error: '\x1b[31m',         // red
+        restarting: '\x1b[33m',    // yellow
+        dead: '\x1b[90m',          // gray
       };
       const stateColor = stateColors[auto.state] || '\x1b[37m';
       const reset = '\x1b[0m';
 
       console.log(`\n  Session: \x1b[36m${data.session_id}${reset}`);
-      console.log(`  Auto State: ${stateColor}${auto.state || 'unknown'}${reset} (confidence: ${auto.confidence != null ? (auto.confidence * 100).toFixed(0) + '%' : '?'})`);
+      const stateEmoji = auto.emoji || '';
+      console.log(`  State: ${stateColor}${stateEmoji} ${auto.state || 'unknown'}${reset} (confidence: ${auto.confidence != null ? (auto.confidence * 100).toFixed(0) + '%' : '?'})`);
       if (auto.since) {
         const durationMs = auto.duration_ms || 0;
         const durationStr = durationMs < 60000

package/daemon.js

@@ -12,7 +12,7 @@ const terminalBackend = require('./terminal-backend');
 const { FileMailbox } = require('./src/mailbox/index');
 const { DeliveryEngine } = require('./src/mailbox/delivery');
 const { UnixSocketNotifier } = require('./src/mailbox/notifier');
-const { SessionStateManager } = require('./session-state');
+const { SessionStateManager, STATE_DISPLAY } = require('./session-state');
 
 const config = getConfig();
 const EXPECTED_TOKEN = config.authToken;
@@ -27,19 +27,33 @@ const HEALTH_POLL_MS = Math.max(100, Number(process.env.TELEPTY_HEALTH_POLL_MS |
 
 // Session state machine manager — auto-detects session state from PTY output
 const sessionStateManager = new SessionStateManager({
-  idle_timeout_ms:    Number(process.env.TELEPTY_STATE_IDLE_TIMEOUT_MS || 5000),
-  stuck_repeat_count: Number(process.env.TELEPTY_STATE_STUCK_REPEAT_COUNT || 3),
-  stuck_window_ms:    Number(process.env.TELEPTY_STATE_STUCK_WINDOW_MS || 180000),
-  thinking_timeout_ms:Number(process.env.TELEPTY_STATE_THINKING_TIMEOUT_MS || 300000),
+  idle_timeout_ms:      Number(process.env.TELEPTY_STATE_IDLE_TIMEOUT_MS || 5000),
+  error_repeat_count:   Number(process.env.TELEPTY_STATE_ERROR_REPEAT_COUNT || 3),
+  error_window_ms:      Number(process.env.TELEPTY_STATE_ERROR_WINDOW_MS || 180000),
+  thinking_timeout_ms:  Number(process.env.TELEPTY_STATE_THINKING_TIMEOUT_MS || 300000),
 });
 
-// Broadcast state transitions to the bus
+// Broadcast state transitions to the bus + fire auto-report on idle
 sessionStateManager.onTransition((sessionId, from, to, detail) => {
   const session = sessions[sessionId];
   if (!session) return;
   broadcastSessionEvent('session_auto_state', sessionId, session, {
     extra: { auto_state: to, auto_state_from: from, auto_detail: detail }
   });
+
+  // Auto-report: fire when session transitions to idle after inject
+  if (to === 'idle' && pendingReports[sessionId]) {
+    const pendingReport = pendingReports[sessionId];
+    delete pendingReports[sessionId];
+    const elapsed = ((Date.now() - new Date(pendingReport.injectedAt).getTime()) / 1000).toFixed(1);
+    const reportMsg = `TASK_COMPLETE: ${sessionId} is now idle after processing inject (${elapsed}s)`;
+    const srcId = resolveSessionAlias(pendingReport.source) || pendingReport.source;
+    const srcSession = sessions[srcId];
+    if (srcSession) {
+      deliverInjectionToSession(srcId, srcSession, reportMsg, { noEnter: false, source: 'auto_report' });
+      console.log(`[AUTO-REPORT] ${sessionId} → ${srcId}: idle after ${elapsed}s (via state machine)`);
+    }
+  }
 });
 
 function persistSessions() {
@@ -267,7 +281,7 @@ function getSessionHealthStatus(session, options = {}) {
 
 function getSessionHealthReason(session, healthStatus) {
   if (session.type === 'wrapped') {
-    if (healthStatus === 'CONNECTED') return session.ready ? 'OWNER_CONNECTED' : 'OWNER_CONNECTED_NOT_READY';
+    if (healthStatus === 'CONNECTED') return 'OWNER_CONNECTED';
     if (healthStatus === 'STALE') return 'OWNER_DISCONNECTED_STALE';
     return 'OWNER_DISCONNECTED';
   }
@@ -554,6 +568,22 @@ async function writeDataToSession(id, session, data) {
   return { success: true };
 }
 
+/**
+ * Submit Enter to a session using terminal-level methods.
+ * Used by POST /submit endpoint for explicit terminal-level submit.
+ * Priority: kitty send-text → cmux send-key → PTY \r fallback.
+ * Returns the strategy name or null on failure.
+ */
+function terminalLevelSubmit(id, session) {
+  // Priority 1: kitty send-text (terminal-level, bypasses PTY raw mode quirks)
+  if (session.type === 'wrapped' && sendViaKitty(id, '\r')) return 'kitty';
+  // Priority 2: cmux send-key
+  if (session.backend === 'cmux' && session.cmuxWorkspaceId && submitViaCmux(id)) return 'cmux';
+  // Priority 3: PTY \r
+  if (submitViaPty(session)) return 'pty_cr';
+  return null;
+}
+
 async function deliverInjectionToSession(id, session, prompt, options = {}) {
   const now = Date.now();
   const injectFailure = getInjectFailure(session, { nowMs: now });
@@ -705,7 +735,13 @@ function serializeSession(id, session, options = {}) {
     lastStateReportAt: session.lastStateReportAt || null,
     transport,
     semantic,
-    autoState: autoState ? { state: autoState.state, since: autoState.since, confidence: autoState.confidence } : null,
+    autoState: autoState ? {
+      state: autoState.state,
+      emoji: (STATE_DISPLAY[autoState.state] || {}).emoji || '?',
+      since: autoState.since,
+      confidence: autoState.confidence,
+      detail: autoState.detail,
+    } : null,
     mailbox: (() => {
       try {
         const pending = mailbox.peek(id).filter(m => m.state === 'pending' || m.state === 'in_flight');
@@ -738,7 +774,7 @@ for (const [id, meta] of Object.entries(_persisted)) {
       lastDisconnectedAt: meta.lastDisconnectedAt || meta.lastActivityAt || new Date().toISOString(),
       lastStateReportAt: meta.lastStateReportAt || null,
       stateReport: meta.stateReport || null,
-      clients: new Set(), isClosing: false, outputRing: [], ready: false,     };
+      clients: new Set(), isClosing: false, outputRing: [], ready: true,     };
     console.log(`[PERSIST] Restored session ${id} (awaiting reconnect)`);
   }
 }
@@ -883,6 +919,7 @@ app.post('/api/sessions/spawn', (req, res) => {
     ptyProcess.onExit(({ exitCode, signal }) => {
       const currentId = sessionRecord.id;
       console.log(`[EXIT] Session ${currentId} exited with code ${exitCode}`);
+      sessionStateManager.markDead(currentId, exitCode, signal);
       sessionRecord.isClosing = true;
       sessionRecord.clients.forEach(ws => ws.close(1000, 'Session exited'));
       if (sessions[currentId] === sessionRecord) {
@@ -953,7 +990,7 @@ app.post('/api/sessions/register', (req, res) => {
     clients: new Set(),
     isClosing: false,
     outputRing: [],
-    ready: delivery_type === 'aterm',  // aterm sessions are always ready (aterm manages readiness)
+    ready: true,  // all sessions are injectable once registered (#150)
       };
   // Check for existing session with same base alias and emit replaced event
   const baseAlias = session_id.replace(/-\d+$/, '');
@@ -1031,7 +1068,9 @@ app.get('/api/sessions/:id/state', (req, res) => {
 
   res.json({
     session_id: resolvedId,
-    auto: autoState || { state: 'unknown', detail: 'no state machine registered' },
+    auto: autoState
+      ? { ...autoState, emoji: (STATE_DISPLAY[autoState.state] || {}).emoji || '?' }
+      : { state: 'unknown', emoji: '?', detail: 'no state machine registered' },
     self_report: semantic,
     last_state_report_at: session.lastStateReportAt || null,
   });
@@ -1291,8 +1330,11 @@ function sendViaKitty(sessionId, text) {
       });
     }
     if (hasCr) {
-      // Delay before sending Return — CLI needs time to process text input
-      execSync('sleep 0.5', { timeout: 2000 });
+      // Delay before sending Return — only when text was sent in the same call
+      // (when CR-only, text was already delivered via a different path)
+      if (textOnly.length > 0) {
+        execSync('sleep 0.5', { timeout: 2000 });
+      }
       execSync(`kitty @ --to unix:${socket} send-text --match id:${windowId} $'\\r'`, {
         timeout: 3000, stdio: ['pipe', 'pipe', 'pipe']
       });
@@ -1383,29 +1425,25 @@ app.post('/api/sessions/:id/submit', async (req, res) => {
   const retryDelayMs = Math.min(Math.max(Number(req.body?.retry_delay_ms) || 500, 100), 2000);
   const preDelayMs = Math.min(Math.max(Number(req.body?.pre_delay_ms) || 0, 0), 1000);
 
-  const strategy = 'pty_cr';
-  console.log(`[SUBMIT] Session ${id} (${session.command}) strategy: ${strategy}${retries > 0 ? `, retries: ${retries}, pre_delay: ${preDelayMs}ms` : ''}`);
+  // Terminal-level submit: kitty → cmux → PTY fallback
+  console.log(`[SUBMIT] Session ${id} (${session.command})${retries > 0 ? `, retries: ${retries}, pre_delay: ${preDelayMs}ms` : ''}`);
 
   // Pre-delay: wait for paste rendering to complete before sending CR
   if (preDelayMs > 0) {
     await new Promise(resolve => setTimeout(resolve, preDelayMs));
   }
 
-  function executeSubmit() {
-    return submitViaPty(session);
-  }
-
-  let success = executeSubmit();
+  let strategy = terminalLevelSubmit(id, session);
   let attempts = 1;
 
   // Retry: resend CR if paste may have absorbed the first one
-  for (let i = 0; i < retries && success; i++) {
+  for (let i = 0; i < retries && strategy; i++) {
     await new Promise(resolve => setTimeout(resolve, retryDelayMs));
-    executeSubmit();
+    terminalLevelSubmit(id, session);
     attempts++;
   }
 
-  if (success) {
+  if (strategy) {
     const busMsg = JSON.stringify({
       type: 'submit',
       sender: 'daemon',
@@ -1419,7 +1457,7 @@ app.post('/api/sessions/:id/submit', async (req, res) => {
     });
     res.json({ success: true, strategy, attempts });
   } else {
-    res.status(503).json({ error: `Submit failed via ${strategy}`, strategy, attempts });
+    res.status(503).json({ error: 'Submit failed via all strategies (kitty/cmux/pty)', strategy: 'none', attempts });
   }
 });
 
@@ -2043,6 +2081,11 @@ const mailboxDelivery = new DeliveryEngine(mailbox, {
     }
   },
 });
+// Startup sweep: break stale lock files before starting delivery
+const staleBroken = mailbox.breakStaleLocks();
+if (staleBroken > 0) {
+  console.log(`[MAILBOX] Startup sweep: broke ${staleBroken} stale lock(s)`);
+}
 mailboxDelivery.start();
 
 const IDLE_THRESHOLD_SECONDS = 60;
@@ -2214,7 +2257,7 @@ wss.on('connection', (ws, req) => {
       clients: new Set([ws]),
       isClosing: false,
       outputRing: [],
-      ready: false,
+      ready: true,
           };
     sessions[sessionId] = autoSession;
     console.log(`[WS] Auto-registered wrapped session ${sessionId} on reconnect`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dmsdc-ai/aigentry-telepty",
-  "version": "0.1.96",
+  "version": "0.1.98",
   "main": "daemon.js",
   "bin": {
     "aigentry-telepty": "install.js",
@@ -9,9 +9,9 @@
     "telepty-mcp": "mcp-server/index.mjs"
   },
   "scripts": {
-    "test": "node --test test/auth.test.js test/daemon.test.js test/daemon-singleton.test.js test/cli.test.js test/skill-installer.test.js test/interactive-terminal.test.js test/runtime-info.test.js test/session-routing.test.js",
-    "test:watch": "node --test --watch test/auth.test.js test/daemon.test.js test/daemon-singleton.test.js test/cli.test.js test/skill-installer.test.js test/interactive-terminal.test.js test/runtime-info.test.js test/session-routing.test.js",
-    "test:ci": "node --test --test-reporter=spec test/auth.test.js test/daemon.test.js test/daemon-singleton.test.js test/cli.test.js test/skill-installer.test.js test/interactive-terminal.test.js test/runtime-info.test.js test/session-routing.test.js"
+    "test": "node --test test/auth.test.js test/daemon.test.js test/daemon-singleton.test.js test/cli.test.js test/skill-installer.test.js test/interactive-terminal.test.js test/runtime-info.test.js test/session-routing.test.js test/session-state.test.js test/mailbox-lock.test.js",
+    "test:watch": "node --test --watch test/auth.test.js test/daemon.test.js test/daemon-singleton.test.js test/cli.test.js test/skill-installer.test.js test/interactive-terminal.test.js test/runtime-info.test.js test/session-routing.test.js test/session-state.test.js test/mailbox-lock.test.js",
+    "test:ci": "node --test --test-reporter=spec test/auth.test.js test/daemon.test.js test/daemon-singleton.test.js test/cli.test.js test/skill-installer.test.js test/interactive-terminal.test.js test/runtime-info.test.js test/session-routing.test.js test/session-state.test.js test/mailbox-lock.test.js"
   },
   "keywords": [
     "pty",

package/session-state.js

@@ -1,16 +1,22 @@
 // session-state.js — PTY output-based session state machine for telepty.
 //
-// Automatically detects session state from PTY output patterns:
-//   running      — PTY output actively flowing
-//   idle         — no output for idle_timeout_ms + prompt pattern detected
-//   thinking     — AI CLI spinner/progress patterns detected
-//   stuck        — same error repeated stuck_repeat_count times within stuck_window_ms
-//   waiting_input— Y/n or interactive prompt pattern detected
+// 8-state dynamic session control (#185):
+//   starting     — PTY not yet spawned / initializing
+//   idle         — prompt detected (OSC 133;B or pattern), ready for input
+//   working      — PTY output actively flowing (AI generating text)
+//   thinking     — AI spinner/progress patterns (no substantive text)
+//   waiting      — interactive prompt detected (approve, y/n, confirm)
+//   error        — error patterns detected in output
+//   restarting   — CLI restart triggered
+//   dead         — PTY process terminated
 //
 // Usage:
 //   const { SessionStateMachine } = require('./session-state');
 //   const sm = new SessionStateMachine(sessionId, config);
 //   sm.feed(data);              // call on every PTY output chunk
+//   sm.markStarting();          // daemon: PTY spawn initiated
+//   sm.markDead(exitCode);      // daemon: PTY exited
+//   sm.markRestarting();        // daemon: auto-restart triggered
 //   sm.getState();              // → { state, since, confidence, last_output_preview, detail }
 //   sm.onTransition(callback);  // (from, to, detail) => {}
 //   sm.destroy();               // cleanup timers
@@ -22,11 +28,26 @@
 // ---------------------------------------------------------------------------
 
 const STATES = Object.freeze({
-  RUNNING:       'running',
-  IDLE:          'idle',
-  THINKING:      'thinking',
-  STUCK:         'stuck',
-  WAITING_INPUT: 'waiting_input',
+  STARTING:    'starting',
+  IDLE:        'idle',
+  WORKING:     'working',
+  THINKING:    'thinking',
+  WAITING:     'waiting',
+  ERROR:       'error',
+  RESTARTING:  'restarting',
+  DEAD:        'dead',
+});
+
+// State display metadata
+const STATE_DISPLAY = Object.freeze({
+  [STATES.STARTING]:   { emoji: '🔄', color: '\x1b[33m' },  // yellow
+  [STATES.IDLE]:       { emoji: '💤', color: '\x1b[32m' },   // green
+  [STATES.WORKING]:    { emoji: '🔨', color: '\x1b[36m' },   // cyan
+  [STATES.THINKING]:   { emoji: '🧠', color: '\x1b[35m' },   // magenta
+  [STATES.WAITING]:    { emoji: '⏳', color: '\x1b[33m' },   // yellow
+  [STATES.ERROR]:      { emoji: '🔴', color: '\x1b[31m' },   // red
+  [STATES.RESTARTING]: { emoji: '🔄', color: '\x1b[33m' },   // yellow
+  [STATES.DEAD]:       { emoji: '☠️', color: '\x1b[90m' },    // gray
 });
 
 // ---------------------------------------------------------------------------
@@ -35,9 +56,9 @@ const STATES = Object.freeze({
 
 const DEFAULT_CONFIG = Object.freeze({
   idle_timeout_ms:      5000,    // 5s silence + prompt → idle
-  stuck_repeat_count:   3,       // same error N times → stuck
-  stuck_window_ms:      180000,  // 3 min window for stuck detection
-  thinking_timeout_ms:  300000,  // 5 min thinking before → stuck
+  error_repeat_count:   3,       // same error N times → high confidence
+  error_window_ms:      180000,  // 3 min window for error dedup
+  thinking_timeout_ms:  300000,  // 5 min thinking before → error
   poll_interval_ms:     1000,    // state check tick interval
   output_preview_len:   200,     // last N chars for preview
   error_dedup_len:      120,     // error line length for dedup fingerprint
@@ -47,6 +68,11 @@ const DEFAULT_CONFIG = Object.freeze({
 // Pattern sets (all terminal-agnostic, CLI-agnostic)
 // ---------------------------------------------------------------------------
 
+// OSC 133 prompt marks — high-confidence idle detection
+// OSC 133;A = prompt start, OSC 133;B = command start (prompt ready)
+// Both indicate the shell/CLI is at a prompt waiting for input.
+const OSC_133_RE = /\x1b\]133;[AB](?:\x07|\x1b\\)/;
+
 // Shell prompt patterns — last line of output looks like a prompt
 const PROMPT_PATTERNS = [
   /[$#%>❯›»] *$/,              // common shell prompts
@@ -74,7 +100,7 @@ const THINKING_PATTERNS = [
 ];
 
 // Interactive input prompts — session is waiting for user input
-const WAITING_INPUT_PATTERNS = [
+const WAITING_PATTERNS = [
   /\[Y\/n\]/i,                 // [Y/n]
   /\(y\/N\)/i,                 // (y/N)
   /\[yes\/no\]/i,              // [yes/no]
@@ -91,7 +117,7 @@ const WAITING_INPUT_PATTERNS = [
   /\benter .*[:\s]*$/i,        // Enter something:
 ];
 
-// Error patterns for stuck detection
+// Error patterns for error detection
 const ERROR_PATTERNS = [
   /\berror\b[:\[]/i,
   /\bError:/,
@@ -109,7 +135,7 @@ const ERROR_PATTERNS = [
   /\bECONNREFUSED\b/,
 ];
 
-// ANSI escape stripper
+// ANSI escape stripper (preserves OSC 133 detection by running after OSC check)
 const ANSI_RE = /\x1b\[[0-9;]*[a-zA-Z]|\x1b\][^\x07]*\x07|\x1b[()][AB012]|\x1b\[[\?]?[0-9;]*[hlm]/g;
 
 function stripAnsi(str) {
@@ -126,9 +152,9 @@ class SessionStateMachine {
     this.config = { ...DEFAULT_CONFIG, ...config };
 
     // Current state
-    this._state = STATES.RUNNING;
+    this._state = STATES.STARTING;
     this._since = Date.now();
-    this._confidence = 0.5;
+    this._confidence = 1.0;
     this._detail = null;
 
     // Output tracking
@@ -137,10 +163,13 @@ class SessionStateMachine {
     this._recentLines = [];         // last N stripped lines
     this._maxRecentLines = 50;
 
-    // Stuck detection: error fingerprints with timestamps
+    // OSC 133 tracking
+    this._lastOsc133At = null;
+
+    // Error detection: error fingerprints with timestamps
     this._errorHistory = [];        // [{ fingerprint, timestamp }]
 
-    // Thinking start time (for thinking → stuck timeout)
+    // Thinking start time (for thinking → error timeout)
     this._thinkingStartedAt = null;
 
     // Transition listeners
@@ -162,6 +191,16 @@ class SessionStateMachine {
     const previewLen = this.config.output_preview_len;
     this._lastOutputPreview = (this._lastOutputPreview + data).slice(-previewLen);
 
+    // Check for OSC 133 prompt mark in RAW data (before ANSI stripping)
+    if (OSC_133_RE.test(data)) {
+      this._lastOsc133At = now;
+      this._transition(STATES.IDLE, 0.95, {
+        trigger: 'osc_133_prompt',
+        timestamp: new Date(now).toISOString(),
+      });
+      return;
+    }
+
     // Strip ANSI and split into lines for pattern analysis
     const cleaned = stripAnsi(data);
     const lines = cleaned.split(/\r?\n/).filter(l => l.trim().length > 0);
@@ -174,6 +213,11 @@ class SessionStateMachine {
       this._recentLines.shift();
     }
 
+    // Don't run detection on lifecycle states managed externally
+    if (this._state === STATES.DEAD || this._state === STATES.RESTARTING) {
+      return;
+    }
+
     // Run detection pipeline (order matters: most specific first)
     this._detect(now);
   }
@@ -207,6 +251,24 @@ class SessionStateMachine {
     this._listeners = [];
   }
 
+  // --- Lifecycle methods (called by daemon) ---
+
+  markStarting() {
+    this._transition(STATES.STARTING, 1.0, { trigger: 'lifecycle' });
+  }
+
+  markDead(exitCode, signal) {
+    this._transition(STATES.DEAD, 1.0, {
+      trigger: 'lifecycle',
+      exit_code: exitCode ?? null,
+      signal: signal ?? null,
+    });
+  }
+
+  markRestarting() {
+    this._transition(STATES.RESTARTING, 1.0, { trigger: 'lifecycle' });
+  }
+
   // --- Internal ---
 
   _transition(newState, confidence, detail) {
@@ -249,20 +311,20 @@ class SessionStateMachine {
       ? this._recentLines[this._recentLines.length - 1].text
       : '';
 
-    // --- Priority 1: waiting_input (most specific, must act on immediately) ---
-    if (this._matchesAny(lastLine, WAITING_INPUT_PATTERNS)) {
-      this._transition(STATES.WAITING_INPUT, 0.9, {
+    // --- Priority 1: waiting (most specific, must act on immediately) ---
+    if (this._matchesAny(lastLine, WAITING_PATTERNS)) {
+      this._transition(STATES.WAITING, 0.9, {
         trigger: 'pattern',
         matched_line: lastLine.slice(0, 100),
       });
       return;
     }
 
-    // --- Priority 2: stuck detection (repeated errors) ---
+    // --- Priority 2: error detection (error patterns in output) ---
     this._trackErrors(now);
-    const stuckResult = this._checkStuck(now);
-    if (stuckResult) {
-      this._transition(STATES.STUCK, stuckResult.confidence, stuckResult.detail);
+    const errorResult = this._checkError(now);
+    if (errorResult) {
+      this._transition(STATES.ERROR, errorResult.confidence, errorResult.detail);
       return;
     }
 
@@ -275,8 +337,8 @@ class SessionStateMachine {
       return;
     }
 
-    // --- Priority 4: running (we just received output, not matching other patterns) ---
-    this._transition(STATES.RUNNING, 0.9, {
+    // --- Priority 4: working (we just received output, not matching other patterns) ---
+    this._transition(STATES.WORKING, 0.9, {
       trigger: 'output_received',
     });
   }
@@ -285,11 +347,16 @@ class SessionStateMachine {
     const now = Date.now();
     const silenceMs = now - this._lastOutputAt;
 
-    // Thinking → stuck after timeout
+    // Don't override lifecycle states
+    if (this._state === STATES.DEAD || this._state === STATES.RESTARTING || this._state === STATES.STARTING) {
+      return;
+    }
+
+    // Thinking → error after timeout
     if (this._state === STATES.THINKING && this._thinkingStartedAt) {
       const thinkingDuration = now - this._thinkingStartedAt;
       if (thinkingDuration > this.config.thinking_timeout_ms) {
-        this._transition(STATES.STUCK, 0.7, {
+        this._transition(STATES.ERROR, 0.7, {
           trigger: 'thinking_timeout',
           thinking_duration_ms: thinkingDuration,
         });
@@ -297,10 +364,10 @@ class SessionStateMachine {
       }
     }
 
-    // Silence → idle (only if last output looks like a prompt)
+    // Silence → idle (only if last output looks like a prompt or OSC 133 was recent)
     if (silenceMs > this.config.idle_timeout_ms) {
-      // Don't override stuck or waiting_input with idle
-      if (this._state === STATES.STUCK || this._state === STATES.WAITING_INPUT) {
+      // Don't override error or waiting with idle
+      if (this._state === STATES.ERROR || this._state === STATES.WAITING) {
         return;
       }
 
@@ -308,11 +375,12 @@ class SessionStateMachine {
         ? this._recentLines[this._recentLines.length - 1].text
         : '';
 
+      const hasOsc133 = this._lastOsc133At && (now - this._lastOsc133At) < this.config.idle_timeout_ms * 2;
       const hasPrompt = this._matchesAny(lastLine, PROMPT_PATTERNS);
-      const confidence = hasPrompt ? 0.9 : 0.6;
+      const confidence = hasOsc133 ? 0.95 : (hasPrompt ? 0.9 : 0.6);
 
       this._transition(STATES.IDLE, confidence, {
-        trigger: hasPrompt ? 'prompt_detected' : 'silence_timeout',
+        trigger: hasOsc133 ? 'osc_133_prompt' : (hasPrompt ? 'prompt_detected' : 'silence_timeout'),
         silence_ms: silenceMs,
         last_line: lastLine.slice(0, 100),
       });
@@ -320,7 +388,7 @@ class SessionStateMachine {
   }
 
   _trackErrors(now) {
-    const cutoff = now - this.config.stuck_window_ms;
+    const cutoff = now - this.config.error_window_ms;
     // Expire old errors
     this._errorHistory = this._errorHistory.filter(e => e.timestamp > cutoff);
 
@@ -336,8 +404,8 @@ class SessionStateMachine {
     }
   }
 
-  _checkStuck(now) {
-    if (this._errorHistory.length < this.config.stuck_repeat_count) {
+  _checkError(now) {
+    if (this._errorHistory.length === 0) {
       return null;
     }
 
@@ -347,20 +415,29 @@ class SessionStateMachine {
       counts[e.fingerprint] = (counts[e.fingerprint] || 0) + 1;
     }
 
+    // Find the most repeated error
+    let maxFp = null;
+    let maxCount = 0;
     for (const [fp, count] of Object.entries(counts)) {
-      if (count >= this.config.stuck_repeat_count) {
-        return {
-          confidence: Math.min(0.95, 0.7 + (count - this.config.stuck_repeat_count) * 0.05),
-          detail: {
-            trigger: 'repeated_error',
-            error_fingerprint: fp,
-            repeat_count: count,
-            window_ms: this.config.stuck_window_ms,
-          },
-        };
+      if (count > maxCount) {
+        maxCount = count;
+        maxFp = fp;
       }
     }
 
+    // Repeated errors → high confidence error state
+    if (maxCount >= this.config.error_repeat_count) {
+      return {
+        confidence: Math.min(0.95, 0.7 + (maxCount - this.config.error_repeat_count) * 0.05),
+        detail: {
+          trigger: 'repeated_error',
+          error_fingerprint: maxFp,
+          repeat_count: maxCount,
+          window_ms: this.config.error_window_ms,
+        },
+      };
+    }
+
     return null;
   }
 
@@ -437,6 +514,30 @@ class SessionStateManager {
     return result;
   }
 
+  /**
+   * Mark a session as starting (PTY spawn initiated).
+   */
+  markStarting(sessionId) {
+    const sm = this._machines.get(sessionId);
+    if (sm) sm.markStarting();
+  }
+
+  /**
+   * Mark a session as dead (PTY exited).
+   */
+  markDead(sessionId, exitCode, signal) {
+    const sm = this._machines.get(sessionId);
+    if (sm) sm.markDead(exitCode, signal);
+  }
+
+  /**
+   * Mark a session as restarting (auto-restart triggered).
+   */
+  markRestarting(sessionId) {
+    const sm = this._machines.get(sessionId);
+    if (sm) sm.markRestarting();
+  }
+
   /**
    * Unregister and cleanup a session's state machine.
    */
@@ -484,13 +585,15 @@ class SessionStateManager {
 
 module.exports = {
   STATES,
+  STATE_DISPLAY,
   DEFAULT_CONFIG,
   SessionStateMachine,
   SessionStateManager,
   // Exported for testing
   PROMPT_PATTERNS,
   THINKING_PATTERNS,
-  WAITING_INPUT_PATTERNS,
+  WAITING_PATTERNS,
   ERROR_PATTERNS,
+  OSC_133_RE,
   stripAnsi,
 };