@dmsdc-ai/aigentry-telepty 0.5.5 → 0.5.6

package/daemon.js

@@ -88,8 +88,18 @@ sessionStateManager.onTransition((sessionId, from, to, detail) => {
     // Mark as idle-notified (but keep the entry — REPORT is still pending).
     // Entry is cleared when REPORT arrives (via inject endpoint) OR session dies.
     if (pendingReport.idleNotified) return; // only fire once
+    // #545: only an OSC133-marked idle with the injected body consumed from the PTY outputRing
+    // is trustworthy enough to report TASK_COMPLETE. A weak prompt-glyph / silence flip (the
+    // residual WORKING case the THINKING-only state guard doesn't cover) stays
+    // TASK_IDLE_UNCONFIRMED — never a false complete.
+    const idleTrigger = detail && detail.detail ? detail.detail.trigger : null;
+    const bodyText = pendingReport.injectedBodyPreview;
+    const bodyVisible = bodyText
+      ? submitGate.observeBodyVisibility(session, bodyText).visible === true
+      : false;
+    const idleEvidenceReliable = idleTrigger === 'osc_133_prompt' && !bodyVisible;
     // real-idle: the state manager observed a genuine busy→idle transition.
-    fireAutoReport(sessionId, session, pendingReport, 'real-idle');
+    fireAutoReport(sessionId, session, pendingReport, 'real-idle', { idleEvidenceReliable });
   }
 
   // Fire TASK_DEAD_NO_REPORT when session dies with a pending report
@@ -307,11 +317,23 @@ function fireAutoReport(targetId, targetSession, pendingReport, trigger, deps =
     pendingReport.submitConfirmedAt ||
     (pendingReport.submitConfirm && pendingReport.submitConfirm.accepted === true)
   );
+  // #545: a `real-idle` flip with weak evidence (no OSC133 REPL-done mark / injected body still
+  // visible in the PTY outputRing) must NOT be reported TASK_COMPLETE — a still-busy worker that
+  // merely paused output gets the honest TASK_IDLE_UNCONFIRMED. The caller (onTransition) sets
+  // deps.idleEvidenceReliable; === false forces the downgrade. Scoped to submitExpected (the #545
+  // symptom — a submit-confirmed worker still thinking), consistent with the BUG-B confirm gate;
+  // plain non-submit injects keep their existing floor-based completion. Absent flag / other
+  // triggers preserve prior behavior.
+  const idleEvidenceUnreliable = trigger === 'real-idle'
+    && pendingReport.submitExpected
+    && deps.idleEvidenceReliable === false;
   const confirmed = trigger === 'ready-signal' && pendingReport.submitExpected
     ? false
-    : pendingReport.submitExpected
-      ? strongSubmitConfirmed
-      : (elapsedNum >= AUTO_REPORT_MIN_REAL_SECONDS || hasSubmitEvidence);
+    : idleEvidenceUnreliable
+      ? false
+      : pendingReport.submitExpected
+        ? strongSubmitConfirmed
+        : (elapsedNum >= AUTO_REPORT_MIN_REAL_SECONDS || hasSubmitEvidence);
   const injTag = pendingReport.injectId ? ` inject=${pendingReport.injectId}` : '';
   const reportMsg = confirmed
     ? `TASK_COMPLETE: ${targetId} is now idle after processing inject (${elapsed}s, via ${trigger}${injTag})`
@@ -1188,9 +1210,10 @@ async function writeDataToSession(id, session, data) {
  * 0x0D into the CLI's innermost node-pty. The former kitty `send-text` (P1) and
  * `cmux send-key` (P2) branches were SURFACE ops on a flaky side channel (75×
  * "Failed to write to socket" vs 0× for pty_cr in a 222k-line run; live
- * 2026-06-07 confirmed pty-only works 3/3). `submitViaCmux`/`sendViaKitty` defs
- * are kept (non-submit callers); codebase removal is gated on the warp/tmux
- * matrix. See docs/adr/2026-06-07-submit-via-pty-context-layer.md.
+ * 2026-06-07 confirmed pty-only works 3/3). The `submitViaCmux`/`sendViaKitty`
+ * defs were since removed (#544/#546 — submit-all also migrated to PTY, leaving
+ * zero cmux send-key in the submit path). See
+ * docs/adr/2026-06-07-submit-via-pty-context-layer.md.
  *
  * Returns the strategy name ('pty_cr') or null on failure.
  */
@@ -2018,45 +2041,6 @@ function findKittyWindowId(socket, sessionId) {
   return null;
 }
 
-function sendViaKitty(sessionId, text) {
-  const { execSync } = require('child_process');
-  const socket = findKittySocket();
-  if (!socket) return false;
-
-  const windowId = findKittyWindowId(socket, sessionId);
-  if (!windowId) {
-    console.error(`[KITTY] No window found for ${sessionId}`);
-    return false;
-  }
-
-  try {
-    // Split text and CR — send-text for both (send-key corrupts keyboard protocol)
-    const hasCr = text.endsWith('\r') || text.endsWith('\n');
-    const textOnly = hasCr ? text.slice(0, -1) : text;
-    if (textOnly.length > 0) {
-      const escaped = textOnly.replace(/\\/g, '\\\\').replace(/'/g, "'\\''");
-      execSync(`kitty @ --to unix:${socket} send-text --match id:${windowId} '${escaped}'`, {
-        timeout: 5000, stdio: ['pipe', 'pipe', 'pipe']
-      });
-    }
-    if (hasCr) {
-      // 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']
-      });
-    }
-    console.log(`[KITTY] Sent ${textOnly.length} chars${hasCr ? ' + Return' : ''} to ${sessionId} (window ${windowId})`);
-    return true;
-  } catch (err) {
-    console.error(`[KITTY] Failed for ${sessionId}:`, err.message);
-    return false;
-  }
-}
-
 function submitViaOsascript(sessionId, keyCombo) {
   const { execSync } = require('child_process');
   const session = sessions[sessionId];
@@ -2107,22 +2091,6 @@ function submitViaOsascript(sessionId, keyCombo) {
   }
 }
 
