newmark-agent 0.6.3 → 0.6.4

package/dist/conversation-utility-host.bundle.cjs

@@ -126966,6 +126966,23 @@ var SkillsManager = class {
 // src/core/agent.ts
 init_flow();
 
+// src/core/branchIdentity.ts
+var BRANCH_IDENTITY_SEPARATOR = "::branch:";
+function branchConversationIdentity(conversationId, branchNodeId) {
+  const conversation = String(conversationId || "").trim() || "default";
+  const branch = String(branchNodeId || "").trim();
+  return branch ? `${conversation}${BRANCH_IDENTITY_SEPARATOR}${branch}` : conversation;
+}
+function assertFreshBranchIdentity(conversationId, branchNodeId, existing) {
+  const branch = String(branchNodeId || "").trim();
+  if (!branch) throw new Error("Branch conversation identity requires a branch node id.");
+  for (const known of existing) {
+    if (String(known || "") === branch) {
+      throw new Error(`Branch conversation identity ${branchConversationIdentity(conversationId, branch)} is already in use.`);
+    }
+  }
+}
+
 // src/core/agentKernelRunner.ts
 var fs19 = __toESM(require("fs"));
 var path21 = __toESM(require("path"));
@@ -128046,10 +128063,16 @@ var HIDDEN_LINE_PREFIXES = [
 ];
 function providerSessionIdentity(agent) {
   const conversationId = String(agent.activeConversationId || "default");
+  let runBranchId = "";
+  try {
+    runBranchId = String(agent.activeWorkRunBranchId() || "");
+  } catch {
+    runBranchId = "";
+  }
+  if (runBranchId) return branchConversationIdentity(conversationId, runBranchId);
   try {
     const snapshot2 = agent.getConversationSnapshot(conversationId);
-    const branchId = String(snapshot2.runtimeBranchId || snapshot2.activeBranchId || "");
-    return branchId ? `${conversationId}::branch:${branchId}` : conversationId;
+    return branchConversationIdentity(conversationId, String(snapshot2.runtimeBranchId || snapshot2.activeBranchId || ""));
   } catch {
     return conversationId;
   }
@@ -132797,6 +132820,22 @@ var Agent5 = class _Agent {
   currentWorkRunId() {
     return this.activeWorkRunId || this.finalizingWorkRunId || "";
   }
+  /**
+   * The branch node that owns the currently active Build. Provider session ids
+   * and branch-scoped caches must use this identity instead of "the branch that
+   * happens to be active", otherwise a concurrently running sibling branch
+   * (branch-communication mode) or a page switched mid-Build would read another
+   * branch's remote session and folded history.
+   */
+  activeWorkRunBranchId() {
+    const runId = this.currentWorkRunId();
+    const run = runId ? this.workRuns.find((item) => String(item.runId || "") === runId) : void 0;
+    return String(run?.branchNodeId || "") || this.currentBranchNodeId();
+  }
+  /** Full conversation identity of one branch node (shared by every branch kind). */
+  branchConversationIdentity(branchNodeId) {
+    return branchConversationIdentity(this.activeConversationId || "default", branchNodeId);
+  }
   activeModelConfig() {
     const deployment = this.activeDeployment();
     return deployment ? this.config.findDeployment(deployment) : this.config.findModel(this.model);
@@ -135035,6 +135074,7 @@ ${next2.body}`;
     });
     const reusableGroup = Object.values(tree.branchGroups).find((group) => group.sourceNodeId === parentNodeId && (targetGuideNodeId && group.sourceGuideId === targetGuideNodeId || !targetGuideNodeId && targetMessageId && group.sourceMessageId === targetMessageId || !group.sourceGuideId && !group.sourceMessageId && group.sourceMessageIndex === index2) || group.nodeIds.includes(parentNodeId) && group.sourceMessageIndex === index2 && (targetGuideNodeId && group.pageGuideIds?.[parentNodeId] === targetGuideNodeId || !targetGuideNodeId && targetMessageId && group.pageMessageIds?.[parentNodeId] === targetMessageId));
     const branchId = crypto15.randomUUID();
+    assertFreshBranchIdentity(clean || this.activeConversationId || "default", branchId, Object.keys(tree.nodes));
     const branch = this.treeNodeFromEntry(branchId, parentNodeId, index2, text3, {
       ...entry,
       chatMessages: sourceNode.chatMessages.slice(0, index2),
@@ -135619,7 +135659,7 @@ Conversation title (a few words):`;
       chatMessages: [...this.chatMessages],
       history: [...this.history],
       providerUsage: this.conversationProviderUsage(),
-      compressionCache: [...this.compressionCache],
+      compressionCache: this.mergedCompressionCacheForPersist(stored.conversations[stateKey2]),
       branchMailbox: [...this.branchMailbox],
       branchCommunication: this.branchCommunicationEnabled,
       plan: this.normalizeConversationPlan(this.conversationPlan),
@@ -135677,7 +135717,7 @@ Conversation title (a few words):`;
     if (saved) {
       this.restoreProviderUsage(saved.providerUsage);
       this.history = [...saved.history];
-      this.compressionCache = saved.compressionCache ? saved.compressionCache.map((entry) => ({ ...entry, messages: [...entry.messages] })) : [];
+      this.compressionCache = this.compressionCacheForBranch(saved.compressionCache);
       this.nextCompressionCacheId = Math.max(1, ...this.compressionCache.map((entry) => Number(entry.id.replace(/^ctx-cache-/, "")) || 0)) + 1;
       this.branchMailbox = (saved.branchMailbox || []).map((message) => ({ ...message }));
       this.nextBranchMessageSequence = Math.max(1, ...this.branchMailbox.map((message) => Number(message.sequence) || 0)) + 1;
@@ -135706,7 +135746,7 @@ Conversation title (a few words):`;
     this.restoreProviderUsage(persisted?.providerUsage);
     const repairedHistory = this.repairDanglingToolCalls(persisted?.history ? [...persisted.history] : []);
     this.history = repairedHistory.messages;
-    this.compressionCache = persisted?.compressionCache ? persisted.compressionCache.map((entry) => ({ ...entry, messages: [...entry.messages] })) : [];
+    this.compressionCache = this.compressionCacheForBranch(persisted?.compressionCache);
     this.nextCompressionCacheId = Math.max(1, ...this.compressionCache.map((entry) => Number(entry.id.replace(/^ctx-cache-/, "")) || 0)) + 1;
     this.branchMailbox = (persisted?.branchMailbox || []).map((message) => ({ ...message }));
     this.nextBranchMessageSequence = Math.max(1, ...this.branchMailbox.map((message) => Number(message.sequence) || 0)) + 1;
@@ -140558,7 +140598,36 @@ ${text3.slice(-tailChars).trimStart()}`;
   }
   compressionArchiveScopeKey() {
     if (this.isSubagentRuntime || !this.config.getBool("context", "compression_archive_enabled")) return null;
-    return this.workspaceConversationKey();
+    const base = this.workspaceConversationKey();
+    if (!base) return null;
+    return branchConversationIdentity(base, this.currentBranchNodeId());
+  }
+  /**
+   * The hot folded-history cache belongs to one branch node. Legacy entries
+   * (created before branch scoping) belong to the root node, which is where
+   * they were produced.
+   */
+  compressionCacheForBranch(entries) {
+    const branch = String(this.currentBranchNodeId() || "");
+    const root3 = String(this.conversationTree()?.rootNodeId || "");
+    return (Array.isArray(entries) ? entries : []).flatMap((entry) => {
+      const owner = String(entry.branchNodeId || root3 || "");
+      if (branch && owner && owner !== branch) return [];
+      if (branch && !owner) return [];
+      return [{ ...entry, branchNodeId: owner || branch || void 0, messages: [...entry.messages] }];
+    });
+  }
+  /**
+   * Persist the union of every branch's folded history: the live in-memory
+   * cache only holds the active branch, and the stored entry holds the rest.
+   */
+  mergedCompressionCacheForPersist(storedEntry) {
+    const branch = String(this.currentBranchNodeId() || "");
+    const others = (storedEntry?.compressionCache || []).filter((entry) => {
+      const owner = String(entry.branchNodeId || "");
+      return !!owner && owner !== branch;
+    });
+    return [...others, ...this.compressionCache.map((entry) => ({ ...entry, messages: [...entry.messages] }))];
   }
   coldCompressionEntries() {
     const scopeKey = this.compressionArchiveScopeKey();
@@ -140621,7 +140690,8 @@ ${text3.slice(-tailChars).trimStart()}`;
       foldedEntries: messages.length,
       foldedChars,
       model,
-      fallback
+      fallback,
+      branchNodeId: this.currentBranchNodeId() || void 0
     });
     this.nextCompressionCacheId += 1;
     const maxEntries = Math.max(0, Math.floor(this.config.getNum("context", "compression_cache_max") || 8));
@@ -141702,6 +141772,81 @@ var GuardedContinuationStore = class {
       return { ...build2, input: cloneInput(build2.input) };
     });
   }
