create-walle 0.10.2 → 0.10.3

package/template/coding-task-manager/lib/idle-notify.js

@@ -0,0 +1,491 @@
+'use strict';
+
+// Landing-throughput WP-6 shard S11 (design doc §5 D-10 "move-only", §6 "Shard module
+// seam"): the idle-notify cluster (checkIdleNotify + its four private helpers) moves out of
+// server.js VERBATIM into this module behind the same configure(deps) seam as
+// lib/api/session-attach.js and lib/terminal-attach-geometry.js (S6), lib/walle-history-serve.js
+// (S8), lib/codex-rollout-history.js (S9) and lib/terminal-input-prepared.js (S10). It registers
+// NO route and NO socket handler: server.js keeps the five pass-through call sites (the
+// _statusBindings probeIdle arrow, the _suppressionReplay factory, the session-create service
+// bindings object, the sessionAttachApi bindings object and the adopted-pty flush) as
+// idleNotify.checkIdleNotify(...), plus this configure() seam.
+// Bodies are identical to server.js declarations except for the `_deps.` prefix on every
+// identifier that used to resolve to a server.js top-level binding (D-10 rule 1), proven by
+// `node bin/move-only-check.js`. No moved body contains an inline `require(...)`, so there is no
+// require rebase here (unlike S1/S3/S6/S8).
+//
+// The module deliberately lives at lib/idle-notify.js and NOT under lib/ws/: checkIdleNotify is
+// the output-quiet idle/waiting detector, not a ws-router handler.
+//
+// Injected deps, per function:
+//   _idlePromptDetections: IDLE_PROMPT_PATTERNS, _providerGenerationGateState, _providerIdFromCmd, _providerTurnFinishedDetection, _providerWaitingInputDetection, approvalAgent, recordSessionDiagnostic, terminalChoice
+//   _unconfirmedPatternWait: (none)
+//   _prioritizeIdlePromptDetections: (none)
+//   _runningEvidenceHoldUntil: IDLE_NOTIFY_DELAY_MS, _providerRunningHoldMsForSession, _serverObservedTimeMs, _sessionCapture, idleNotifyState
+//   checkIdleNotify: IDLE_NOTIFY_DELAY_MS, STATUS_EVIDENCE, _clearServerWaitingForInput, _composerMayClose, _deriveApprovalBannerLabel, _getHeadlessViewportRead, _isActivePtyChunk, _isStatusOnlyPtyChunk, _markBackgroundAgentsEvidence, _markServerSessionTurnClosed, _markServerSessionTurnEvidence, _markTerminalLifecycleChanged, _providerActivelyGenerating, _providerIdFromCmd, _recheckHeadlessApprovalPrompt, _recordWaitCleared, _selectionCardFpForSession, _statusBindings, _suppressCtmUiRefreshActivity, _suppressionReplay, _wordsMayUnstickWait, autoApprovalBuffers, broadcastToAll, dispatchMobileNotification, idleNotifyState, isSessionAtLivePrompt, mobileNotifications, reconcileSessionWaitState, recordSessionDiagnostic, restoreRuntime, sessionPolicy, statusRuntime, stripAnsi, telemetryReceiver
+//
+// Mutable module state (D-10 rule 2 / S9 lesson 7): _sessionCapture is a server.js `let`
+// reassigned once during boot (in the boot sequence), so it is injected as a GETTER -- never a
+// copy. Every other dep is a by-value reference, and no moved body writes a server.js binding
+// (checked with an acorn walk), so there is no get/set pair here. Calls between the five moved
+// functions stay direct (no _deps.).
+
+let _deps = null;
+
+function configure(deps = {}) {
+  _deps = deps;
+}
+
+function _idlePromptDetections(session, lastLines, rawTail) {
+  const detections = [];
+  const providerId = session?._providerId || _deps._providerIdFromCmd(session?.cmd || '');
+  for (const { pattern, test, reason, provider } of _deps.IDLE_PROMPT_PATTERNS) {
+    if (provider && provider !== providerId) continue;
+    if ((test && test(lastLines)) || (pattern && pattern.test(lastLines))) {
+      detections.push({ reason, source: 'pattern' });
+    }
+  }
+  try {
+    const choice = _deps.terminalChoice.extractTerminalChoice(rawTail || lastLines);
+    if (choice && (choice.kind === 'numbered' || choice.kind === 'form')) {
+      detections.push({ reason: 'choice', source: 'terminal-choice', fingerprint: choice.fingerprint });
+    }
+  } catch (e) {
+    _deps.recordSessionDiagnostic(session?.id || '', 'terminal-choice-detection-error', {
+      error: e && e.message || String(e),
+    });
+  }
+  const providerDetection = _deps._providerWaitingInputDetection(session, rawTail || lastLines);
+  if (providerDetection) detections.push({ ...providerDetection, source: providerDetection.source || 'provider' });
+  if (_deps._providerTurnFinishedDetection(session, rawTail || lastLines)) {
+    detections.push({ reason: 'finished', source: 'provider-ready-composer' });
+  }
+  // "Agent is actively generating" gate (provider-aware). Under the Claude V2 rule (the default) generation is the
+  // busy status-line shape or live background-agent evidence, NOT the "esc to interrupt" footer (that phrase is
+  // ignored: it lingers in scrollback). When the provider reports it is
+  // generating, the agent is NOT blocked on the user, so drop EVERY blocker reason —
+  // including 'input', which the composer-footer gate below deliberately keeps. This
+  // is what stops a long, output-quiet tool turn (the bare `❯` composer is still
+  // painted, so the `❯` idle-notify pattern fires) from being mislabeled "Needs You".
+  // A genuinely idle composer lacks this footer, so real idle-notify is unaffected.
+  // Claude's per-chunk busy channel also gives this gate bounded memory: a single
+  // footer-less repaint cannot leak a false input wait between live status paints.
+  // The memory arm applies only to the non-blocking input reason; approval and
+  // choice remain positive blocking assertions and are never hidden by stale work.
+  const generation = _deps._providerGenerationGateState(session, rawTail || lastLines);
+  if (generation.activelyGenerating || generation.heldByRecentEvidence) {
+    const isBlocker = generation.activelyGenerating
+      ? (d) => d.reason === 'input' || d.reason === 'approval' || d.reason === 'choice'
+      : (d) => d.reason === 'input';
+    const blockers = detections.filter(isBlocker);
+    if (blockers.length) {
+      _deps.recordSessionDiagnostic(session?.id || '', 'waiting-input-generating-gated', {
+        suppressed: blockers.map((d) => `${d.reason}:${d.source}`).join(','),
+      });
+      return detections.filter((d) => !isBlocker(d));
+    }
+  }
+  // Negative "not at a live prompt" gate. A live approval/choice widget REPLACES
+  // the composer, so positive evidence that the agent is idle/generating at its
+  // ready prompt is decisive proof it is NOT blocked at a permission prompt or a
+  // selection menu. Two independent, provider-spanning signals:
+  //   (1) `hasComposerStatusFooter` — the agent's own composer/working footer is on
+  //       screen. This vocabulary is Claude-specific (esc to interrupt, shift+tab to
+  //       cycle, ? for shortcuts), so on its own it does NOT cover Codex/Cursor.
+  //   (2) a `finished` detection from the provider's own state detector
+  //       (`_providerTurnFinishedDetection` → e.g. Claude/Codex
+  //       `detectTurnFinished`, which
+  //       returns false when a REAL pending widget like CODEX_PENDING_PROMPT_RE is on
+  //       screen). This makes the gate provider-aware for free: a Codex/any-provider
+  //       session that has repainted its ready composer suppresses the bogus banner.
+  // Without this, a session merely DISPLAYING approval-shaped prose (a coding agent's
+  // numbered to-do list, this very tool discussing approvals) raised a false
+  // "Approval needed" banner. Only the blocker reasons are gated: 'input' is the
+  // normal ready-composer idle-notify state and 'finished' is itself a positive idle
+  // signal, so both pass through.
+  const composerFooter = _deps.approvalAgent.hasComposerStatusFooter(rawTail || lastLines);
+  const turnFinished = detections.some((d) => d.reason === 'finished');
+  if (detections.some((d) => d.reason === 'approval' || d.reason === 'choice') &&
+      (composerFooter || turnFinished)) {
+    const filtered = detections.filter((d) => d.reason !== 'approval' && d.reason !== 'choice');
+    _deps.recordSessionDiagnostic(session?.id || '', 'waiting-input-composer-gated', {
+      via: composerFooter ? (turnFinished ? 'composer+finished' : 'composer') : 'finished',
+      suppressed: detections
+        .filter((d) => d.reason === 'approval' || d.reason === 'choice')
+        .map((d) => `${d.reason}:${d.source}`)
+        .join(','),
+    });
+    return filtered;
+  }
+  return detections;
+}
+
+function _unconfirmedPatternWait(source, liveConfirmed) {
+  return source === 'pattern' && !liveConfirmed;
+}
+
+function _prioritizeIdlePromptDetections(detections) {
+  const rank = (d) => {
+    if (d?.reason === 'approval') return 0;
+    if (d?.reason === 'choice') return 1;
+    if (d?.reason === 'input') return 2;
+    if (d?.reason === 'finished') return 4;
+    return 3;
+  };
+  return [...detections].sort((a, b) => rank(a) - rank(b));
+}
+
+function _runningEvidenceHoldUntil(sessionId, session, now = Date.now()) {
+  const holdMs = Math.max(_deps.IDLE_NOTIFY_DELAY_MS, _deps._providerRunningHoldMsForSession(session));
+  const candidates = [];
+  const st = _deps.idleNotifyState.get(sessionId);
+  if (st && st.lastSignificantOutput) candidates.push(st.lastSignificantOutput);
+  if (session && session.lastPtyActivity) candidates.push(_deps._serverObservedTimeMs(session.lastPtyActivity, now, session, 'lastPtyActivity', 'idle-notify'));
+  if (_deps._sessionCapture && typeof _deps._sessionCapture.getStatus === 'function') {
+    for (const id of [sessionId, session?._claudeSessionId].filter(Boolean)) {
+      try {
+        const projected = _deps._sessionCapture.getStatus(id);
+        if (projected && projected.status === 'running' && projected.lastActivity) {
+          candidates.push(_deps._serverObservedTimeMs(projected.lastActivity, now, session, 'captureLastActivity', 'idle-notify'));
+        }
+      } catch {}
+    }
+  }
+  const newest = Math.max(0, ...candidates.filter((ms) => Number.isFinite(ms) && ms > 0));
+  if (!newest) return 0;
+  return newest + holdMs;
+}
+
+function checkIdleNotify(sessionId, session, data, delayMs = _deps.IDLE_NOTIFY_DELAY_MS) {
+  if (!_deps.sessionPolicy(session).humanAttention) return; // worker-session-class WP-5: no human attends a headless worker
+  const hasAuthoritativeSource = _deps.telemetryReceiver.hasAuthoritativeSource(sessionId);
+  let st = _deps.idleNotifyState.get(sessionId);
+  if (!st) {
+    st = { timer: null, notified: false, reason: '', notifiedAt: 0, lastOutput: Date.now(), buf: '', freshBuf: '', _lastCheck: 0, suppressedFresh: '', suppressReplayTimer: null };
+    _deps.idleNotifyState.set(sessionId, st);
+  }
+
+  // Accumulate output — cheap string concat only, no regex per-chunk
+  st.buf += data;
+  if (st.buf.length > 4096) st.buf = st.buf.slice(-3000);
+  st.freshBuf += data; // Track content since last check
+
+  st.lastOutput = Date.now();
+
+  // Throttle the expensive work: only process every 500ms instead of per-chunk
+  const now = Date.now();
+  if (now - st._lastCheck < 500) return;
+  st._lastCheck = now;
+
+  // Only reset notified flag if FRESH output (since last check) has substantial content.
+  // Strip comprehensively (CSI, OSC, charset, control). Check for word characters
+  // (letters/digits) to distinguish real text from TUI spinner glyphs (✢✳✶✻·⠂).
+  const freshChunk = st.freshBuf;
+  const freshStripped = _deps.stripAnsi(freshChunk).trim();
+  st.freshBuf = ''; // Reset for next interval
+  // Tab activation / resize / reflow makes the agent's TUI repaint a full frame,
+  // and the deferred-restore replay does the same. That redraw is NOT fresh agent
+  // activity, so it must not bump significant-output bookkeeping or (below) reset a
+  // waiting session — the exact false Idle/Needs-You → Running flip seen on click.
+  // Honor the same UI-refresh / restore suppression the main PTY data handler
+  // already applies (genuine work is still caught via the busy-status path).
+  const refreshSuppressed = _deps._suppressCtmUiRefreshActivity(session) ||
+    _deps.restoreRuntime.restoreActivitySuppressed(session, now);
+  const wordsPresent = _deps._isActivePtyChunk(session, freshChunk) &&
+    !_deps._isStatusOnlyPtyChunk(session, freshChunk) &&
+    /\w/.test(freshStripped) &&
+    freshStripped.length > 5;
+  const hasWords = !refreshSuppressed && wordsPresent;
+  // The window swallowed real content — arm the once-only replay so this text still
+  // gets a detection pass when the suppression window closes.
+  if (refreshSuppressed && wordsPresent) {
+    _deps._suppressionReplay.armPromptReplay(sessionId, session, st, freshChunk);
+  }
+  if (hasWords) {
+    st.lastSignificantOutput = now;
+    if (session?._activeTurnOpen && !_deps.statusRuntime.viewerProvoked(session, now)) _deps._markServerSessionTurnEvidence(session, now, 'terminal-output', { ledger: false });
+  }
+  // Authority inversion: when telemetry/hooks own this session, generic word
+  // output may not clear a waiting state into Running — the structured source
+  // (codex user_prompt/tool_decision, claude start hook) or the strict
+  // busy-status line does that. Without a structured source, words remain the
+  // unstick signal.
+  if (hasWords && st.notified && !_deps.statusRuntime.viewerProvoked(session, now) && !_deps._statusBindings.keepBlockingWait(session) && _deps._wordsMayUnstickWait(session, now, hasAuthoritativeSource)) { // F-B: viewer-provoked words never clear a wait
+    const hasUnsubmittedWaitingInput = !!(session?._waitingForInput &&
+      session._lastNonResolvingWaitingInputAt &&
+      (!session._lastWaitingResolveInputAt ||
+        session._lastNonResolvingWaitingInputAt > session._lastWaitingResolveInputAt));
+    if (!hasUnsubmittedWaitingInput) {
+      st.notified = false;
+      st.reason = '';
+      st.notifiedAt = 0;
+      if (session) {
+        _deps._recordWaitCleared(session, 'terminal-output');
+        session._waitingForInput = false;
+        session._waitingForInputLiveConfirmed = null;
+        session._waitingForInputReason = '';
+        session._waitingForInputMessage = '';
+        session._waitingForInputAt = 0;
+      }
+      // Tell clients this session is no longer idle — clears _waitingForInput
+      _deps.broadcastToAll({ type: 'session-resumed', id: sessionId });
+      // If a provider hook missed the next start transition, real terminal
+      // output is enough to unstick the sidebar until the hook catches up.
+      if (hasAuthoritativeSource) {
+        _deps.broadcastToAll({ type: 'session.status', id: sessionId, working: true, source: 'terminal-output', timestamp: Date.now() });
+      }
+      _deps.recordSessionDiagnostic(sessionId, 'status-running', { source: 'terminal-output', reason: 'significant-output' });
+    }
+  }
+
+  // Only reset the idle timer when significant output arrives.
+  // Spinner noise should NOT reset — let the existing countdown continue.
+  if (hasWords) {
+    if (st.timer) { clearTimeout(st.timer); st.timer = null; }
+  }
+
+  // Set timer if none is running — after IDLE_NOTIFY_DELAY_MS of no significant output,
+  // check if we're at a prompt marker.
+  function armIdlePromptTimer(delayMs) {
+    st.timer = setTimeout(async () => {
+      st.timer = null;
+      // Waiting-input state must be based on the current terminal viewport, not
+      // on the rolling PTY text buffer. The rolling buffer can contain old
+      // approval widgets that were already handled, which caused stale
+      // "Do you want to proceed?" prompts to reappear as fresh user blockers.
+      // No viewport, no evidence: record nothing and say so (the rolling PTY buffer is historical, never judged as the screen).
+      const viewportRead = await _deps._getHeadlessViewportRead(sessionId);
+      if (!viewportRead.ok) {
+        // D-5: one re-arm 1 s later (the trigger of a card that just painted must not be lost to one slow read); a second failure records.
+        if (!st.readRetried) { st.readRetried = true; armIdlePromptTimer(1000); return; }
+        st.readRetried = false;
+        _deps.recordSessionDiagnostic(sessionId, 'viewport-read-failed', { source: 'idle-settle', reason: viewportRead.reason || 'unknown' });
+        return;
+      }
+      st.readRetried = false;
+      const waitingSource = viewportRead.text;
+      // Background-agent evidence: VIEWPORT only (a raw chunk can carry replayed scrollback).
+      if (!_deps._suppressCtmUiRefreshActivity(session) && !_deps.restoreRuntime.restoreActivitySuppressed(session, Date.now())) {
+        _deps._markBackgroundAgentsEvidence(session, waitingSource, Date.now());
+      }
+      const clean = _deps.stripAnsi(waitingSource);
+      // Get last non-empty lines
+      const lines = clean.split('\n').filter(l => l.trim().length > 0);
+      const lastLines = lines.slice(-8).join('\n');
+
+      // Plan-card convergence (secondary detector + clear-when-gone). The shadow
+      // approver is the primary, output-driven detector; this output-quiet pass
+      // catches what it missed and, crucially, CLEARS the plan Needs-You/render
+      // state once the card leaves the viewport. Judged against the AUTHORITATIVE
+      // viewport (`clean`), and short-circuits the generic detection loop so it
+      // can't clobber the 'plan' wait reason with a generic 'input'/'finished'.
+      if (session && typeof session._planCardOnDetect === 'function') {
+        const card = _deps._selectionCardFpForSession(session, clean);
+        if (card.fp) {
+          // Render convergence for ANY card type (plan / AskUserQuestion / permission).
+          session._planCardOnDetect(card.fp, card.reason);
+          // Only the plan card's Needs-You is owned by convergence, so only it short-circuits
+          // the generic loop. A choice/approval card FALLS THROUGH so the canonical reconcile
+          // keeps owning its banner exactly as before (render-only generalization).
+          if (card.reason === 'plan') return;
+        } else if (session._planCardPending) {
+          session._clearPlanDecisionPending('card-gone');
+        }
+      }
+
+      const detections = _prioritizeIdlePromptDetections(_idlePromptDetections(session, lastLines, waitingSource));
+      // Active-generation clear for a stale non-blocking 'input' wait. The gate in
+      // _idlePromptDetections suppresses NEW 'input' detections while the agent is
+      // generating, but it cannot clear an 'input' _waitingForInput that an EARLIER
+      // output-quiet window already set. The word-output clear path (the hasWords
+      // branch above) is the only other clear, and a long status-only turn — a
+      // "Wrangling… esc to interrupt" spinner, or a backgrounded sub-agent painting
+      // "Waiting for N background agents…" — emits no words, so the stale flag sticks
+      // for the whole turn. Because _isServerWaitingForInput then feeds the phase
+      // projection a needs_you condition (strength 5) that outranks the running spine
+      // (strength 3), the session reads "Needs You" for minutes while it is plainly
+      // working. So once we POSITIVELY confirm generation, clear it here. This mirrors
+      // reconcileSessionWaitState's _clearWaitCard('actively-generating', …) for the
+      // choice/approval cards it owns. Only the non-blocking 'input' reason is cleared;
+      // real approval/choice/plan blockers (a live widget REPLACES the footer, so it is
+      // never "generating") are owned by reconcile and left untouched.
+      if (session && session._waitingForInput &&
+          String(session._waitingForInputReason || '') === 'input' &&
+          _deps._providerActivelyGenerating(session, waitingSource)) {
+        _deps._clearServerWaitingForInput(sessionId, session, st);
+        _deps.broadcastToAll({ type: 'session-resumed', id: sessionId });
+        _deps.recordSessionDiagnostic(sessionId, 'waiting-cleared-generating', { reason: 'input', source: 'idle-settle' });
+        return;
+      }
+      // Approval/choice cards have ONE owner: the canonical reconcile. Routing the
+      // output-quiet trigger through it (instead of the old edge-emit below) keeps
+      // the card idempotent and consistent with the warm tick + restart. The warm
+      // tick is the safety net for prompts this idle detector misses entirely.
+      if (detections.some((d) => d.reason === 'approval' || d.reason === 'choice')) {
+        await _deps.reconcileSessionWaitState(sessionId);
+        return;
+      }
+      for (const detection of detections) {
+        const { reason, source } = detection;
+        if (reason === 'input') {
+          const deferUntil = _runningEvidenceHoldUntil(sessionId, session, Date.now());
+          if (deferUntil > Date.now()) {
+            armIdlePromptTimer(Math.max(250, Math.min(_deps.IDLE_NOTIFY_DELAY_MS, deferUntil - Date.now() + 50)));
+            return;
+          }
+        }
+        // Approval prompts are first-class and may be handled by the
+        // auto-approver. Generic numbered choice menus are different: they
+        // need user input, but are not approvals and must not be suppressed
+        // just because the approval detector correctly returns "not approval".
+        if (reason === 'approval') {
+          const buf = _deps.autoApprovalBuffers.get(sessionId);
+          if (buf && !buf.reviewing && !buf._workerPending) {
+            buf._workerPending = true;
+            const result = await _deps._recheckHeadlessApprovalPrompt(sessionId);
+            if (!result.hasApproval) {
+              if (_deps.autoApprovalBuffers.get(sessionId) === buf) buf._workerPending = false;
+              _deps.recordSessionDiagnostic(sessionId, 'stale-waiting-input-suppressed', {
+                source: 'terminal-prompt',
+                reason,
+                rawDetected: !!result.rawDetected,
+                gateReason: result.gateReason || '',
+                snippet: lastLines.trim().split('\n').slice(-3).join('\n').slice(0, 200),
+              });
+              continue;
+            }
+            // The recheck result is also delivered to the shared approver
+            // handler, which owns waiting_input transitions for real approval
+            // widgets. Do not duplicate that state change here.
+            return;
+          }
+          continue;
+        }
+        if (reason === 'finished') {
+          // Positive "agent returned to its ready prompt" signal (e.g. Codex's
+          // idle composer with no Working… line). Close the active turn so the
+          // session settles to Idle rather than riding the long open-turn hold.
+          // This is NOT a user blocker — do not set _waitingForInput.
+          const busyNow = _deps._providerActivelyGenerating(session, waitingSource); // gated on the LEDGER (R-3/W-4/D-2): composerMayClose
+          if (_deps._composerMayClose(session, Date.now(), busyNow)) {
+            _deps._markServerSessionTurnClosed(session, Date.now(), source || 'ready-composer', { kind: _deps.STATUS_EVIDENCE.AGENT_READY_COMPOSER });
+            _deps._markTerminalLifecycleChanged(session, 'turn-finished');
+            _deps.recordSessionDiagnostic(sessionId, 'status-idle', {
+              source: source || 'ready-composer',
+              snippet: lastLines.trim().split('\n').slice(-3).join('\n').slice(0, 200),
+            });
+            _deps.broadcastToAll({ type: 'session.status', id: sessionId, working: false, source: 'terminal-idle', timestamp: Date.now() });
+            // The turn just settled to its idle prompt — force a clean final
+            // render (SIGWINCH repaint + authoritative snapshot to all clients)
+            // so the browser never sticks on a stale mid-repaint frame. Provider-
+            // agnostic: both Claude and Codex 'finished' detections route here.
+            if (typeof session._forceCleanFinalRenderOnIdle === 'function') {
+              session._forceCleanFinalRenderOnIdle(sessionId, source || 'ready-composer');
+            }
+          } else if (_deps._statusBindings.composerRetryMs(session, Date.now(), busyNow) > 0) {
+            armIdlePromptTimer(_deps._statusBindings.composerRetryMs(session, Date.now(), busyNow)); // N-2: only the W-4 age rule said no
+          }
+          continue;
+        }
+        if (!st.notified) {
+          st.notified = true;
+          const waitingAt = Date.now();
+          const providerId = session?._providerId || _deps._providerIdFromCmd(session?.cmd || '');
+          // Compute prompt authority before mutating liveness. An unconfirmed
+          // pattern wait is visible to the user, but cannot erase the open-turn
+          // and busy evidence that would disprove it on the next heartbeat.
+          const liveConfirmed = source === 'terminal-choice'
+            || _deps.isSessionAtLivePrompt(providerId, waitingSource).live;
+          const unconfirmedPattern = _unconfirmedPatternWait(source, liveConfirmed);
+          st.reason = reason;
+          st.notifiedAt = waitingAt;
+          if (session) {
+            // D-14: an idle composer of a lease-only provider is no wait: the ledger reads it as a ready composer below.
+            if (!(reason === 'input' && _deps._statusBindings.inputWaitIsIdle(session))) {
+              session._waitingForInput = true;
+              session._waitingForInputLiveConfirmed = liveConfirmed;
+              session._waitingForInputReason = reason;
+              session._waitingForInputAt = waitingAt;
+              session._lastNonResolvingWaitingInputAt = 0;
+              session._lastWaitingResolveInputAt = 0;
+            }
+            if (!unconfirmedPattern) {
+              session._lastBusyStatusAt = 0;
+              session._lastBusyStatusSource = reason ? `waiting:${reason}` : 'waiting';
+              _deps._markServerSessionTurnClosed(session, waitingAt, `waiting:${reason || 'input'}`);
+            } else {
+              _deps.recordSessionDiagnostic(sessionId, 'waiting-input-leak-veto', {
+                source,
+                reason,
+                preservedOpenTurn: session._activeTurnOpen === true,
+                preservedBusyEvidence: Number(session._lastBusyStatusAt || 0) > 0,
+              });
+            }
+            _deps._markTerminalLifecycleChanged(session, `waiting-for-input:${reason}`);
+          }
+          // Provider hooks are useful, but a visible prompt is stronger evidence
+          // than a stale "working" hook that never received its stop event.
+          if (hasAuthoritativeSource) {
+            _deps.broadcastToAll({ type: 'session.status', id: sessionId, working: false, source: 'terminal-prompt', timestamp: Date.now() });
+          }
+          const promptSnippet = lastLines.trim().split('\n').slice(-3).join('\n').slice(0, 200);
+          // Banner label = the actual command/prompt, NOT the session title and NOT
+          // the menu/box-drawing junk at the bottom of the widget. For approvals we
+          // reuse the auto-approver's own parser (escalationCommandParts) to surface
+          // the real command (e.g. the Bash command). Falls back to a junk-filtered
+          // prompt line, then the title, so the label is never empty or a bare divider.
+          // The fixed-size headless grid can clip a tall command box; pass the wider
+          // rolling PTY buffer (ANSI-stripped) so the label can recover the command.
+          const labelBuffer = _deps.stripAnsi(String(st.buf || '').slice(-8000));
+          const derivedPromptLabel = _deps._deriveApprovalBannerLabel(providerId, clean, lines, reason, labelBuffer) || '';
+          const promptLabel = derivedPromptLabel || session.title || session.label || '';
+          // Stable per-prompt fingerprint so a user-dismissed false banner stays
+          // dismissed until the on-screen prompt actually changes (client compares the
+          // incoming fingerprint against the one it dismissed).
+          const promptFingerprint = detection.fingerprint || ('snip:' + promptLabel);
+          // Only a positive, anchored widget confirms a LIVE prompt the Approve/Deny
+          // buttons may act on (they inject '1'/Esc keystrokes): a highlighted
+          // terminal-choice menu, or the provider state detector's authoritative
+          // isSessionAtLivePrompt. A bare global-pattern match over the whole rendered
+          // tail is not trustworthy enough to inject a keystroke, so the client shows
+          // it Review-only.
+          _deps.recordSessionDiagnostic(sessionId, 'status-waiting', {
+            source: source || 'terminal-prompt',
+            reason,
+            liveConfirmed,
+            snippet: promptSnippet,
+          });
+          if (session) session._waitingForInputMessage = derivedPromptLabel;
+          _deps.broadcastToAll({
+            type: 'waiting-for-input',
+            id: sessionId,
+            reason,
+            label: promptLabel,
+            snippet: promptSnippet,
+            fingerprint: promptFingerprint,
+            liveConfirmed,
+            timestamp: waitingAt,
+          });
+          _deps.dispatchMobileNotification(_deps.mobileNotifications.notifyWaitingInput({
+            sessionId,
+            source: 'server-waiting-for-input',
+            createdAt: waitingAt,
+            privatePreview: lastLines.trim().split('\n').slice(-1).join(' ').slice(0, 64),
+          }));
+        }
+        return;
+      }
+    }, Math.max(0, Number(delayMs) || 0));
+  }
+
+  if (!st.timer) armIdlePromptTimer(delayMs);
+}
+
+module.exports = {
+  configure,
+  _idlePromptDetections,
+  _unconfirmedPatternWait,
+  _prioritizeIdlePromptDetections,
+  _runningEvidenceHoldUntil,
+  checkIdleNotify,
+};

