chainlesschain 0.162.177 → 0.162.178

package/src/lib/turn-binding.js

@@ -13,6 +13,7 @@
  *     -> toolCallIds[]            (tool_use_ids this turn issued)
  *     -> permissionDecisionIds[]  (approval decisions made this turn)
  *     -> childAgentIds[]          (sub-agents spawned this turn)
+ *     -> childBindings[]          (child trace/checkpoint/worktree lineage)
  *     -> worktreeId               (isolation worktree, if any)
  *     -> coverage: full | partial | none
  *
@@ -90,6 +91,7 @@ function emptyRecord(turnId, conversationOffset) {
     toolCallIds: [],
     permissionDecisionIds: [],
     childAgentIds: [],
+    childBindings: [],
     worktreeId: null,
     // side-effect flags → coverage (kept internal; surfaced via `coverage`)
     _flags: {
@@ -160,6 +162,39 @@ export class TurnBindingLog {
     return this;
   }
 
+  recordChildBinding(turnId, binding) {
+    if (!binding || typeof binding !== "object") return this;
+    const childAgentId =
+      binding.childAgentId == null ? null : String(binding.childAgentId);
+    if (!childAgentId) return this;
+    const normalized = {
+      childAgentId,
+      parentAgentId:
+        binding.parentAgentId == null ? null : String(binding.parentAgentId),
+      traceId: binding.traceId == null ? null : String(binding.traceId),
+      parentTraceId:
+        binding.parentTraceId == null ? null : String(binding.parentTraceId),
+      checkpointIds: Array.isArray(binding.checkpointIds)
+        ? [...new Set(binding.checkpointIds.map(String))]
+        : [],
+      toolUseIds: Array.isArray(binding.toolUseIds)
+        ? [...new Set(binding.toolUseIds.map(String))]
+        : [],
+      worktreeId:
+        binding.worktreeId == null ? null : String(binding.worktreeId),
+      worktreePath:
+        binding.worktreePath == null ? null : String(binding.worktreePath),
+    };
+    const rec = this._rec(turnId);
+    const index = rec.childBindings.findIndex(
+      (item) => item.childAgentId === childAgentId,
+    );
+    if (index === -1) rec.childBindings.push(normalized);
+    else rec.childBindings[index] = normalized;
+    pushUnique(rec.childAgentIds, childAgentId);
+    return this;
+  }
+
   /** Bind (or re-bind to the earliest) file checkpoint for this turn. */
   bindCheckpoint(turnId, checkpointId) {
     const rec = this._rec(turnId);
@@ -231,6 +266,11 @@ export class TurnBindingLog {
       toolCallIds: [...rec.toolCallIds],
       permissionDecisionIds: [...rec.permissionDecisionIds],
       childAgentIds: [...rec.childAgentIds],
+      childBindings: rec.childBindings.map((binding) => ({
+        ...binding,
+        checkpointIds: [...binding.checkpointIds],
+        toolUseIds: [...binding.toolUseIds],
+      })),
       worktreeId: rec.worktreeId,
       coverage: computeCoverage(rec._flags),
     };
@@ -260,6 +300,22 @@ export class TurnBindingLog {
         childAgentIds: Array.isArray(r.childAgentIds)
           ? [...r.childAgentIds]
           : [],
+        childBindings: Array.isArray(r.childBindings)
+          ? r.childBindings.map((binding) => ({
+              childAgentId: String(binding.childAgentId),
+              parentAgentId: binding.parentAgentId ?? null,
+              traceId: binding.traceId ?? null,
+              parentTraceId: binding.parentTraceId ?? null,
+              checkpointIds: Array.isArray(binding.checkpointIds)
+                ? binding.checkpointIds.map(String)
+                : [],
+              toolUseIds: Array.isArray(binding.toolUseIds)
+                ? binding.toolUseIds.map(String)
+                : [],
+              worktreeId: binding.worktreeId ?? null,
+              worktreePath: binding.worktreePath ?? null,
+            }))
+          : [],
         worktreeId: r.worktreeId ?? null,
         _flags: { ...emptyRecord(id)._flags, ...(r._flags || {}) },
       });
@@ -428,16 +484,12 @@ export function buildTurnBindingFromMarks(turns = [], marks = []) {
 /**
  * Stateful feeder turning raw agent-loop events into TurnBindingLog records —
  * the SHARED producer core for every runner (headless and the interactive
- * REPL), so id synthesis and the event→table mapping can never drift between
- * them. Provider tool_use ids are not visible on the yielded event stream, so
- * tool-call ids are synthesized `<nonce>:c<seq>` and turn ids `<nonce>:t<seq>`
- * (mirrors the side-effect ledger's op-id scheme — stable within a run, unique
- * across resumes as long as `nonce` is per-run unique).
+ * REPL). Provider tool ids are consumed directly; ids are synthesized only for
+ * legacy/custom event sources that omit `tool_use_id`.
  *
- * Dirty-gating: `beginTurn` alone never marks the table dirty, so a tool-free
- * turn costs the caller zero persistence writes; only a recorded signal
- * (checkpoint / tool call / permission decision / child agent / a supersede
- * prune) does.
+ * Every begun turn marks the table dirty. Tool-free turns still need an
+ * explicit `full` coverage record; otherwise restore/history consumers cannot
+ * distinguish "nothing happened" from "the producer failed to record".
  *
  * @param {{log?: TurnBindingLog, nonce?: string}} [opts]
  */
@@ -458,8 +510,7 @@ export function createTurnBindingFeed({
      * contract `pickPersistedTurn` relies on). `supersede: true` first prunes
      * records at/after that offset (live-REPL rewind/clear/compaction rule);
      * append-only runners leave it off. `worktreeId` stamps the run's isolation
-     * worktree onto the record (does NOT mark dirty by itself — a tool-free
-     * turn in a worktree still writes nothing).
+     * worktree onto the record.
      */
     beginTurn(
       conversationOffset,
@@ -471,6 +522,7 @@ export function createTurnBindingFeed({
       currentTurnId = `${nonce}:t${turnSeq++}`;
       log.startTurn(currentTurnId, { conversationOffset });
       if (worktreeId != null) log.setWorktree(currentTurnId, worktreeId);
+      dirty = true;
       return currentTurnId;
     },
     currentTurnId: () => currentTurnId,
@@ -486,27 +538,41 @@ export function createTurnBindingFeed({
           }
           break;
         case "tool-executing": {
-          const callId = `${nonce}:c${callSeq++}`;
+          const callId =
+            event.tool_use_id == null
+              ? `${nonce}:c${callSeq++}`
+              : String(event.tool_use_id);
           currentCallId = callId;
           log.recordToolCall(turnId, callId, { name: event.tool });
           dirty = true;
           break;
         }
         case "tool-result": {
-          // A gated tool surfaces its permission decision on `result.policy`;
-          // re-derive a stable decision id feeder-side (core's own id hangs
-          // off the provider call id, which the event stream does not expose).
+          const callId =
+            event.tool_use_id == null
+              ? currentCallId
+              : String(event.tool_use_id);
+          // New core events expose the exact decision id. Legacy/custom event
+          // sources retain the deterministic compatibility derivation.
           const policy = event.result?.policy;
           if (policy && (policy.via || policy.decision)) {
             log.recordPermissionDecision(
               turnId,
-              `${currentCallId || "call"}:perm:${policy.via || policy.decision}`,
+              event.permission_decision_id ||
+                `${callId || "call"}:perm:${policy.via || policy.decision}`,
             );
             dirty = true;
           }
+          if (event.result?.userEdited === true) {
+            log.markUserEdit(turnId);
+            dirty = true;
+          }
           // Foreground spawn_sub_agent reports its child id on the result.
           if (event.result?.subAgentId) {
             log.recordChildAgent(turnId, event.result.subAgentId);
+            if (event.result.childBinding) {
+              log.recordChildBinding(turnId, event.result.childBinding);
+            }
             dirty = true;
           }
           currentCallId = null;
@@ -515,6 +581,9 @@ export function createTurnBindingFeed({
         case "background-sub-agent-result":
           if (event.subAgentId) {
             log.recordChildAgent(turnId, event.subAgentId);
+            if (event.childBinding) {
+              log.recordChildBinding(turnId, event.childBinding);
+            }
             dirty = true;
           }
           break;

package/src/repl/agent-repl.js

@@ -1123,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");
@@ -3650,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.
@@ -3671,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
@@ -5267,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 };
@@ -5283,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;
       }
     }
 
@@ -5722,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 (

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),
   };