chainlesschain 0.162.170 → 0.162.172

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

@@ -0,0 +1,91 @@
+/**
+ * REPL turn-binding PRODUCER — closes the incremental-gap 仍欠 item "REPL 自身
+ * 作为显式表生产者（交互 turn 实时喂+持久化，镜像 headless 接线；现 REPL 只消费）".
+ *
+ * Wraps the SHARED feeder core ([[turn-binding.js]] `createTurnBindingFeed` —
+ * the exact mapping the headless runner uses, so the two producers can never
+ * drift) with the three REPL-specific concerns:
+ *
+ *   1. Rehydrate: the first turn loads the session's persisted table
+ *      (`loadTurnBindingLog`) so an interactive continuation of a headless (or
+ *      earlier REPL) run APPENDS to the existing table instead of clobbering it.
+ *   2. Timeline supersede: the live REPL can shrink its conversation
+ *      (`/rewind`, `/clear`, auto-compaction), so each new turn prunes records
+ *      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.
+ *
+ * I/O goes through `_deps` so tests drive the producer hermetically.
+ */
+
+import { createTurnBindingFeed } from "../lib/turn-binding.js";
+import {
+  loadTurnBindingLog,
+  persistTurnBinding,
+} from "../lib/turn-binding-store.js";
+
+// Injected so tests can seed the persisted table / capture snapshots without
+// touching the real sessions directory.
+export const _deps = {
+  loadTurnBindingLog,
+  persistTurnBinding,
+  now: () => Date.now(),
+};
+
+/**
+ * @param {{sessionId?: string, nonce?: string}} [opts]
+ * @returns {object|null}  null when the session cannot persist (no sessionId)
+ */
+export function createReplTurnBindingProducer({ sessionId, nonce } = {}) {
+  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;
+  return {
+    /**
+     * Anchor a new interactive turn. Call just AFTER the user message was
+     * appended, with `conversationOffset = messages.length` — the exact-match
+     * contract `pickPersistedTurn` relies on.
+     */
+    beginTurn(conversationOffset) {
+      try {
+        if (!feed) {
+          feed = createTurnBindingFeed({
+            log: _deps.loadTurnBindingLog(sessionId),
+            nonce: runNonce,
+          });
+        }
+        return feed.beginTurn(conversationOffset, { supersede: true });
+      } catch {
+        return null; // advisory — never disturb the turn
+      }
+    },
+    /** Fold one agent-loop event into the current turn (fed by agentLoop). */
+    handleEvent(event) {
+      if (!feed) return false;
+      try {
+        return feed.handleEvent(event);
+      } catch {
+        return false;
+      }
+    },
+    /** Persist the table after a settled turn (dirty-gated, best-effort). */
+    persistIfDirty() {
+      if (!feed || !feed.isDirty()) return false;
+      try {
+        const ok = _deps.persistTurnBinding(sessionId, feed.log);
+        if (ok) feed.clearDirty();
+        return ok;
+      } catch {
+        return false;
+      }
+    },
+    /** The live table (for tests / future in-process consumers). */
+    log: () => (feed ? feed.log : null),
+  };
+}

package/src/runtime/headless-runner.js

@@ -57,6 +57,8 @@ import {
   classifyToolSideEffect,
 } from "../lib/side-effect-ledger.js";
 import { SIDE_EFFECT_LEDGER_EVENT } from "../lib/side-effect-ledger-store.js";
+import { TurnBindingLog, createTurnBindingFeed } from "../lib/turn-binding.js";
+import { TURN_BINDING_EVENT } from "../lib/turn-binding-store.js";
 import { operationIdempotencyKey } from "../lib/idempotency.js";
 import { expandFileRefsAsync } from "./file-ref-expander.js";
 import { composeSystemPrompt } from "./system-prompt.js";
@@ -730,6 +732,50 @@ export async function runAgentHeadless(options = {}, deps = {}) {
       // best-effort — never fail the run over ledger persistence
     }
   };
