newmark-agent 0.6.3 → 0.6.4

package/dist/core/continuation/store.js

@@ -271,6 +271,87 @@ class GuardedContinuationStore {
             return { ...build, input: cloneInput(build.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(build => build.branchId === branch.branchId && build.status === 'QUEUED')
+                .sort((a, b) => a.queueSequence - b.queueSequence);
+            const repaired = [];
+            let chainParent = frontier;
+            let mutated = false;
+            for (const build of queued) {
+                if ((build.parentBuildId || null) !== (chainParent || null)) {
+                    const previousParentBuildId = build.parentBuildId;
+                    build.parentBuildId = chainParent;
+                    build.waitingReason = undefined;
+                    build.updatedAt = new Date().toISOString();
+                    repaired.push(build.buildId);
+                    mutated = true;
+                    this.appendEvent(ledger, {
+                        type: 'BuildQueueRepaired',
+                        workspaceId: this.workspaceId,
+                        rootId: branch.rootId,
+                        branchId: branch.branchId,
+                        buildId: build.buildId,
+                        attemptId: null,
+                        fence: null,
+                        payload: {
+                            previousParentBuildId,
+                            newParentBuildId: chainParent,
+                            reason: String(input.reason || 'committed-frontier-repair'),
+                        },
+                    });
+                }
+                chainParent = build.buildId;
+            }
+            if (mutated) {
+                branch.queueRevision += 1;
+                branch.lifecycleRevision += 1;
+                branch.updatedAt = new Date().toISOString();
+            }
+            return { repaired, frontier };
+        });
+    }
+    /**
+     * dev-0.6.4 hotfix: 读取视角的受阻推导。
+     *
+     * 一个 QUEUED Build 只有在它的父正好是「已提交 frontier」或队列里位于它之前
+     * 的可执行 Build 时才可能被 claim（见 `claimBuild`）。这里按队列顺序推导哪些行
+     * 目前不可执行：父不是链上前驱、或父已 FAILED/CANCELLED 的行即为受阻，且受阻点
+     * 之后的所有行同样受阻。
+     */
+    blockedQueuedBuildIds(ledger, branch) {
+        const blocked = new Set();
+        const queued = Object.values(ledger.builds)
+            .filter(build => build.branchId === branch.branchId && build.status === 'QUEUED')
+            .sort((a, b) => a.queueSequence - b.queueSequence);
+        let chainParent = branch.headBuildId || null;
+        for (const build of queued) {
+            const parent = build.parentBuildId ? ledger.builds[build.parentBuildId] : null;
+            // 链上的前驱（frontier 或队列里位于它之前的行）在执行时已经提交，因此只有
+            // 「父不是链上前驱」或「父已 FAILED/CANCELLED」的行才是真正受阻的。
+            const parentIsChainPredecessor = (build.parentBuildId || null) === (chainParent || null);
+            const parentFailed = !!parent && (parent.status === 'FAILED' || parent.status === 'CANCELLED');
+            if (!parentIsChainPredecessor || parentFailed) {
+                blocked.add(build.buildId);
+                continue;
+            }
+            chainParent = build.buildId;
+        }
+        return blocked;
+    }
     deleteQueuedBuild(input) {
         this.mutate(ledger => {
             const build = ledger.builds[input.buildId];
@@ -702,10 +783,17 @@ class GuardedContinuationStore {
     }
     snapshotUnlocked(ledger, branch) {
         const guard = ledger.guards[branch.branchId] || (0, contracts_1.defaultGuard)(branch.branchId);
+        // dev-0.6.4 hotfix: 受阻状态由父链推导，而不是只在失败瞬间给直系后继打标记。
+        // 这样“失败之后才入队”的行同样会显示为受阻，界面才能给出显式修复入口。
+        const blockedBuildIds = this.blockedQueuedBuildIds(ledger, branch);
         const builds = Object.values(ledger.builds)
             .filter(build => build.branchId === branch.branchId)
             .sort((a, b) => a.queueSequence - b.queueSequence)
-            .map(build => ({ ...build, input: cloneInput(build.input) }));
+            .map(build => ({
+            ...build,
+            input: cloneInput(build.input),
+            waitingReason: build.waitingReason || (blockedBuildIds.has(build.buildId) ? 'DEPENDENCY_FAILED' : undefined),
+        }));
         return {
             workspaceId: this.workspaceId,
             rootId: branch.rootId,

package/dist/core/conversationKernel.d.ts

@@ -19,8 +19,12 @@ export interface ConversationQueueItemSnapshot {
     /** Exact workspace ledger branch id used when this row was admitted. */
     ledgerBranchId?: string;
     modelSelection?: string;
+    /** Ledger reason shown when a queued row cannot run (for example DEPENDENCY_FAILED). */
+    waitingReason?: string;
+    /** True when the ledger currently blocks this row from being claimed. */
+    blocked?: boolean;
 }
-export type ConversationQueueAction = 'enqueue' | 'update' | 'delete' | 'reorder' | 'toggle_pause' | 'set_pause' | 'guide';
+export type ConversationQueueAction = 'enqueue' | 'update' | 'delete' | 'reorder' | 'toggle_pause' | 'set_pause' | 'repair_blocked' | 'guide';
 export interface ConversationQueueActionInput {
     id?: string;
     text?: string;
@@ -303,6 +307,14 @@ export declare class ConversationKernel {
     deleteQueueItem(target: ConversationTargetInput, idInput: string): boolean;
     reorderQueueItems(target: ConversationTargetInput, orderedIdsInput: string[]): ConversationQueueItemSnapshot[];
     setQueuePaused(target: ConversationTargetInput, paused: boolean): boolean;
+    /**
+     * dev-0.6.4 hotfix: 显式修复被失败前置阻断的排队行。
+     *
+     * 0.6.3 的合约是「失败/取消阻断后继，且不静默跳过」，所以这里不挂在恢复动作上
+     * 自动执行；它必须由用户的显式动作触发（界面上的“修复受阻队列”按钮）。每一次
+     * 改挂都写入 `BuildQueueRepaired` 事件并发布可见状态，触发者与原因可审计。
+     */
+    private repairBlockedQueueNow;
     queueAction(target: ConversationTargetInput, action: ConversationQueueAction, input?: ConversationQueueActionInput): {
         ok: boolean;
         queueItems: ConversationQueueItemSnapshot[];

package/dist/core/conversationKernel.js

@@ -388,6 +388,23 @@ class ConversationKernel {
         const runtime = this.findRuntime(target);
         if (!runtime)
             return [];
+        // dev-0.6.4 hotfix: 把账本里的受阻原因带进队列投影，界面才能显示
+        // “被失败前置阻断”而不是无声卡住。
+        let waitingByBuildId = new Map();
+        const continuation = this.continuationStore(runtime);
+        if (continuation) {
+            try {
+                const snapshot = continuation.store.snapshot({
+                    workspaceId: continuation.workspaceId,
+                    rootId: continuation.rootId,
+                    branchId: continuation.branchId,
+                });
+                waitingByBuildId = new Map(snapshot.builds
+                    .filter(build => !!build.waitingReason)
+                    .map(build => [build.buildId, String(build.waitingReason)]));
+            }
+            catch { /* the projection stays usable without ledger diagnostics */ }
+        }
         return runtime.pendingNextTurn.flatMap(item => {
             if (item.queueMode !== 'followUp')
                 return [];
@@ -396,6 +413,7 @@ class ConversationKernel {
             const id = String(item.message.clientMessageId || '');
             if (!id)
                 return [];
+            const buildId = String(item.message.buildId || '');
             return [{
                     id,
                     buildId: item.message.buildId,
@@ -409,6 +427,8 @@ class ConversationKernel {
                     branchNodeId: item.message.branchNodeId,
                     branchPath: item.message.branchPath?.slice(),
                     modelSelection: item.message.modelSelection,
+                    waitingReason: waitingByBuildId.get(buildId),
+                    blocked: waitingByBuildId.has(buildId),
                 }];
         });
     }
@@ -484,6 +504,8 @@ class ConversationKernel {
         const ledgerBranchId = continuation?.branchId;
         let buildId = '';
         if (continuation) {
+            // 入队严格保持 0.6.3 语义：新命令接在当前队尾之后。被失败前置阻断的行不会
+            // 被静默跳过；用户可通过界面上的“修复受阻队列”显式动作重建可执行链。
             const authoritative = continuation.store.snapshot({
                 workspaceId: continuation.workspaceId,
                 rootId: continuation.rootId,
@@ -708,6 +730,10 @@ class ConversationKernel {
         return this.queueItems(runtime.target);
     }
     setQueuePaused(target, paused) {
+        // 队列策略只作用于已经存在的 runtime：在这里按需重建 runtime 会让空闲会话
+        // 重新变成“持有排队工作”的所有者，破坏工作区清理契约
+        // （`Cannot release a conversation with running or queued work`）。界面路径统一
+        // 走 queueAction，它已经负责按需创建 runtime。
         const runtime = this.findRuntime(target);
         if (!runtime)
             throw new Error('Target conversation runtime is unavailable');
@@ -720,6 +746,35 @@ class ConversationKernel {
         }
         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 (error) {
+            runtime.runner.recordWorkStatus(`Queue repair failed: ${error instanceof Error ? error.message : String(error)}`);
+            return 0;
+        }
+    }
     queueAction(target, action, input = {}) {
         const normalized = this.normalizeTarget(target);
         const runtime = this.findRuntime(normalized) || this.runtime(normalized, {
@@ -758,6 +813,10 @@ class ConversationKernel {
         else if (action === 'set_pause') {
             this.setQueuePaused(runtime.target, input.paused === true);
         }
+        else if (action === 'repair_blocked') {
+            // 显式修复：把被失败前置阻断的排队行重新挂到最后一个已提交 Build。
+            this.repairBlockedQueueNow(runtime);
+        }
         else if (action === 'guide') {
             if (input.text !== undefined)
                 this.updateQueueItem(runtime.target, String(input.id || ''), input.text, input);
@@ -1675,6 +1734,9 @@ class ConversationKernel {
                 && runtime.queued.followUp.length === 0
                 && runner.subagents.readRootInbox().length === 0;
         });
+        // 执行投影严格跟随当前激活分支节点：新分支绝不接管另一条分页的排队输入
+        // （dev-0.6.3 的既有契约）。界面上跨分页的排队行可见性由渲染层负责，
+        // 执行始终属于受理时捕获的那条分支。
         for (const continuation of runner.conversationContinuations()) {
             runtime.pendingNextTurn.push({
                 message: continuation.clientMessageId || continuation.images?.length || continuation.hiddenUserInput

package/dist/main.js

@@ -3123,7 +3123,7 @@ else {
             };
             const mutateConversationQueue = async (target, rawAction, input = {}) => {
                 const action = rawAction.replace(/^queue_/, '');
-                if (!['enqueue', 'update', 'delete', 'reorder', 'toggle_pause', 'set_pause', 'guide'].includes(action))
+                if (!['enqueue', 'update', 'delete', 'reorder', 'toggle_pause', 'set_pause', 'repair_blocked', 'guide'].includes(action))
                     throw new Error('Unknown queue action');
                 const key = activeFlowStateKey(target);
                 const flow = activeFlowStateFor(target);