-function submitViaCmux(sessionId) {
-  const { execSync } = require('child_process');
-  const session = sessions[sessionId];
-  if (!session || !session.cmuxWorkspaceId) return false;
-  try {
-    execSync(`cmux send-key --workspace ${session.cmuxWorkspaceId} return`, {
-      timeout: 5000, stdio: ['pipe', 'pipe', 'pipe']
-    });
-    console.log(`[SUBMIT] cmux send-key return for ${sessionId} (workspace ${session.cmuxWorkspaceId})`);
-    return true;
-  } catch (err) {
-    console.error(`[SUBMIT] cmux send-key failed for ${sessionId}:`, err.message);
-    return false;
-  }
-}
-
 // POST /api/sessions/:id/submit — render-gated CLI-aware submit
 //
 // Default behavior (0.3.0+): wait for the target REPL to be ready (sessionStateManager
@@ -2419,27 +2387,22 @@ app.post('/api/sessions/:id/submit', async (req, res) => {
   return res.json(responseBody);
 });
 
-// POST /api/sessions/submit-all — Submit all active sessions
-app.post('/api/sessions/submit-all', (req, res) => {
+// Submit Enter to every active session. #546: submit is a PTY/context op (bare 0x0D) for every
+// wrapped + spawned backend INCLUDING cmux — the path validated 3/3 live for per-session submit
+// (#544). The cmux `send-key --surface return` surface op is removed (ZERO cmux send-key);
+// osascript Cmd+Enter remains only for app-window sessions with no PTY bridge. Exported (pure
+// over the passed sessions map) so the dispatch is unit-testable without starting the daemon.
+function runSubmitAll(sessionsMap) {
   const results = { successful: [], failed: [] };
 
-  for (const [id, session] of Object.entries(sessions)) {
+  for (const [id, session] of Object.entries(sessionsMap)) {
     const strategy = getSubmitStrategy(session.command);
     let success = false;
 
-    // cmux per-session backend
-    if (session.backend === 'cmux') {
-      success = terminalBackend.cmuxSendEnter(id);
-    }
-    if (!success && session.backend === 'cmux' && session.cmuxWorkspaceId) {
-      success = submitViaCmux(id);
-    }
-    if (!success) {
-      if (strategy === 'pty_cr') {
-        success = submitViaPty(session);
-      } else if (strategy === 'osascript_cmd_enter') {
-        success = submitViaOsascript(id, 'cmd_enter');
-      }
+    if (strategy === 'pty_cr') {
+      success = submitViaPty(session);
+    } else if (strategy === 'osascript_cmd_enter') {
+      success = submitViaOsascript(id, 'cmd_enter');
     }
 
     if (success) {
@@ -2449,7 +2412,12 @@ app.post('/api/sessions/submit-all', (req, res) => {
     }
   }
 
-  res.json({ success: true, results });
+  return results;
+}
+
+// POST /api/sessions/submit-all — Submit all active sessions
+app.post('/api/sessions/submit-all', (req, res) => {
+  res.json({ success: true, results: runSubmitAll(sessions) });
 });
 
 app.post('/api/sessions/:id/inject', async (req, res) => {
@@ -3528,6 +3496,7 @@ module.exports = {
   forceSubmitDeliveredToSurface,  // #544/#537/Bug B: PTY-native force-confirm (pty_cr = delivered)
   terminalLevelSubmit,            // #544: PTY-only submit path (pty_cr | null)
   submitViaPty,                   // #544: bare-0x0D submit into the innermost node-pty
+  runSubmitAll,                   // #546: submit-all via PTY for every backend (no cmux send-key)
   failBootstrapQueueOnTimeout,    // #31: actionable bootstrap-timeout queue flush
   shouldApplyOwnerAliveFloor,     // #29: owner-alive optimistic-floor decision (deps DI: isProcessRunning/...)
   scheduleBootstrapPromptPoll,    // #29: arms the floor timer (deps DI: setTimeout/...)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dmsdc-ai/aigentry-telepty",
-  "version": "0.5.5",
+  "version": "0.5.6",
   "main": "daemon.js",
   "bin": {
     "aigentry-telepty": "install.js",

package/session-state.js

@@ -356,8 +356,7 @@ class SessionStateMachine {
     });
   }
 
-  _tick() {
-    const now = Date.now();
+  _tick(now = Date.now()) {
     const silenceMs = now - this._lastOutputAt;
 
     // Don't override lifecycle states
@@ -389,6 +388,16 @@ class SessionStateMachine {
         : '';
 
       const hasOsc133 = this._lastOsc133At && (now - this._lastOsc133At) < this.config.idle_timeout_ms * 2;
+
+      // #545: a THINKING session that merely went quiet is STILL thinking. The claude TUI
+      // input-box glyph (›/❯) false-matches PROMPT_PATTERNS and pure silence flips at 0.6, so
+      // a weak signal would wrongly end thinking. Only a reliable REPL-done mark (OSC 133) may.
+      // WORKING is intentionally NOT guarded — a real shell prompt `$ ` legitimately settles
+      // working→idle (test 255); the daemon real-idle gate covers the residual WORKING case.
+      if (this._state === STATES.THINKING && !hasOsc133) {
+        return;
+      }
+
       const hasPrompt = this._matchesAny(lastLine, PROMPT_PATTERNS);
       const confidence = hasOsc133 ? 0.95 : (hasPrompt ? 0.9 : 0.6);