+  // P1 explicit turn→checkpoint binding: feed the TurnBindingLog in real time
+  // off the yielded agent-loop events (checkpoint / tool / policy / child-agent)
+  // and persist the table as a hash-chained `turn_checkpoint_binding` session
+  // event at each turn boundary. Provider tool_use ids are not runner-visible,
+  // so tool-call ids are synthesized `<nonce>:c<seq>` (mirrors the side-effect
+  // ledger's op-id scheme — stable within a run, unique across resumes).
+  // rebuildMessages ignores this event type, so it never pollutes model
+  // context. Only writes when a turn actually recorded something, and only for
+  // persisted runs — a tool-free Q&A or ephemeral run stays byte-identical.
+  let turnBindingLog = new TurnBindingLog();
+  if (persist) {
+    try {
+      const events = store.readEvents(sessionId) || [];
+      for (let i = events.length - 1; i >= 0; i--) {
+        const e = events[i];
+        if (
+          e &&
+          e.type === TURN_BINDING_EVENT &&
+          e.data &&
+          Array.isArray(e.data.turns)
+        ) {
+          turnBindingLog = TurnBindingLog.fromJSON(e.data);
+          break;
+        }
+      }
+    } catch {
+      // fresh log — best effort
+    }
+  }
+  // Event→table folding + id synthesis live in the SHARED feeder core
+  // (createTurnBindingFeed) so the interactive REPL producer can never drift
+  // from this runner's mapping. No feed at all for non-persisted runs.
+  const turnBindingFeed = persist
+    ? createTurnBindingFeed({ log: turnBindingLog, nonce: sideEffectRunNonce })
+    : null;
+  const persistTurnBindingLog = () => {
+    if (!turnBindingFeed || !turnBindingFeed.isDirty()) return;
+    try {
+      store.appendEvent(sessionId, TURN_BINDING_EVENT, turnBindingLog.toJSON());
+      turnBindingFeed.clearDirty();
+    } catch {
+      // best-effort — never fail the run over binding persistence
+    }
+  };
   if (persist) {
     try {
       const events = store.readEvents(sessionId) || [];
@@ -1703,7 +1749,17 @@ export async function runAgentHeadless(options = {}, deps = {}) {
   try {
     // eslint-disable-next-line no-constant-condition
     while (true) {
+      // P1 turn→checkpoint binding: one drain of the loop = one turn. Anchor
+      // the conversation offset before the model sees the new user turn. A
+      // `--worktree` run stamps its isolation worktree (branch name, threaded
+      // from the command layer) onto each turn record.
+      if (turnBindingFeed) {
+        turnBindingFeed.beginTurn(messages.length, {
+          worktreeId: options.worktreeId ?? null,
+        });
+      }
       for await (const event of runLoop(messages, loopOptions)) {
+        if (turnBindingFeed) turnBindingFeed.handleEvent(event);
         switch (event.type) {
           case "checkpoint": {
             if (isText)
@@ -1876,6 +1932,9 @@ export async function runAgentHeadless(options = {}, deps = {}) {
         // call is made (break out of the for-await, not just the switch).
         if (stopForCost) break;
       }
+      // P1 turn→checkpoint binding: the turn settled — persist the explicit
+      // table (latest snapshot wins on load; no-op when nothing was recorded).
+      persistTurnBindingLog();
       // ── auto-rewake re-drive (opt-in via --auto-rewake) ─────────────────
       // Under auto-rewake, settle the async Stop hooks after EVERY turn (so the
       // final turn's background check still runs). If an asyncRewake check

package/src/assets/web-panel/assets/MarkdownRenderer-RQ1HbTY5.js

@@ -1 +0,0 @@
-import{P as c,J as p,b as s}from"./vendor-Bn1JzzAn.js";import{r as a}from"./markdown-Yo_c6Krv.js";import{_ as d}from"./index-Dmt1HDWZ.js";const _={__name:"MarkdownRenderer",props:{content:{type:String,default:""}},setup(t,{expose:o}){o();const e=t,r=s(()=>a(e.content||"")),n={props:e,rendered:r,computed:s,get renderMarkdown(){return a}};return Object.defineProperty(n,"__isScriptSetup",{enumerable:!1,value:!0}),n}},i=["innerHTML"];function m(t,o,e,r,n,u){return c(),p("div",{class:"markdown-content",innerHTML:r.rendered},null,8,i)}const w=d(_,[["render",m],["__scopeId","data-v-0b0b9f63"],["__file","/tmp/cc-web-panel-i8wW4v/repo/packages/web-panel/src/components/MarkdownRenderer.vue"]]);export{w as M};

package/src/assets/web-panel/assets/devWarning-Cwuuqc_f.js

@@ -1 +0,0 @@
-import{Q as r}from"./index-Dmt1HDWZ.js";const o=((n,a,e)=>{r(n,`[ant-design-vue: ${a}] ${e}`)});export{o as d};

package/src/assets/web-panel/assets/index-BkTk-zJK.js

@@ -1 +0,0 @@
-import{C as o}from"./Col-8NQiKJJx.js";import{a0 as t}from"./index-Dmt1HDWZ.js";import"./vendor-Bn1JzzAn.js";import"./index-BqPuyN4p.js";import"./icons-DG5UD-6K.js";const s=t(o);export{s as default};

package/src/assets/web-panel/assets/index-C-BSTEhe.js

@@ -1 +0,0 @@
-import{A as o}from"./Row-C-RorxHs.js";import{a0 as t}from"./index-Dmt1HDWZ.js";import"./vendor-Bn1JzzAn.js";import"./responsiveObserve-CVZZlhJf.js";import"./useFlexGapSupport-Dljy3diT.js";import"./styleChecker-BqknYxTe.js";import"./index-BqPuyN4p.js";import"./icons-DG5UD-6K.js";const l=t(o);export{l as default};