+  /**
+   * dev-0.6.4 hotfix: 当某个被受理的 Build 失败/取消后，它的后继会永远无法被
+   * claim（`claimBuild` 只认「父 = 已提交 frontier」），整条队列就此卡死，新提交
+   * 也只是接在失败链后面。
+   *
+   * 这里提供一条**显式**修复通道：把被阻断的排队 Build 重新挂到当前已提交的
+   * frontier 上，保持原有队列顺序，并为每一次改挂写入 `BuildQueueRepaired`
+   * 审计事件（记录旧 parent / 新 parent / 原因）。它不是静默 rebase：调用方是
+   * 用户的显式动作（恢复队列）或一次新的入队命令。
+   */
+  repairBlockedQueue(input) {
+    return this.mutate((ledger) => {
+      const branch = this.requireBranch(ledger, input);
+      const frontier = branch.headBuildId || null;
+      const queued = Object.values(ledger.builds).filter((build2) => build2.branchId === branch.branchId && build2.status === "QUEUED").sort((a, b) => a.queueSequence - b.queueSequence);
+      const repaired = [];
+      let chainParent = frontier;
+      let mutated = false;
+      for (const build2 of queued) {
+        if ((build2.parentBuildId || null) !== (chainParent || null)) {
+          const previousParentBuildId = build2.parentBuildId;
+          build2.parentBuildId = chainParent;
+          build2.waitingReason = void 0;
+          build2.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          repaired.push(build2.buildId);
+          mutated = true;
+          this.appendEvent(ledger, {
+            type: "BuildQueueRepaired",
+            workspaceId: this.workspaceId,
+            rootId: branch.rootId,
+            branchId: branch.branchId,
+            buildId: build2.buildId,
+            attemptId: null,
+            fence: null,
+            payload: {
+              previousParentBuildId,
+              newParentBuildId: chainParent,
+              reason: String(input.reason || "committed-frontier-repair")
+            }
+          });
+        }
+        chainParent = build2.buildId;
+      }
+      if (mutated) {
+        branch.queueRevision += 1;
+        branch.lifecycleRevision += 1;
+        branch.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      return { repaired, frontier };
+    });
+  }
+  /**
+   * dev-0.6.4 hotfix: 读取视角的受阻推导。
+   *
+   * 一个 QUEUED Build 只有在它的父正好是「已提交 frontier」或队列里位于它之前
+   * 的可执行 Build 时才可能被 claim（见 `claimBuild`）。这里按队列顺序推导哪些行
+   * 目前不可执行：父不是链上前驱、或父已 FAILED/CANCELLED 的行即为受阻，且受阻点
+   * 之后的所有行同样受阻。
+   */
+  blockedQueuedBuildIds(ledger, branch) {
+    const blocked = /* @__PURE__ */ new Set();
+    const queued = Object.values(ledger.builds).filter((build2) => build2.branchId === branch.branchId && build2.status === "QUEUED").sort((a, b) => a.queueSequence - b.queueSequence);
+    let chainParent = branch.headBuildId || null;
+    for (const build2 of queued) {
+      const parent2 = build2.parentBuildId ? ledger.builds[build2.parentBuildId] : null;
+      const parentIsChainPredecessor = (build2.parentBuildId || null) === (chainParent || null);
+      const parentFailed = !!parent2 && (parent2.status === "FAILED" || parent2.status === "CANCELLED");
+      if (!parentIsChainPredecessor || parentFailed) {
+        blocked.add(build2.buildId);
+        continue;
+      }
+      chainParent = build2.buildId;
+    }
+    return blocked;
+  }
   deleteQueuedBuild(input) {
     this.mutate((ledger) => {
       const build2 = ledger.builds[input.buildId];
@@ -142103,7 +142248,12 @@ var GuardedContinuationStore = class {
   }
   snapshotUnlocked(ledger, branch) {
     const guard = ledger.guards[branch.branchId] || defaultGuard(branch.branchId);
-    const builds = Object.values(ledger.builds).filter((build2) => build2.branchId === branch.branchId).sort((a, b) => a.queueSequence - b.queueSequence).map((build2) => ({ ...build2, input: cloneInput(build2.input) }));
+    const blockedBuildIds = this.blockedQueuedBuildIds(ledger, branch);
+    const builds = Object.values(ledger.builds).filter((build2) => build2.branchId === branch.branchId).sort((a, b) => a.queueSequence - b.queueSequence).map((build2) => ({
+      ...build2,
+      input: cloneInput(build2.input),
+      waitingReason: build2.waitingReason || (blockedBuildIds.has(build2.buildId) ? "DEPENDENCY_FAILED" : void 0)
+    }));
     return {
       workspaceId: this.workspaceId,
       rootId: branch.rootId,
@@ -142706,11 +142856,25 @@ var ConversationKernel = class {
   queueItems(target) {
     const runtime = this.findRuntime(target);
     if (!runtime) return [];
+    let waitingByBuildId = /* @__PURE__ */ new Map();
+    const continuation = this.continuationStore(runtime);
+    if (continuation) {
+      try {
+        const snapshot2 = continuation.store.snapshot({
+          workspaceId: continuation.workspaceId,
+          rootId: continuation.rootId,
+          branchId: continuation.branchId
+        });
+        waitingByBuildId = new Map(snapshot2.builds.filter((build2) => !!build2.waitingReason).map((build2) => [build2.buildId, String(build2.waitingReason)]));
+      } catch {
+      }
+    }
     return runtime.pendingNextTurn.flatMap((item) => {
       if (item.queueMode !== "followUp") return [];
       if (typeof item.message === "string") return [];
       const id = String(item.message.clientMessageId || "");
       if (!id) return [];
+      const buildId = String(item.message.buildId || "");
       return [{
         id,
         buildId: item.message.buildId,
@@ -142723,7 +142887,9 @@ var ConversationKernel = class {
         images: item.message.images?.map((image) => ({ ...image })),
         branchNodeId: item.message.branchNodeId,
         branchPath: item.message.branchPath?.slice(),
-        modelSelection: item.message.modelSelection
+        modelSelection: item.message.modelSelection,
+        waitingReason: waitingByBuildId.get(buildId),
+        blocked: waitingByBuildId.has(buildId)
       }];
     });
   }
@@ -142997,6 +143163,35 @@ ${text3}`;
     }
     return runtime.queuePaused;
   }
+  /**
+   * dev-0.6.4 hotfix: 显式修复被失败前置阻断的排队行。
+   *
+   * 0.6.3 的合约是「失败/取消阻断后继，且不静默跳过」，所以这里不挂在恢复动作上
+   * 自动执行；它必须由用户的显式动作触发（界面上的“修复受阻队列”按钮）。每一次
+   * 改挂都写入 `BuildQueueRepaired` 事件并发布可见状态，触发者与原因可审计。
+   */
+  repairBlockedQueueNow(runtime) {
+    const continuation = this.continuationStore(runtime);
+    if (!continuation) return 0;
+    try {
+      const result = continuation.store.repairBlockedQueue({
+        workspaceId: continuation.workspaceId,
+        rootId: continuation.rootId,
+        branchId: continuation.branchId,
+        reason: "explicit-user-repair"
+      });
+      if (result.repaired.length) {
+        runtime.runner.recordWorkStatus(
+          `${result.repaired.length} queued row(s) blocked by a failed predecessor were re-anchored to the last committed build; the queue resumes in order.`
+        );
+        this.schedulePendingRuntimeContinuation(runtime, runtime.runId);
+      }
+      return result.repaired.length;
+    } catch (error2) {
+      runtime.runner.recordWorkStatus(`Queue repair failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
+      return 0;
+    }
+  }
   queueAction(target, action, input = {}) {
     const normalized = this.normalizeTarget(target);
     const runtime = this.findRuntime(normalized) || this.runtime(normalized, {
@@ -143031,6 +143226,8 @@ ${text3}`;
       this.setQueuePaused(runtime.target, !runtime.queuePaused);
     } else if (action === "set_pause") {
       this.setQueuePaused(runtime.target, input.paused === true);
+    } else if (action === "repair_blocked") {
+      this.repairBlockedQueueNow(runtime);
     } else if (action === "guide") {
       if (input.text !== void 0) this.updateQueueItem(runtime.target, String(input.id || ""), input.text, input);
       const item = this.queueItems(runtime.target).find((entry) => entry.id === String(input.id || ""));

package/dist/core/agent.d.ts

@@ -85,6 +85,8 @@ export interface CompressionCacheEntry {
     foldedChars: number;
     model: string;
     fallback: boolean;
+    /** Branch node that owns this folded history. Sibling pages must never read it. */
+    branchNodeId?: string;
 }
 type ConversationModelSelection = {
     kind: 'auto';
@@ -528,6 +530,16 @@ export declare class Agent {
     activeModelName(): string;
     modelSelectionValue(): string;
     currentWorkRunId(): string;
+    /**
+     * The branch node that owns the currently active Build. Provider session ids
+     * and branch-scoped caches must use this identity instead of "the branch that
+     * happens to be active", otherwise a concurrently running sibling branch
+     * (branch-communication mode) or a page switched mid-Build would read another
+     * branch's remote session and folded history.
+     */
+    activeWorkRunBranchId(): string;
+    /** Full conversation identity of one branch node (shared by every branch kind). */
+    branchConversationIdentity(branchNodeId: string): string;
     activeModelConfig(): ReturnType<ConfigManager['allModels']>[number] | undefined;
     requestedModelSelection(): ModelSelection;
     resetAutoRoute(): void;
@@ -1229,6 +1241,17 @@ export declare class Agent {
     private formatCompressionSummary;
     private persistCompressedHistory;
     private compressionArchiveScopeKey;
+    /**
+     * The hot folded-history cache belongs to one branch node. Legacy entries
+     * (created before branch scoping) belong to the root node, which is where
+     * they were produced.
+     */
+    private compressionCacheForBranch;
+    /**
+     * Persist the union of every branch's folded history: the live in-memory
+     * cache only holds the active branch, and the stored entry holds the rest.
+     */
+    private mergedCompressionCacheForPersist;
     private coldCompressionEntries;
     private compressionArchiveEntryCount;
     private archiveColdCompressionEntries;

package/dist/core/agent.js

@@ -58,6 +58,7 @@ const skills_1 = require("./skills");
 const flow_1 = require("./flow");
 const memoryLab_1 = require("./memoryLab");
 const agentKernelRunner_1 = require("./agentKernelRunner");
+const branchIdentity_1 = require("./branchIdentity");
 const toolPolicy_1 = require("./toolPolicy");
 const conversationTarget_1 = require("./conversationTarget");
 const utilityHostToolBridge_1 = require("./utilityHostToolBridge");
@@ -1020,6 +1021,22 @@ class Agent {
     currentWorkRunId() {
         return this.activeWorkRunId || this.finalizingWorkRunId || '';
     }
+    /**
+     * The branch node that owns the currently active Build. Provider session ids
+     * and branch-scoped caches must use this identity instead of "the branch that
+     * happens to be active", otherwise a concurrently running sibling branch
+     * (branch-communication mode) or a page switched mid-Build would read another
+     * branch's remote session and folded history.
+     */
+    activeWorkRunBranchId() {
+        const runId = this.currentWorkRunId();
+        const run = runId ? this.workRuns.find(item => String(item.runId || '') === runId) : undefined;
+        return String(run?.branchNodeId || '') || this.currentBranchNodeId();
+    }
+    /** Full conversation identity of one branch node (shared by every branch kind). */
+    branchConversationIdentity(branchNodeId) {
+        return (0, branchIdentity_1.branchConversationIdentity)(this.activeConversationId || 'default', branchNodeId);
+    }
     activeModelConfig() {
         const deployment = this.activeDeployment();
         return deployment ? this.config.findDeployment(deployment) : this.config.findModel(this.model);
@@ -3615,6 +3632,10 @@ class Agent {
                 && ((targetGuideNodeId && group.pageGuideIds?.[parentNodeId] === targetGuideNodeId)
                     || (!targetGuideNodeId && targetMessageId && group.pageMessageIds?.[parentNodeId] === targetMessageId))));
         const branchId = crypto.randomUUID();
+        // dev-0.6.4: 新分支（用户分页编辑与实验性分支交流共用这一事务）必须拿到
+        // 全新的全对话 id。复用节点 id 会让两个分支共享 provider 会话序列、
+        // 压缩历史与本地缓存，正是「跨分支缓存」必须禁止的情形。
+        (0, branchIdentity_1.assertFreshBranchIdentity)(clean || this.activeConversationId || 'default', branchId, Object.keys(tree.nodes));
         const branch = this.treeNodeFromEntry(branchId, parentNodeId, index, text, {
             ...entry,
             chatMessages: sourceNode.chatMessages.slice(0, index),
@@ -4317,7 +4338,7 @@ class Agent {
             chatMessages: [...this.chatMessages],
             history: [...this.history],
             providerUsage: this.conversationProviderUsage(),
-            compressionCache: [...this.compressionCache],
+            compressionCache: this.mergedCompressionCacheForPersist(stored.conversations[stateKey]),
             branchMailbox: [...this.branchMailbox],
             branchCommunication: this.branchCommunicationEnabled,
             plan: this.normalizeConversationPlan(this.conversationPlan),
@@ -4377,7 +4398,7 @@ class Agent {
         if (saved) {
             this.restoreProviderUsage(saved.providerUsage);
             this.history = [...saved.history];
-            this.compressionCache = saved.compressionCache ? saved.compressionCache.map(entry => ({ ...entry, messages: [...entry.messages] })) : [];
+            this.compressionCache = this.compressionCacheForBranch(saved.compressionCache);
             this.nextCompressionCacheId = Math.max(1, ...this.compressionCache.map(entry => Number(entry.id.replace(/^ctx-cache-/, '')) || 0)) + 1;
             this.branchMailbox = (saved.branchMailbox || []).map(message => ({ ...message }));
             this.nextBranchMessageSequence = Math.max(1, ...this.branchMailbox.map(message => Number(message.sequence) || 0)) + 1;
@@ -4406,7 +4427,7 @@ class Agent {
         this.restoreProviderUsage(persisted?.providerUsage);
         const repairedHistory = this.repairDanglingToolCalls(persisted?.history ? [...persisted.history] : []);
         this.history = repairedHistory.messages;
-        this.compressionCache = persisted?.compressionCache ? persisted.compressionCache.map(entry => ({ ...entry, messages: [...entry.messages] })) : [];
+        this.compressionCache = this.compressionCacheForBranch(persisted?.compressionCache);
         this.nextCompressionCacheId = Math.max(1, ...this.compressionCache.map(entry => Number(entry.id.replace(/^ctx-cache-/, '')) || 0)) + 1;
         this.branchMailbox = (persisted?.branchMailbox || []).map(message => ({ ...message }));
         this.nextBranchMessageSequence = Math.max(1, ...this.branchMailbox.map(message => Number(message.sequence) || 0)) + 1;
@@ -9795,7 +9816,41 @@ class Agent {
     compressionArchiveScopeKey() {
         if (this.isSubagentRuntime || !this.config.getBool('context', 'compression_archive_enabled'))
             return null;
-        return this.workspaceConversationKey();
+        const base = this.workspaceConversationKey();
+        if (!base)
+            return null;
+        // dev-0.6.4: 折叠历史必须按分支节点隔离——用户分页产生的分支与实验性分支
+        // 交流产生的分支共用这一条身份规则，兄弟分支不得互相读取压缩归档。
+        return (0, branchIdentity_1.branchConversationIdentity)(base, this.currentBranchNodeId());
+    }
+    /**
+     * The hot folded-history cache belongs to one branch node. Legacy entries
+     * (created before branch scoping) belong to the root node, which is where
+     * they were produced.
+     */
+    compressionCacheForBranch(entries) {
+        const branch = String(this.currentBranchNodeId() || '');
+        const root = String(this.conversationTree()?.rootNodeId || '');
+        return (Array.isArray(entries) ? entries : []).flatMap(entry => {
+            const owner = String(entry.branchNodeId || root || '');
+            if (branch && owner && owner !== branch)
+                return [];
+            if (branch && !owner)
+                return [];
+            return [{ ...entry, branchNodeId: owner || branch || undefined, messages: [...entry.messages] }];
+        });
+    }
+    /**
+     * Persist the union of every branch's folded history: the live in-memory
+     * cache only holds the active branch, and the stored entry holds the rest.
+     */
+    mergedCompressionCacheForPersist(storedEntry) {
+        const branch = String(this.currentBranchNodeId() || '');
+        const others = (storedEntry?.compressionCache || []).filter(entry => {
+            const owner = String(entry.branchNodeId || '');
+            return !!owner && owner !== branch;
+        });
+        return [...others, ...this.compressionCache.map(entry => ({ ...entry, messages: [...entry.messages] }))];
     }
     coldCompressionEntries() {
         const scopeKey = this.compressionArchiveScopeKey();
@@ -9872,6 +9927,7 @@ class Agent {
             foldedChars,
             model,
             fallback,
+            branchNodeId: this.currentBranchNodeId() || undefined,
         });
         this.nextCompressionCacheId += 1;
         const maxEntries = Math.max(0, Math.floor(this.config.getNum('context', 'compression_cache_max') || 8));

package/dist/core/agentKernelRunner.js

@@ -39,6 +39,7 @@ exports.resetPublicAssistantDeltaFilter = resetPublicAssistantDeltaFilter;
 exports.runAgentKernel = runAgentKernel;
 exports.routeToolSurfaceV2 = routeToolSurfaceV2;
 exports.toolResultObjectiveOutcome = toolResultObjectiveOutcome;
+const branchIdentity_1 = require("./branchIdentity");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const terminalTakeover_1 = require("../tools/terminalTakeover");
@@ -75,13 +76,25 @@ const HIDDEN_LINE_PREFIXES = [
  * a fork that reuses the root conversation id can read the other branch's
  * history. Keep the id stable within one branch (normal sequential turns still
  * cache-hit) and change it the moment the runtime branch changes.
+ *
+ * dev-0.6.4: 分支身份固定在 Build 启动时创建的那条分支节点上（用户分页分支与
+ * 实验性分支交流分支共用同一规则）。这里绝不读取「当前正在查看/激活的分支」，
+ * 否则正在并行运行的兄弟分支或中途切换的页面会把请求绑到别的分支的远程会话。
  */
 function providerSessionIdentity(agent) {
     const conversationId = String(agent.activeConversationId || 'default');
+    let runBranchId = '';
+    try {
+        runBranchId = String(agent.activeWorkRunBranchId() || '');
+    }
+    catch {
+        runBranchId = '';
+    }
+    if (runBranchId)
+        return (0, branchIdentity_1.branchConversationIdentity)(conversationId, runBranchId);
     try {
         const snapshot = agent.getConversationSnapshot(conversationId);
-        const branchId = String(snapshot.runtimeBranchId || snapshot.activeBranchId || '');
-        return branchId ? `${conversationId}::branch:${branchId}` : conversationId;
+        return (0, branchIdentity_1.branchConversationIdentity)(conversationId, String(snapshot.runtimeBranchId || snapshot.activeBranchId || ''));
     }
     catch {
         return conversationId;

package/dist/core/branchIdentity.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Branch conversation identity (dev-0.6.4).
+ *
+ * A conversation owns a tree of branch nodes. Every node is its own full
+ * conversation: the provider-side session sequence id, the folded-history
+ * archive and every local transcript cache are scoped by the node id, so
+ * sibling pages can never read each other's remote session or cached history.
+ *
+ * The user's pagination edits and the experimental branch-communication
+ * branches are created by the same `Agent.branchConversation` transaction, so
+ * both kinds of branch must share this single identity function. Never derive
+ * the identity from "the branch that happens to be active" at request time.
+ */
+export declare const BRANCH_IDENTITY_SEPARATOR = "::branch:";
+/** The full conversation id of one branch node: `<conversationId>::branch:<branchNodeId>`. */
+export declare function branchConversationIdentity(conversationId: string, branchNodeId: string): string;
+/** True when a value already carries a branch node identity. */
+export declare function isBranchConversationIdentity(value: string): boolean;
+/**
+ * Workspace-wide cache scope for one branch. Used by caches that must never be
+ * shared across sibling branches (compression history, provider payloads).
+ */
+export declare function branchCacheScopeKey(workspaceId: string, conversationId: string, branchNodeId: string): string;
+/**
+ * A branch may never reuse the identity of another node. Callers that mint a
+ * new page assert this before the node becomes reachable.
+ */
+export declare function assertFreshBranchIdentity(conversationId: string, branchNodeId: string, existing: Iterable<string>): void;
+//# sourceMappingURL=branchIdentity.d.ts.map

package/dist/core/branchIdentity.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * Branch conversation identity (dev-0.6.4).
+ *
+ * A conversation owns a tree of branch nodes. Every node is its own full
+ * conversation: the provider-side session sequence id, the folded-history
+ * archive and every local transcript cache are scoped by the node id, so
+ * sibling pages can never read each other's remote session or cached history.
+ *
+ * The user's pagination edits and the experimental branch-communication
+ * branches are created by the same `Agent.branchConversation` transaction, so
+ * both kinds of branch must share this single identity function. Never derive
+ * the identity from "the branch that happens to be active" at request time.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BRANCH_IDENTITY_SEPARATOR = void 0;
+exports.branchConversationIdentity = branchConversationIdentity;
+exports.isBranchConversationIdentity = isBranchConversationIdentity;
+exports.branchCacheScopeKey = branchCacheScopeKey;
+exports.assertFreshBranchIdentity = assertFreshBranchIdentity;
+exports.BRANCH_IDENTITY_SEPARATOR = '::branch:';
+/** The full conversation id of one branch node: `<conversationId>::branch:<branchNodeId>`. */
+function branchConversationIdentity(conversationId, branchNodeId) {
+    const conversation = String(conversationId || '').trim() || 'default';
+    const branch = String(branchNodeId || '').trim();
+    return branch ? `${conversation}${exports.BRANCH_IDENTITY_SEPARATOR}${branch}` : conversation;
+}
+/** True when a value already carries a branch node identity. */
+function isBranchConversationIdentity(value) {
+    return String(value || '').includes(exports.BRANCH_IDENTITY_SEPARATOR);
+}
+/**
+ * Workspace-wide cache scope for one branch. Used by caches that must never be
+ * shared across sibling branches (compression history, provider payloads).
+ */
+function branchCacheScopeKey(workspaceId, conversationId, branchNodeId) {
+    const workspace = String(workspaceId || '').trim() || 'none';
+    return `${workspace}::${branchConversationIdentity(conversationId, branchNodeId)}`;
+}
+/**
+ * A branch may never reuse the identity of another node. Callers that mint a
+ * new page assert this before the node becomes reachable.
+ */
+function assertFreshBranchIdentity(conversationId, branchNodeId, existing) {
+    const branch = String(branchNodeId || '').trim();
+    if (!branch)
+        throw new Error('Branch conversation identity requires a branch node id.');
+    for (const known of existing) {
+        if (String(known || '') === branch) {
+            throw new Error(`Branch conversation identity ${branchConversationIdentity(conversationId, branch)} is already in use.`);
+        }
+    }
+}
+//# sourceMappingURL=branchIdentity.js.map

package/dist/core/continuation/contracts.d.ts

@@ -146,7 +146,7 @@ export interface FinalRecord {
 export interface ContinuationEvent {
     eventId: string;
     cursor: number;
-    type: 'BuildAccepted' | 'AttemptStarted' | 'AttemptHeartbeat' | 'BuildCommitted' | 'BuildFailed' | 'BuildCancelled' | 'BranchForked' | 'BranchPaused' | 'BranchResumed' | 'StaleWriteRejected';
+    type: 'BuildAccepted' | 'AttemptStarted' | 'AttemptHeartbeat' | 'BuildCommitted' | 'BuildFailed' | 'BuildCancelled' | 'BranchForked' | 'BranchPaused' | 'BranchResumed' | 'BuildQueueRepaired' | 'StaleWriteRejected';
     workspaceId: WorkspaceId;
     rootId: RootId;
     branchId: BranchId;

package/dist/core/continuation/store.d.ts

@@ -47,6 +47,34 @@ export declare class GuardedContinuationStore {
         buildId: BuildId;
         input: BuildInput;
     }): BuildRecord;
+    /**
+     * dev-0.6.4 hotfix: 当某个被受理的 Build 失败/取消后，它的后继会永远无法被
+     * claim（`claimBuild` 只认「父 = 已提交 frontier」），整条队列就此卡死，新提交
+     * 也只是接在失败链后面。
+     *
+     * 这里提供一条**显式**修复通道：把被阻断的排队 Build 重新挂到当前已提交的
+     * frontier 上，保持原有队列顺序，并为每一次改挂写入 `BuildQueueRepaired`
+     * 审计事件（记录旧 parent / 新 parent / 原因）。它不是静默 rebase：调用方是
+     * 用户的显式动作（恢复队列）或一次新的入队命令。
+     */
+    repairBlockedQueue(input: {
+        workspaceId: string;
+        rootId: RootId;
+        branchId: BranchId;
+        reason?: string;
+    }): {
+        repaired: BuildId[];
+        frontier: BuildId | null;
+    };
+    /**
+     * dev-0.6.4 hotfix: 读取视角的受阻推导。
+     *
+     * 一个 QUEUED Build 只有在它的父正好是「已提交 frontier」或队列里位于它之前
+     * 的可执行 Build 时才可能被 claim（见 `claimBuild`）。这里按队列顺序推导哪些行
+     * 目前不可执行：父不是链上前驱、或父已 FAILED/CANCELLED 的行即为受阻，且受阻点
+     * 之后的所有行同样受阻。
+     */
+    private blockedQueuedBuildIds;
     deleteQueuedBuild(input: {
         workspaceId: string;
         rootId: RootId;