chainlesschain 0.162.176 → 0.162.178

package/src/repl/agent-repl.js

@@ -183,12 +183,12 @@ function persistRecentDenial(record, options = {}) {
  * user's attention (e.g. waiting on a permission/risk confirmation). A hook can
  * ring a bell / send a desktop notification. Best-effort, never blocks.
  */
-async function _fireNotification(message, type = "info") {
+async function _fireNotification(message, type = "info", session = null) {
   // Fire settings.json observe hooks first (best-effort)
   if (_settingsHooks) {
     try {
       const { runObserveHooks } =
-        await import("../lib/settings-hook-events.cjs");
+        await import("../lib/settings-hook-events.js");
       runObserveHooks(
         _settingsHooks,
         "Notification",
@@ -196,7 +196,7 @@ async function _fireNotification(message, type = "info") {
           message,
           type,
           cwd: process.cwd(),
-          session_id: _session?.sessionId || null,
+          session_id: session?.sessionId || null,
         },
         { cwd: process.cwd() },
       );
@@ -205,10 +205,10 @@ async function _fireNotification(message, type = "info") {
     }
   }
   // Fire database-registered Notification hooks (interceptable/suppressible)
-  if (_session) {
+  if (session) {
     try {
       const result = await fireNotification(_hookDb, message, {
-        session: _session,
+        session,
         type,
       });
       if (result?.directive?.suppress) {
@@ -750,6 +750,8 @@ export async function startAgentRepl(options = {}) {
         }
         await _fireNotification(
           `Permission needed: ${riskLevel || "medium"}-risk ${tool || "run_shell"}${args?.command ? " — " + args.command : ""}`,
+          "info",
+          _sessionHandle,
         );
         const local = askGateApprovalLocally({ tool, args, riskLevel });
         if (!_remoteApproval?.bridge) return local.promise;
@@ -840,6 +842,8 @@ export async function startAgentRepl(options = {}) {
       }
       await _fireNotification(
         `Permission needed: ${tool}${rule ? " (" + rule + ")" : ""}`,
+        "info",
+        _sessionHandle,
       );
       const local = askPermissionLocally({ tool, args, rule, reason });
       if (!_remoteApproval?.bridge) return local.promise;
@@ -1119,8 +1123,10 @@ export async function startAgentRepl(options = {}) {
   // P1 explicit turn→checkpoint binding — the REPL as PRODUCER (mirrors the
   // headless runner's feed via the shared feeder core): one record per
   // interactive turn, persisted dirty-gated at each settle. Lazily created on
-  // the first prompt turn of a persistable (JSONL) session; advisory only.
+  // the first prompt turn of a persistable (JSONL) session. This is Critical
+  // recovery state: a failure blocks subsequent model/tool turns.
   let _turnBindingProducer = null;
+  let _turnBindingCriticalError = null;
   // Apply --output-style or the settings.json `outputStyle` default at startup.
   try {
     const { resolveOutputStyle } = await import("../lib/output-styles.js");
@@ -1142,7 +1148,7 @@ export async function startAgentRepl(options = {}) {
   if (_settingsHooks && _loadedReplInstructions) {
     try {
       const { runInstructionsLoadedHooks } =
-        await import("../lib/settings-hook-events.cjs");
+        await import("../lib/settings-hook-events.js");
       const ctx = runInstructionsLoadedHooks(_settingsHooks, {
         files: _loadedReplInstructions.files,
         cwd: process.cwd(),
@@ -1158,7 +1164,7 @@ export async function startAgentRepl(options = {}) {
   if (_settingsHooks) {
     try {
       const { runSessionStartHooks } =
-        await import("../lib/settings-hook-events.cjs");
+        await import("../lib/settings-hook-events.js");
       const ctx = runSessionStartHooks(_settingsHooks, {
         source: "startup",
         cwd: process.cwd(),
@@ -1466,7 +1472,7 @@ export async function startAgentRepl(options = {}) {
     if (_settingsHooks && messages.some((m) => m.role !== "system")) {
       try {
         const { runObserveHooks } =
-          await import("../lib/settings-hook-events.cjs");
+          await import("../lib/settings-hook-events.js");
         runObserveHooks(
           _settingsHooks,
           "SessionResume",
@@ -1764,31 +1770,34 @@ export async function startAgentRepl(options = {}) {
 
   // MCP elicitation in the interactive REPL uses the same readline surface as
   // approvals, while MCPClient retains the protocol-level response shape.
-  const mcpElicitationClients = [
-    _adhocMcp?.mcpClient,
-    _bundleMcpClient,
-  ].filter((client) => client?.setElicitationHandler);
+  const mcpElicitationClients = [_adhocMcp?.mcpClient, _bundleMcpClient].filter(
+    (client) => client?.setElicitationHandler,
+  );
   for (const client of mcpElicitationClients) {
     client.setElicitationHandler(
       (request) =>
         new Promise((resolve) => {
-          const label = request.message || "MCP server requests additional input";
-          rl.question(chalk.yellow(`\n  MCP [${request.server}] ${label}\n  > `), (answer) => {
-            const trimmed = String(answer || "").trim();
-            if (!trimmed) {
-              resolve({ action: "cancel" });
-            } else {
-              let content = { value: trimmed };
-              try {
-                const parsed = JSON.parse(trimmed);
-                if (parsed && typeof parsed === "object") content = parsed;
-              } catch {
-                // Plain text remains a valid single-field elicitation answer.
+          const label =
+            request.message || "MCP server requests additional input";
+          rl.question(
+            chalk.yellow(`\n  MCP [${request.server}] ${label}\n  > `),
+            (answer) => {
+              const trimmed = String(answer || "").trim();
+              if (!trimmed) {
+                resolve({ action: "cancel" });
+              } else {
+                let content = { value: trimmed };
+                try {
+                  const parsed = JSON.parse(trimmed);
+                  if (parsed && typeof parsed === "object") content = parsed;
+                } catch {
+                  // Plain text remains a valid single-field elicitation answer.
+                }
+                resolve({ action: "accept", content });
               }
-              resolve({ action: "accept", content });
-            }
-            rl.prompt();
-          });
+              rl.prompt();
+            },
+          );
         }),
       { timeoutMs: options.mcpElicitationTimeoutMs },
     );
@@ -1896,7 +1905,7 @@ export async function startAgentRepl(options = {}) {
         // turn — the session stays open, the current work is suspended. The
         // keypress handler can't await, so fire observe-only fire-and-forget.
         if (_settingsHooks) {
-          import("../lib/settings-hook-events.cjs")
+          import("../lib/settings-hook-events.js")
             .then(({ runObserveHooks }) =>
               runObserveHooks(
                 _settingsHooks,
@@ -2058,7 +2067,7 @@ export async function startAgentRepl(options = {}) {
   const _costStore = newCostStore(); // running token spend for `/cost`
   let _renderStatus = null;
   try {
-    const slm = await import("../lib/status-line.cjs");
+    const slm = await import("../lib/status-line.js");
     const _sl = slm.default || slm;
     const _slCfg = _sl.loadStatusLineConfig({ cwd: process.cwd() });
     _customStatus = !!_slCfg;
@@ -3153,12 +3162,12 @@ export async function startAgentRepl(options = {}) {
           if (_settingsHooks && oldCwd !== newCwd) {
             try {
               const { runCwdChangedHooks, dispatchAsyncHooks } =
-                await import("../lib/settings-hook-events.cjs");
+                await import("../lib/settings-hook-events.js");
               const payload = { oldCwd, newCwd, sessionId };
               runCwdChangedHooks(_settingsHooks, payload);
               if (!_asyncHookSupervisor) {
                 const { AsyncHookSupervisor } =
-                  await import("../lib/async-hook-supervisor.cjs");
+                  await import("../lib/async-hook-supervisor.js");
                 _asyncHookSupervisor = new AsyncHookSupervisor({
                   persistStats: true,
                 });
@@ -3643,6 +3652,11 @@ export async function startAgentRepl(options = {}) {
             _sanitizeRolesNextTurn =
               messages[messages.length - 1]?.role === "user";
             sessionId = resumeId;
+            // The producer owns one immutable session id. Recreate it lazily
+            // on the next turn so bindings from the resumed conversation can
+            // never be appended to the previously active session.
+            _turnBindingProducer = null;
+            _turnBindingCriticalError = null;
             // The prior session's checkpoint marks (turn-index → checkpoint id)
             // no longer map to this swapped-in history; keeping them would make
             // a later /rewind restore files from the WRONG session's snapshot.
@@ -3664,6 +3678,8 @@ export async function startAgentRepl(options = {}) {
               _sanitizeRolesNextTurn =
                 messages[messages.length - 1]?.role === "user";
               sessionId = existing.id;
+              _turnBindingProducer = null;
+              _turnBindingCriticalError = null;
               // Drop the prior session's checkpoint marks (see JSONL branch).
               _checkpointMarks.length = 0;
               _clearedConversation = null; // stash belongs to the swapped-out session
@@ -3739,7 +3755,7 @@ export async function startAgentRepl(options = {}) {
         if (_settingsHooks) {
           try {
             const { runObserveHooks, dispatchAsyncHooks } =
-              await import("../lib/settings-hook-events.cjs");
+              await import("../lib/settings-hook-events.js");
             const payload = {
               session_id: sessionId || null,
               source: "reload-plugins",
@@ -3747,7 +3763,7 @@ export async function startAgentRepl(options = {}) {
             runObserveHooks(_settingsHooks, "ConfigChange", payload, { cwd });
             if (!_asyncHookSupervisor) {
               const { AsyncHookSupervisor } =
-                await import("../lib/async-hook-supervisor.cjs");
+                await import("../lib/async-hook-supervisor.js");
               _asyncHookSupervisor = new AsyncHookSupervisor({
                 persistStats: true,
               });
@@ -5099,7 +5115,7 @@ export async function startAgentRepl(options = {}) {
     if (_settingsHooks) {
       try {
         const { runUserPromptSubmitHooks } =
-          await import("../lib/settings-hook-events.cjs");
+          await import("../lib/settings-hook-events.js");
         const ups = runUserPromptSubmitHooks(_settingsHooks, {
           prompt: userContent,
           cwd: process.cwd(),
@@ -5122,10 +5138,10 @@ export async function startAgentRepl(options = {}) {
         // turn without blocking it; its result/rewake surfaces on a later turn
         // via the async-hook drain below. Lazily create the supervisor.
         const { dispatchAsyncHooks } =
-          await import("../lib/settings-hook-events.cjs");
+          await import("../lib/settings-hook-events.js");
         if (!_asyncHookSupervisor) {
           const { AsyncHookSupervisor } =
-            await import("../lib/async-hook-supervisor.cjs");
+            await import("../lib/async-hook-supervisor.js");
           _asyncHookSupervisor = new AsyncHookSupervisor({
             persistStats: true,
           });
@@ -5260,6 +5276,15 @@ export async function startAgentRepl(options = {}) {
       }
     }
 
+    if (_turnBindingCriticalError) {
+      logger.error(
+        `[recovery] critical turn-binding state is unavailable: ${_turnBindingCriticalError.message}. ` +
+          "Resume or start a healthy session before running another model/tool turn.",
+      );
+      prompt();
+      return;
+    }
+
     // Add user message (keep the object ref so a /btw aside can be injected for
     // this turn's model call and then stripped before persistence).
     const _userMsg = { role: "user", content: _userMessageContent };
@@ -5276,11 +5301,26 @@ export async function startAgentRepl(options = {}) {
         if (!_turnBindingProducer) {
           const { createReplTurnBindingProducer } =
             await import("./repl-turn-binding.js");
-          _turnBindingProducer = createReplTurnBindingProducer({ sessionId });
+          _turnBindingProducer = createReplTurnBindingProducer({
+            sessionId,
+            onError: (error, phase) => {
+              _turnBindingCriticalError = error;
+              logger.warn(
+                `[recovery] turn binding ${phase} failed for ${sessionId}: ${error.message}`,
+              );
+            },
+          });
         }
         _turnBindingProducer?.beginTurn(messages.length);
-      } catch {
-        /* advisory — never disturb the turn */
+      } catch (error) {
+        _turnBindingCriticalError =
+          error instanceof Error ? error : new Error(String(error));
+        if (messages[messages.length - 1] === _userMsg) messages.pop();
+        logger.error(
+          `[recovery] refusing the turn because binding state is unavailable: ${_turnBindingCriticalError.message}`,
+        );
+        prompt();
+        return;
       }
     }
 
@@ -5433,7 +5473,7 @@ export async function startAgentRepl(options = {}) {
       // fire-and-forget; their results/rewakes drain into the next turn above.
       if (_settingsHooks && !_asyncHookSupervisor) {
         const { AsyncHookSupervisor } =
-          await import("../lib/async-hook-supervisor.cjs");
+          await import("../lib/async-hook-supervisor.js");
         _asyncHookSupervisor = new AsyncHookSupervisor({ persistStats: true });
       }
       const {
@@ -5579,7 +5619,6 @@ export async function startAgentRepl(options = {}) {
         try {
           const rg = await import("../lib/repl-goal.js");
           const fsMod = await import("node:fs");
-          const cpMod = await import("node:child_process");
           const judge = async (cond, { finalText }) => {
             const { chatWithTools } = await import("../runtime/agent-core.js");
             const { firstBalancedJson } =
@@ -5621,7 +5660,6 @@ export async function startAgentRepl(options = {}) {
             response || "",
             {
               cwd: process.cwd(),
-              spawnSync: cpMod.spawnSync,
               existsSync: fsMod.existsSync,
               judge,
             },
@@ -5717,8 +5755,9 @@ export async function startAgentRepl(options = {}) {
           // Non-critical
         }
       }
-      // Persist the explicit turn-binding table for this settled turn
-      // (dirty-gated: a tool-free Q&A turn writes nothing; never throws).
+      // Persist the explicit turn-binding table for this settled turn,
+      // including tool-free turns. A failure is Critical: the producer throws,
+      // this turn reports an error, and the guard above blocks later turns.
       _turnBindingProducer?.persistIfDirty();
       // Auto-compact when context grows too large
       if (
@@ -5772,7 +5811,7 @@ export async function startAgentRepl(options = {}) {
       if (_settingsHooks) {
         try {
           const { runObserveHooks, dispatchAsyncHooks } =
-            await import("../lib/settings-hook-events.cjs");
+            await import("../lib/settings-hook-events.js");
           runObserveHooks(
             _settingsHooks,
             "Stop",
@@ -5781,7 +5820,7 @@ export async function startAgentRepl(options = {}) {
           );
           if (!_asyncHookSupervisor) {
             const { AsyncHookSupervisor } =
-              await import("../lib/async-hook-supervisor.cjs");
+              await import("../lib/async-hook-supervisor.js");
             _asyncHookSupervisor = new AsyncHookSupervisor({
               persistStats: true,
             });
@@ -5879,7 +5918,7 @@ export async function startAgentRepl(options = {}) {
     if (_settingsHooks) {
       try {
         const { runObserveHooks } =
-          await import("../lib/settings-hook-events.cjs");
+          await import("../lib/settings-hook-events.js");
         runObserveHooks(
           _settingsHooks,
           "SessionEnd",

package/src/repl/remote-approval.js

@@ -8,10 +8,9 @@
  *     publishes permission.resolved so the phone/web UI clears it)
  *   - remote answer first → cancel the local readline prompt and print
  *     the outcome
- *   - remote leg times out or the bridge closes mid-ask → NOT a decision:
- *     keep waiting on the terminal. A silent phone must never auto-deny a
- *     user sitting at the keyboard — the fail-closed timeout is headless
- *     semantics only.
+ *   - remote leg times out or the bridge closes mid-ask → NOT a remote human
+ *     decision, so keep waiting on the terminal. A later local answer still
+ *     needs the bridge's durable CAS; an expired/closed card cannot be revived.
  *
  * Pure over an injected bridge + local prompt handle ({promise, cancel}),
  * so the race is unit-testable without a WS server or readline.
@@ -46,8 +45,9 @@ export function describeAskContext({
   };
 }
 
-// Remote outcomes that are NOT a decision for an interactive session: the
-// devices went silent (timeout) or the bridge was torn down mid-ask (closed).
+// These outcomes are not a remote human decision. The terminal may still
+// answer, but its result is accepted only if resolveLocally can durably settle
+// the same live card.
 const NON_DECISIVE_REMOTE = new Set(["timeout", "closed"]);
 
 /**
@@ -90,14 +90,14 @@ export async function raceLocalAndRemote({
     winner = await localLeg;
   }
   if (winner.src === "local") {
-    if (requestId) {
-      try {
-        bridge.resolveLocally(requestId, winner.approved);
-      } catch {
-        // clearing the device card is best-effort
-      }
+    if (!requestId) return false;
+    try {
+      const persisted = bridge.resolveLocally(requestId, winner.approved);
+      return persisted === true && winner.approved === true;
+    } catch {
+      // A local "yes" without a durable CAS is not an approval.
+      return false;
     }
-    return winner.approved;
   }
   try {
     local.cancel?.();

package/src/repl/repl-turn-binding.js

@@ -14,10 +14,9 @@
  *      anchored at/after its own offset — under `pickPersistedTurn`'s
  *      exact-offset matching a stale record from the discarded timeline would
  *      otherwise shadow the new turn and could offer the wrong checkpoint.
- *   3. Per-settle persistence: dirty-gated `persistTurnBinding` after each turn
- *      (a tool-free Q&A turn writes nothing), best-effort — the producer is
- *      advisory and must NEVER disturb the turn itself, so every method
- *      swallows its own failures.
+ *   3. Per-settle persistence: `persistTurnBinding` after each turn, including
+ *      tool-free turns. Failures are reported through `onError` and fail closed
+ *      by default; tests/diagnostics may explicitly request advisory mode.
  *
  * I/O goes through `_deps` so tests drive the producer hermetically.
  */
@@ -37,15 +36,35 @@ export const _deps = {
 };
 
 /**
- * @param {{sessionId?: string, nonce?: string}} [opts]
+ * @param {{sessionId?: string, nonce?: string, failClosed?:boolean,
+ *          onError?:(error:Error, phase:string)=>void}} [opts]
  * @returns {object|null}  null when the session cannot persist (no sessionId)
  */
-export function createReplTurnBindingProducer({ sessionId, nonce } = {}) {
+export function createReplTurnBindingProducer({
+  sessionId,
+  nonce,
+  onError,
+  failClosed = true,
+} = {}) {
   if (!sessionId) return null;
   // Per-process nonce (mirrors the headless runner's per-run nonce): restored
   // turn ids keep their original nonce, new ids can't collide across resumes.
   const runNonce = nonce || String(_deps.now());
   let feed = null;
+  let lastError = null;
+  const report = (error, phase) => {
+    lastError = error instanceof Error ? error : new Error(String(error));
+    try {
+      onError?.(lastError, phase);
+    } catch {
+      // Reporting must not replace the underlying recovery warning.
+    }
+  };
+  const rejectOr = (error, phase, fallback) => {
+    report(error, phase);
+    if (failClosed) throw lastError;
+    return fallback;
+  };
   return {
     /**
      * Anchor a new interactive turn. Call just AFTER the user message was
@@ -61,8 +80,8 @@ export function createReplTurnBindingProducer({ sessionId, nonce } = {}) {
           });
         }
         return feed.beginTurn(conversationOffset, { supersede: true });
-      } catch {
-        return null; // advisory — never disturb the turn
+      } catch (error) {
+        return rejectOr(error, "load", null);
       }
     },
     /** Fold one agent-loop event into the current turn (fed by agentLoop). */
@@ -70,21 +89,32 @@ export function createReplTurnBindingProducer({ sessionId, nonce } = {}) {
       if (!feed) return false;
       try {
         return feed.handleEvent(event);
-      } catch {
-        return false;
+      } catch (error) {
+        return rejectOr(error, "event", false);
       }
     },
-    /** Persist the table after a settled turn (dirty-gated, best-effort). */
+    /** Persist the table after a settled turn (dirty-gated, fail-closed). */
     persistIfDirty() {
       if (!feed || !feed.isDirty()) return false;
+      let ok = false;
       try {
-        const ok = _deps.persistTurnBinding(sessionId, feed.log);
-        if (ok) feed.clearDirty();
-        return ok;
-      } catch {
-        return false;
+        ok = _deps.persistTurnBinding(sessionId, feed.log);
+      } catch (error) {
+        return rejectOr(error, "persist", false);
+      }
+      if (!ok) {
+        return rejectOr(
+          new Error("turn-binding snapshot was not persisted"),
+          "persist",
+          false,
+        );
       }
+      feed.clearDirty();
+      lastError = null;
+      return true;
     },
+    lastError: () => lastError,
+    sessionId: () => sessionId,
     /** The live table (for tests / future in-process consumers). */
     log: () => (feed ? feed.log : null),
   };