chainlesschain 0.162.176 → 0.162.178

package/src/lib/status-line.js

@@ -0,0 +1,33 @@
+import statusLine from "./status-line.cjs";
+import executionBroker from "./process-execution-broker/index.js";
+
+const brokerRunner = executionBroker.spawnSync.bind(executionBroker);
+
+export function renderStatusLine(config, context, options = {}) {
+  return statusLine.renderStatusLine(config, context, {
+    ...options,
+    runProcess:
+      options.runProcess || statusLine._deps.runProcess || brokerRunner,
+  });
+}
+
+export function getStatusLine(options = {}) {
+  return statusLine.getStatusLine({
+    ...options,
+    runProcess:
+      options.runProcess || statusLine._deps.runProcess || brokerRunner,
+  });
+}
+
+export const {
+  loadStatusLineConfig,
+  buildContext,
+  formatTokens,
+  shortenPath,
+  renderDefaultStatusLine,
+  isStatusLineDisabled,
+  terminalSize,
+  _deps,
+} = statusLine;
+
+export default { ...statusLine, renderStatusLine, getStatusLine };

package/src/lib/sub-agent-context.js

@@ -110,6 +110,11 @@ export class SubAgentContext {
     // symlinkDirectories } — only materialize the needed packages and reuse
     // approved dep dirs. null → full checkout (byte-identical default).
     this._worktreeOptions = options.worktreeOptions || null;
+    // Recovery lineage collected from the child agent-loop event stream.
+    // These are provider/runtime identifiers, not reconstructed log labels.
+    this._runId = null;
+    this._checkpointIds = [];
+    this._toolUseIds = [];
 
     // ── Isolated state ──────────────────────────────────────────────
     // Independent message history — never shared with parent
@@ -399,6 +404,22 @@ export class SubAgentContext {
       for await (const event of gen) {
         this._iterationCount++;
 
+        if (event.type === "run-started" && event.runId) {
+          this._runId = String(event.runId);
+        }
+        if (event.type === "checkpoint" && event.id) {
+          const checkpointId = String(event.id);
+          if (!this._checkpointIds.includes(checkpointId)) {
+            this._checkpointIds.push(checkpointId);
+          }
+        }
+        if (event.type === "tool-executing" && event.tool_use_id) {
+          const toolUseId = String(event.tool_use_id);
+          if (!this._toolUseIds.includes(toolUseId)) {
+            this._toolUseIds.push(toolUseId);
+          }
+        }
+
         if (event.type === "token-usage" && this._onUsage) {
           // Forward real usage to the spawner. A nested child's event already
           // carries its own attribution frame — preserve it (deepest wins).
@@ -604,6 +625,26 @@ export class SubAgentContext {
     }
   }
 
+  /**
+   * Serializable child→parent recovery lineage. Worktree paths are included
+   * for local restore UX; executable merge callbacks and tool payloads are not.
+   */
+  recoveryBinding(result = this.result) {
+    const worktree = result?.worktree || null;
+    return {
+      childAgentId: this.id,
+      parentAgentId: this.parentId || null,
+      traceId: this._runId,
+      parentTraceId: this._hookParentTraceId || null,
+      checkpointIds: [...this._checkpointIds],
+      toolUseIds: [...this._toolUseIds],
+      worktreeId:
+        worktree?.branch || this._worktreeBranch || null,
+      worktreePath:
+        worktree?.path || this._worktreePath || null,
+    };
+  }
+
   /**
    * True when this sub-agent has been asked to stop — either via an external
    * abort signal or via this context's own `abort()` (precise single-agent
@@ -647,6 +688,7 @@ export class SubAgentContext {
       iterationCount: this._iterationCount,
       createdAt: this.createdAt,
       completedAt: this.completedAt,
+      recoveryBinding: this.recoveryBinding(),
       worktree: this._worktreePath
         ? { path: this._worktreePath, branch: this._worktreeBranch }
         : null,

package/src/lib/turn-binding-store.js

@@ -35,46 +35,85 @@ export const _deps = {
   readEvents: storeReadEvents,
 };
 
+export class TurnBindingPersistenceError extends Error {
+  constructor(operation, sessionId, cause) {
+    const detail = cause?.message || String(cause || "unknown persistence error");
+    super(`Turn binding ${operation} failed for ${sessionId}: ${detail}`, {
+      cause,
+    });
+    this.name = "TurnBindingPersistenceError";
+    this.code =
+      operation === "read"
+        ? "TURN_BINDING_READ_FAILED"
+        : "TURN_BINDING_PERSIST_FAILED";
+    this.operation = operation;
+    this.sessionId = sessionId;
+  }
+}
+
+function persistenceFailure(operation, sessionId, cause, failIfUnavailable) {
+  if (!failIfUnavailable) return false;
+  throw new TurnBindingPersistenceError(operation, sessionId, cause);
+}
+
 /**
  * Append the current binding table as a new chained event. Each call writes the
  * FULL table (append-only snapshot), so the newest event is authoritative — a
  * later `loadTurnBindingLog` never has to merge partial deltas across a chain
  * that a compaction could have truncated.
  *
- * Best-effort: a persistence failure must not crash the turn it is recording, so
- * the caller gets `false` instead of a throw.
+ * Turn/checkpoint binding is Critical state. Persistence fails closed by
+ * default; diagnostic callers may explicitly opt into advisory behavior.
  *
  * @param {string} sessionId
  * @param {TurnBindingLog|object} log  a TurnBindingLog or its toJSON() shape
+ * @param {{failIfUnavailable?:boolean}} [opts]
  * @returns {boolean} true when the snapshot was written
  */
-export function persistTurnBinding(sessionId, log) {
-  if (!sessionId || !log) return false;
-  const snapshot = log instanceof TurnBindingLog ? log.toJSON() : log;
-  if (!snapshot || !Array.isArray(snapshot.turns)) return false;
+export function persistTurnBinding(sessionId, log, opts = {}) {
+  const failIfUnavailable = opts.failIfUnavailable !== false;
+  if (!sessionId || !log) {
+    return persistenceFailure(
+      "write",
+      sessionId || "<missing-session>",
+      new TypeError("sessionId and binding log are required"),
+      failIfUnavailable,
+    );
+  }
   try {
+    const snapshot = log instanceof TurnBindingLog ? log.toJSON() : log;
+    if (!snapshot || !Array.isArray(snapshot.turns)) {
+      throw new TypeError("binding snapshot must contain a turns array");
+    }
     _deps.appendEvent(sessionId, TURN_BINDING_EVENT, snapshot);
     return true;
-  } catch {
-    // Persistence is advisory — never let it break the agent turn.
-    return false;
+  } catch (error) {
+    return persistenceFailure("write", sessionId, error, failIfUnavailable);
   }
 }
 
 /**
  * Rebuild the TurnBindingLog from the LATEST persisted snapshot in a session
- * transcript. Returns an empty log when the session has no binding event (or on
- * any read error) so callers can treat "never persisted" and "unreadable" alike.
+ * transcript. Returns an empty log when the session has no binding event.
+ * Read/corruption errors fail closed unless explicitly marked advisory.
  *
  * @param {string} sessionId
+ * @param {{failIfUnavailable?:boolean}} [opts]
  * @returns {TurnBindingLog}
  */
-export function loadTurnBindingLog(sessionId) {
+export function loadTurnBindingLog(sessionId, opts = {}) {
+  const failIfUnavailable = opts.failIfUnavailable !== false;
   let events = [];
   try {
     events = _deps.readEvents(sessionId) || [];
-  } catch {
-    return new TurnBindingLog();
+  } catch (error) {
+    const fallback = persistenceFailure(
+      "read",
+      sessionId || "<missing-session>",
+      error,
+      failIfUnavailable,
+    );
+    if (fallback === false) return new TurnBindingLog();
   }
   // Newest snapshot wins — scan backwards for the first well-formed one.
   for (let i = events.length - 1; i >= 0; i--) {
@@ -85,7 +124,17 @@ export function loadTurnBindingLog(sessionId) {
       e.data &&
       Array.isArray(e.data.turns)
     ) {
-      return TurnBindingLog.fromJSON(e.data);
+      try {
+        return TurnBindingLog.fromJSON(e.data);
+      } catch (error) {
+        const fallback = persistenceFailure(
+          "read",
+          sessionId || "<missing-session>",
+          error,
+          failIfUnavailable,
+        );
+        if (fallback === false) return new TurnBindingLog();
+      }
     }
   }
   return new TurnBindingLog();

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;