package/template/coding-task-manager/lib/instance-id-ownership-manifest.js

@@ -64,6 +64,14 @@ const INSTANCE_ID_COLUMN_MANIFEST = [
   },
 
   // --- provenance: historical, never restamped ---
+  {
+    table: 'conversation_item_clock', column: 'origin_instance_id', classification: 'provenance',
+    note: 'shared-memory WP-5 (migration v61): the machine that authored a conversation item — the replica feed addresses a change by (origin, seq), so it must never be restamped.',
+  },
+  {
+    table: 'conversation_vv', column: 'origin_instance_id', classification: 'provenance',
+    note: 'shared-memory WP-5 (migration v61): per-origin version vector key — one row per authoring machine; never restamped.',
+  },
   {
     table: 'ctm_sessions', column: 'origin_instance_id', classification: 'provenance',
     note: 'Historical: which instance a session was originally created on. Documented at db.js ~line 1234.',

package/template/coding-task-manager/lib/instance-manifest.js

@@ -108,9 +108,13 @@ function buildInstanceManifest(options = {}) {
   // name; favorite/hidden ride the manifest as booleans so every primary reads the same values.
   const machineSelf = options.machineSelf && typeof options.machineSelf === 'object' ? options.machineSelf : null;
   const selfDisplayName = _limitedString(machineSelf && machineSelf.displayName, '');
+  // The unset default is the box's hostname (mDNS `.local` dropped), never a relative label: a hub
+  // shows this name on every remote session's chip, and a literal "Local CTM" from each box made
+  // every pooled machine read as this one.
+  const hostLabel = hostname === 'unknown-host' ? 'Local CTM' : hostname.replace(/\.local$/i, '');
   const displayName = selfDisplayName || _limitedString(
     env.CTM_EXECUTION_HOST_DISPLAY_NAME || env.CTM_INSTANCE_DISPLAY_NAME,
-    executionHostKind === 'hosted' ? hostname : 'Local CTM'
+    executionHostKind === 'hosted' ? hostname : hostLabel
   );
   const deploymentMode = _deploymentMode(env, executionHostKind);
   const serviceManager = _serviceManager(env);

package/template/coding-task-manager/lib/instance-sync-status.js

@@ -52,6 +52,17 @@ function _phaseEnabledBySchema(hybridEnabled, hasOwnership, hasOutbox) {
   return hybridEnabled && hasOwnership && hasOutbox;
 }
 
+// The v2 memory round's last report, wherever the worker keeps it: the peers loop records it
+// under lastResult.machineProbe, the machines-only loop under machines (both are the
+// _sweepMachines result). null when no sweep has reached a machine yet.
+function _brainSyncFromWorker(worker) {
+  const probe = worker.lastResult && worker.lastResult.machineProbe;
+  if (probe && probe.brainSync && typeof probe.brainSync === 'object') return probe.brainSync;
+  const machines = worker.machines;
+  if (machines && machines.brainSync && typeof machines.brainSync === 'object') return machines.brainSync;
+  return null;
+}
+
 function buildInstanceSyncStatus(options = {}) {
   const env = options.env || process.env;
   const manifest = options.manifest || {};
@@ -134,14 +145,13 @@ function buildInstanceSyncStatus(options = {}) {
       // {peer, lastAttemptAt, lastOkAt, lastDeliveredSeq, lastError}.
       pull: Array.isArray(worker.lastResult && worker.lastResult.results) ? worker.lastResult.results : [],
       push: Array.isArray(worker.push) ? worker.push : [],
-      // WP-5 §6.6: the brain pair (memories/knowledge/entities/people) per peer —
-      // {peer, lastAttemptAt, lastOkAt, lastSeq, lastError, pull, push}; a failed brain
-      // leg appears here and never as a failed CTM leg.
-      // Follow-ups #16/#17: each brain record carries `backfill: {local, peer}` (per-table
-      // {after, done} history-backfill progress), and brainPrune is the last local outbox prune
-      // ({ok, throughSeq, pruned, more, error, lastAttemptAt} or null before the first one).
-      brain: Array.isArray(worker.brain) ? worker.brain : [],
-      brainPrune: worker.brainPrune && typeof worker.brainPrune === 'object' ? worker.brainPrune : null,
+      // WP-3 §6.6 + WP-6 (§11): the v2 memory round (lib/memory-sync.js runBrainMemberRound,
+      // driven by the machine-registry sweep) is the ONLY brain transport left — the v1
+      // outbox pair and its local prune were retired with migration 104. The round's report
+      // ({ok, members:[...]}) rides the sweep result: `lastResult.machineProbe.brainSync` in
+      // the peers loop, `machines.brainSync` in the machines-only loop. null before the first
+      // tick that reached a machine.
+      brainSync: _brainSyncFromWorker(worker),
     },
     // S-30 (WP-0, remote-machine-hub-sessions-2026-10-22.html): the machine registry's rollup —
     // how many boxes this hub knows and where they stand. The CALLER supplies it

package/template/coding-task-manager/lib/landing/agent-rule.txt

@@ -0,0 +1 @@
+To integrate finished work: commit on your branch, then run land submit and report its job id; never merge or fast-forward <target> yourself. Do not merge <target> into your branch to land it; merge only when land submit or the queue reports a conflict.