baxian 2.0.16 → 2.0.18

package/dist/agent/manager.js

@@ -12,14 +12,14 @@ import { versionTimeOf } from '../platform/row-schema.js';
 import { checkOpenPrBinding, checkPrBinding } from '../platform/pr-binding.js';
 import { collectPendingFeedback, scanCommentSourcesOnce } from '../platform/feedback.js';
 import { prReviewCacheRevision } from '../platform/pr-conversation-cache.js';
-import { deadTokens, recheckPassProvenance } from '../platform/verdict-engine.js';
+import { deadTokens, liveVerdictVeto } from '../platform/verdict-engine.js';
 import { platformBindingMismatch, taskNeedsPlatformBindingAudit, } from '../platform/startup.js';
 import { AGENT_STORE_NOOP } from '../state/agent-store.js';
 import { createRunner, LocalRunner, shellQuote, resolveAgentHost, workdirHostGroupKey, } from './runner.js';
 import { isTransientNetworkFailure } from './net-exec.js';
 import { imageFilename, agentHostPath, writeImageToHost } from './image-input.js';
 import { TmuxManager, ReplNotReadyError, detectStartupDialog, detectRuntimeMenu, runtimeBusyCheck, hasRuntimeReadyView, hasReplProcTitle, isShellProcTitle, hasOscTitleWorking, hasOscTitleIdle, screenAllowsTitleIdle, PaneGoneError, } from './tmux.js';
-import { BranchManager, DirtyWorkdirError, ReviewHeadMismatchError, isAutoDeletableTaskBranch } from './branch.js';
+import { BranchManager, DirtyWorkdirError, ReviewHeadMismatchError, isAutoDeletableTaskBranch, } from './branch.js';
 import { RepoStore, createRepoStoreCache } from './repo-store.js';
 import { PhaseSignalWatcher, } from './phase-signal-watcher.js';
 import { buildPromptInline, buildGreetingPrompt, PromptSizeError, MAX_PROMPT_BYTES_ROUTE_LIMIT, } from './prompt.js';
@@ -45,7 +45,6 @@ function samePassProvenance(left, right) {
         && right !== undefined
         && left.sourceKey === right.sourceKey
         && left.id === right.id
-        && left.bodyDigest === right.bodyDigest
         && left.token === right.token
         && left.failToken === right.failToken
         && left.anchorSha === right.anchorSha;
@@ -150,6 +149,13 @@ const DEFAULT_NEED_INPUT_RETRY_INTERVAL_MS = 5_000;
 const DEFAULT_DISPATCH_SETTLE_TIMEOUT_MS = 3_000;
 const DELETE_CLEANUP_TIMEOUT_MS = 15_000;
 const PLATFORM_HEAD_SHA_RE = new RegExp(`^${SHA_HEX_SOURCE}$`);
+function branchCleanupIdentity(task) {
+    return {
+        taskId: task.id,
+        taskBranch: task.branch,
+        branchCreatedByBaxian: task.branchCreatedByBaxian,
+    };
+}
 function createSignalTokenExcluding(...excluded) {
     let token = createSignalToken();
     while (excluded.includes(token))
@@ -1701,9 +1707,7 @@ export class AgentManager {
                     }
                     const pendingAt = new Date().toISOString();
                     if (boundTask && cfg.role === 'dev') {
-                        boundTask.branchCleanupPending = { agentId, reason, updatedAt: pendingAt };
-                        boundTask.updatedAt = pendingAt;
-                        await this.taskStore.set(boundTask);
+                        await this.persistBranchCleanupOutcome(boundTask, agentId, { status: 'pending', reason });
                     }
                     let wrote = false;
                     await this.agentStore.update(agentId, (latest2) => {
@@ -1769,59 +1773,8 @@ export class AgentManager {
                     }
                     if (cfg.role === 'dev' && boundTask) {
                         const branches = new BranchManager(runner);
-                        const cleanup = await branches.cleanupTaskBranch(releaseWorkdir, {
-                            taskId: boundTask.id,
-                            taskBranch: boundTask.branch,
-                            branchCreatedByBaxian: boundTask.branchCreatedByBaxian,
-                        }, () => this.assertTaskGeneration(agentId, expectedTaskId, lockToken, releaseWorkdir).then(() => undefined));
-                        let cleanupStateChanged = false;
-                        if (cleanup.status === 'pending') {
-                            if (boundTask.branchCleanupPending?.agentId !== agentId
-                                || boundTask.branchCleanupPending.reason !== cleanup.reason
-                                || boundTask.branchCleanupSkipped !== undefined) {
-                                boundTask.branchCleanupPending = {
-                                    agentId,
-                                    reason: cleanup.reason,
-                                    updatedAt: new Date().toISOString(),
-                                };
-                                delete boundTask.branchCleanupSkipped;
-                                cleanupStateChanged = true;
-                            }
-                        }
-                        else if (cleanup.status === 'skipped') {
-                            if (boundTask.branchCleanupSkipped?.agentId !== agentId
-                                || boundTask.branchCleanupSkipped.reason !== cleanup.reason
-                                || boundTask.branchCleanupPending !== undefined) {
-                                boundTask.branchCleanupSkipped = {
-                                    agentId,
-                                    reason: cleanup.reason,
-                                    updatedAt: new Date().toISOString(),
-                                };
-                                delete boundTask.branchCleanupPending;
-                                cleanupStateChanged = true;
-                            }
-                        }
-                        else {
-                            if (boundTask.branchCleanupPending?.agentId === agentId) {
-                                delete boundTask.branchCleanupPending;
-                                cleanupStateChanged = true;
-                            }
-                            if (boundTask.branchCleanupSkipped?.agentId === agentId) {
-                                delete boundTask.branchCleanupSkipped;
-                                cleanupStateChanged = true;
-                            }
-                            if (cleanup.remoteTipSha) {
-                                boundTask.branchLocalCleaned = {
-                                    remoteTipSha: cleanup.remoteTipSha,
-                                    updatedAt: new Date().toISOString(),
-                                };
-                                cleanupStateChanged = true;
-                            }
-                        }
-                        if (cleanupStateChanged) {
-                            boundTask.updatedAt = new Date().toISOString();
-                            await this.taskStore.set(boundTask);
-                        }
+                        const cleanup = await branches.cleanupTaskBranch(releaseWorkdir, this.cleanupIdentityFor(boundTask), () => this.assertTaskGeneration(agentId, expectedTaskId, lockToken, releaseWorkdir).then(() => undefined));
+                        await this.persistBranchCleanupOutcome(boundTask, agentId, cleanup);
                         if (cleanup.status !== 'deleted')
                             await branches.parkOnDefaultDetached(releaseWorkdir);
                     }
@@ -1891,6 +1844,64 @@ export class AgentManager {
             console.warn(`[AgentManager] clearing branchLocalCleaned(${taskId}) failed:`, err);
         });
     }
+    cleanupIdentityFor(task) {
+        const identity = branchCleanupIdentity(task);
+        if (task.status === 'merged' && task.prNumber !== undefined) {
+            identity.resolveMergedHeadSha = () => this.platformFetchPrHeadSha(task.id);
+        }
+        return identity;
+    }
+    async persistBranchCleanupOutcome(task, agentId, cleanup, guard) {
+        await this.withTaskLock(async () => {
+            const latest = await this.taskStore.get(task.id);
+            if (!latest || latest.branch !== task.branch || (guard !== undefined && !guard(latest)))
+                return;
+            const effective = cleanup;
+            const now = new Date().toISOString();
+            let changed = false;
+            if (effective.status === 'pending') {
+                if (latest.branchCleanupPending?.agentId !== agentId
+                    || latest.branchCleanupPending.reason !== effective.reason
+                    || latest.branchCleanupSkipped !== undefined) {
+                    latest.branchCleanupPending = { agentId, reason: effective.reason, updatedAt: now };
+                    delete latest.branchCleanupSkipped;
+                    changed = true;
+                }
+                if (effective.remoteTipSha !== undefined
+                    && latest.branchLocalCleaned?.remoteTipSha !== effective.remoteTipSha) {
+                    latest.branchLocalCleaned = { remoteTipSha: effective.remoteTipSha, updatedAt: now };
+                    changed = true;
+                }
+            }
+            else if (effective.status === 'skipped') {
+                if (latest.branchCleanupSkipped?.agentId !== agentId
+                    || latest.branchCleanupSkipped.reason !== effective.reason
+                    || latest.branchCleanupPending !== undefined) {
+                    latest.branchCleanupSkipped = { agentId, reason: effective.reason, updatedAt: now };
+                    delete latest.branchCleanupPending;
+                    changed = true;
+                }
+            }
+            else {
+                if (latest.branchCleanupPending !== undefined) {
+                    delete latest.branchCleanupPending;
+                    changed = true;
+                }
+                if (latest.branchCleanupSkipped !== undefined) {
+                    delete latest.branchCleanupSkipped;
+                    changed = true;
+                }
+                if (effective.remoteTipSha) {
+                    latest.branchLocalCleaned = { remoteTipSha: effective.remoteTipSha, updatedAt: now };
+                    changed = true;
+                }
+            }
+            if (!changed)
+                return;
+            latest.updatedAt = now;
+            await this.taskStore.set(latest);
+        });
+    }
     async releaseAgentIfBound(agentId, expectedTaskId, opts) {
         const state = await this.agentStore.get(agentId);
         if (state?.taskId !== expectedTaskId)
@@ -1911,50 +1922,7 @@ export class AgentManager {
             && task.branchCleanupSkipped === undefined)
             .map(task => [task.branch, task]));
         const owner = 'maintenance:branch-reconcile';
-        const persistCleanup = async (task, agentId, cleanup) => {
-            await this.withTaskLock(async () => {
-                const latest = await this.taskStore.get(task.id);
-                if (!latest
-                    || latest.branch !== task.branch
-                    || latest.branchCreatedByBaxian !== true
-                    || !TERMINAL_STATUSES.includes(latest.status))
-                    return;
-                const now = new Date().toISOString();
-                let changed = false;
-                if (cleanup.status === 'pending') {
-                    if (latest.branchCleanupPending?.agentId !== agentId
-                        || latest.branchCleanupPending.reason !== cleanup.reason
-                        || latest.branchCleanupSkipped !== undefined) {
-                        latest.branchCleanupPending = { agentId, reason: cleanup.reason, updatedAt: now };
-                        delete latest.branchCleanupSkipped;
-                        changed = true;
-                    }
-                }
-                else if (cleanup.status === 'skipped') {
-                    if (latest.branchCleanupSkipped?.agentId !== agentId
-                        || latest.branchCleanupSkipped.reason !== cleanup.reason
-                        || latest.branchCleanupPending !== undefined) {
-                        latest.branchCleanupSkipped = { agentId, reason: cleanup.reason, updatedAt: now };
-                        delete latest.branchCleanupPending;
-                        changed = true;
-                    }
-                }
-                else {
-                    if (latest.branchCleanupPending !== undefined) {
-                        delete latest.branchCleanupPending;
-                        changed = true;
-                    }
-                    if (latest.branchCleanupSkipped !== undefined) {
-                        delete latest.branchCleanupSkipped;
-                        changed = true;
-                    }
-                }
-                if (!changed)
-                    return;
-                latest.updatedAt = now;
-                await this.taskStore.set(latest);
-            });
-        };
+        const persistCleanup = (task, agentId, cleanup) => this.persistBranchCleanupOutcome(task, agentId, cleanup, latest => latest.branchCreatedByBaxian === true && TERMINAL_STATUSES.includes(latest.status));
         for (const cfg of this.agentIndex.values()) {
             if (cfg.role !== 'dev')
                 continue;
@@ -1980,7 +1948,9 @@ export class AgentManager {
                     `${err instanceof Error ? err.message : String(err)}`);
                 continue;
             }
-            if (!refs.some(ref => candidateByBranch.has(ref.slice('refs/heads/'.length))))
+            const isTarget = (task, present) => present.has(task.branch) || task.branchCleanupPending !== undefined;
+            let present = new Set(refs.map(ref => ref.slice('refs/heads/'.length)));
+            if (!candidateTasks.some(task => isTarget(task, present)))
                 continue;
             if (this.isDeletionInFlight(cfg.id))
                 continue;
@@ -1988,6 +1958,7 @@ export class AgentManager {
             if (!token)
                 continue;
             const cleanupResults = [];
+            let targets = [];
             try {
                 if (!this.deletionGateOpen(cfg.id, genAtEntry))
                     continue;
@@ -1997,8 +1968,9 @@ export class AgentManager {
                 if (!(await this.lockManager.isOwner(cfg.id, owner, token)))
                     continue;
                 refs = await branches.listLocalTaskRefs(workdir);
-                refs = refs.filter(ref => candidateByBranch.has(ref.slice('refs/heads/'.length)));
-                if (refs.length === 0)
+                present = new Set(refs.map(ref => ref.slice('refs/heads/'.length)));
+                targets = [...candidateByBranch.values()].filter(task => isTarget(task, present));
+                if (targets.length === 0)
                     continue;
                 const tmux = new TmuxManager(runner);
                 if (await tmux.hasSession(cfg.id)) {
@@ -2007,16 +1979,8 @@ export class AgentManager {
                 }
                 if (!(await this.lockManager.isOwner(cfg.id, owner, token)))
                     continue;
-                for (const actualRef of refs) {
-                    const branch = actualRef.slice('refs/heads/'.length);
-                    const task = candidateByBranch.get(branch);
-                    if (!task)
-                        continue;
-                    const cleanup = await branches.cleanupTaskBranch(workdir, {
-                        taskId: task.id,
-                        taskBranch: task.branch,
-                        branchCreatedByBaxian: task.branchCreatedByBaxian,
-                    }, () => this.assertTaskLockOwner(cfg.id, owner, token));
+                for (const task of targets) {
+                    const cleanup = await branches.cleanupTaskBranch(workdir, this.cleanupIdentityFor(task), () => this.assertTaskLockOwner(cfg.id, owner, token));
                     cleanupResults.push({ task, cleanup });
                 }
             }
@@ -2026,10 +1990,7 @@ export class AgentManager {
                     await this.markAwaitingHuman(cfg.id, 'dirty-workdir', message, { expectedTaskId: null });
                 }
                 else if (err instanceof ReplNotReadyError || message.includes('stayed busy past')) {
-                    for (const actualRef of refs) {
-                        const task = candidateByBranch.get(actualRef.slice('refs/heads/'.length));
-                        if (!task)
-                            continue;
+                    for (const task of targets) {
                         cleanupResults.push({
                             task,
                             cleanup: {
@@ -5457,25 +5418,16 @@ export class AgentManager {
         const { task, driver } = await this.platformTaskAndDriver(taskId);
         if (task.prNumber === undefined)
             return { kind: 'provenance-invalid', reason: 'no bound PR' };
-        const provenance = task.passProvenance;
-        if (!provenance)
+        if (!task.passProvenance)
             return { kind: 'provenance-invalid', reason: 'no accepted pass provenance' };
         const scans = await this.platformScanComments(driver, task.prNumber);
-        const recheck = recheckPassProvenance({
-            token: provenance.token,
-            failToken: provenance.failToken,
-            anchorSha: provenance.anchorSha,
-            carrier: { sourceKey: provenance.sourceKey, id: provenance.id, bodyDigest: provenance.bodyDigest },
-        }, scans);
-        if (!recheck.ok) {
-            return recheck.reason === 'source-scan-incomplete'
-                ? { kind: 'retryable', reason: recheck.reason }
-                : { kind: 'provenance-invalid', reason: `provenance ${recheck.reason}` };
-        }
         const pending = collectPendingFeedback(scans);
         if (!pending.allSourcesOk)
             return { kind: 'retryable', reason: 'source scan incomplete' };
-        return { kind: 'valid', pendingCount: pending.pending.size };
+        const veto = liveVerdictVeto(task.passProvenance, scans);
+        if (veto)
+            return { kind: 'provenance-invalid', reason: `provenance ${veto}` };
+        return { kind: 'valid', pending: pending.pending };
     }
     async platformPendingFeedback(taskId) {
         const { task, driver } = await this.platformTaskAndDriver(taskId);
@@ -5508,24 +5460,14 @@ export class AgentManager {
             if (provenance.anchorSha.toLowerCase() !== opts.expectedHeadSha.toLowerCase()) {
                 throw new PlatformMergeRecheckError('provenance-invalid', `pass provenance anchors ${provenance.anchorSha}, not the merge head ${opts.expectedHeadSha}`);
             }
-            const scans = await this.platformScanComments(driver, prNumber);
-            const recheck = recheckPassProvenance({
-                token: provenance.token,
-                failToken: provenance.failToken,
-                anchorSha: provenance.anchorSha,
-                carrier: { sourceKey: provenance.sourceKey, id: provenance.id, bodyDigest: provenance.bodyDigest },
-            }, scans);
-            if (!recheck.ok) {
-                if (recheck.reason === 'source-scan-incomplete') {
-                    throw new Error('merge blocked: provenance source-scan-incomplete');
-                }
-                throw new PlatformMergeRecheckError('provenance-invalid', `provenance ${recheck.reason}`);
-            }
-            const pending = collectPendingFeedback(scans);
-            if (!pending.allSourcesOk)
+            const verified = await this.platformVerifyAcceptedPass(taskId);
+            if (verified.kind === 'retryable')
                 throw new Error('merge blocked: pending-feedback scan incomplete');
-            if (pending.pending.size > 0) {
-                throw new PlatformMergeRecheckError('pending-feedback', `${pending.pending.size} pending feedback revision(s) without ack`);
+            if (verified.kind === 'provenance-invalid') {
+                throw new PlatformMergeRecheckError('provenance-invalid', verified.reason);
+            }
+            if (verified.pending.size > 0) {
+                throw new PlatformMergeRecheckError('pending-feedback', `${verified.pending.size} pending feedback comment(s) without ack`);
             }
         }
         const fresh = await this.taskStore.get(taskId);
@@ -7329,6 +7271,7 @@ export class AgentManager {
                 ...(platform ? { platform } : {}),
                 ...(signalToken ? { signalToken } : {}),
                 ...(imagePaths.length ? { imagePaths } : {}),
+                ...(opts.pendingFeedback?.length ? { pendingFeedback: opts.pendingFeedback } : {}),
             });
         }
         catch (err) {
@@ -8417,7 +8360,7 @@ export class AgentManager {
         if (accepted.kind !== 'valid') {
             throw new ApiError(409, `Cannot restore task ${task.id}: ${accepted.reason}`);
         }
-        if (accepted.pendingCount > 0) {
+        if (accepted.pending.size > 0) {
             throw new ApiError(409, `Cannot restore task ${task.id}: the accepted pass has pending feedback`);
         }
         const reviewedPass = task.passProvenance;