baxian 2.0.3 → 2.0.4

package/dist/agent/manager.js

@@ -1,15 +1,18 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { randomBytes } from 'node:crypto';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { join, normalize } from 'node:path';
 import { tmpdir } from 'node:os';
 import { createSignalToken, PASSIVE_VERDICT_WATCH } from './phase-signal.js';
 import { tmuxInstallHint } from './preflight.js';
-import { BRANCH_PREFIX, isValidBranchName, PHASE_EXPECTED_STATUS, PHASE_REQUIRES_AGENT_BOUND_TO_TASK, TASK_TERMINAL_STATUSES as TERMINAL_STATUSES, TASK_ACTIVE_STATUS_SET as ACTIVE_TASK_STATUSES, TASK_OWNER_ROLES, effectiveTaskReviewRound, isSpecStagePhase, isTaskOpen, repoIdentityKey, taskGenerationGuard, taskReviewRound, taskMatchesGeneration, } from '../shared/index.js';
+import { BRANCH_PREFIX, isValidBranchName, PHASE_EXPECTED_STATUS, PHASE_REQUIRES_AGENT_BOUND_TO_TASK, TASK_TERMINAL_STATUSES as TERMINAL_STATUSES, TASK_ACTIVE_STATUS_SET as ACTIVE_TASK_STATUSES, TASK_OWNER_ROLES, effectiveTaskReviewRound, isSpecStagePhase, isTaskOpen, repoIdentityKey, taskAttentionGeneration, taskGenerationGuard, taskReviewRound, taskMatchesGeneration, } from '../shared/index.js';
 import { buildProjectDriver, makeDriverExec } from '../platform/driver-host.js';
 import { DriverOpError, buildDriverRunContext, GitDriver, safeDriverErrorText } from '../platform/git-driver.js';
+import { versionTimeOf } from '../platform/row-schema.js';
 import { checkOpenPrBinding, checkPrBinding } from '../platform/pr-binding.js';
 import { collectPendingFeedback, scanCommentSourcesOnce } from '../platform/feedback.js';
-import { recheckPassProvenance } from '../platform/verdict-engine.js';
+import { prReviewCacheRevision } from '../platform/pr-conversation-cache.js';
+import { deadTokens, recheckPassProvenance } from '../platform/verdict-engine.js';
 import { platformBindingMismatch, taskNeedsPlatformBindingAudit, } from '../platform/startup.js';
 import { AGENT_STORE_NOOP } from '../state/agent-store.js';
 import { SkillRegistry } from '../skill/registry.js';
@@ -27,6 +30,7 @@ import { resolveProjectTool } from '../config/validator.js';
 import { SHA_HEX_SOURCE } from '../platform/types.js';
 import { bodyDigest } from '../platform/body-digest.js';
 import { validateCommentBody } from '../platform/command-renderer.js';
+import { buildReviewTokenLine, extractReviewTokens, rowTokens } from '../platform/markers.js';
 const BENIGN_DISPATCH_CONFLICT_CODES = new Set(['dispatch-superseded', 'dispatch-in-flight']);
 export function isBenignDispatchConflict(err) {
     return err instanceof ApiError
@@ -39,6 +43,16 @@ function requireTaskQaAgentId(task, operation) {
         throw new Error(`${operation}: task ${task.id} has no QA participant`);
     return task.qaAgentId;
 }
+function samePassProvenance(left, right) {
+    return left !== undefined
+        && 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;
+}
 export class EnsureSessionError extends Error {
     partial;
     constructor(partial, message) {
@@ -226,6 +240,7 @@ export class AgentManager {
     paneStreamerManager;
     pluginRegistry;
     platformDefaultBranchOf;
+    prConversationCache;
     platformDriverExec;
     phaseSignalWatcher;
     errorRecordStore;
@@ -234,6 +249,7 @@ export class AgentManager {
     dispatchSettleTimeoutMs;
     dispatchAckResendIntervalMs = 3_000;
     taskMutationQueue = Promise.resolve();
+    taskMutationScope = new AsyncLocalStorage();
     agentOperationQueues = new Map();
     agentIndex;
     platformRunner;
@@ -254,6 +270,8 @@ export class AgentManager {
     cancelInterruptGuardWaitMs = DEFAULT_DISPATCH_ACK_TIMEOUT_MS + 5_000;
     markCompleteInFlight = new Set();
     specVerdictInFlight = new Set();
+    codeVerdictInFlight = new Set();
+    retryTaskInFlight = new Set();
     cancelCleanupInFlight = new Map();
     deletionInFlight = new Set();
     divergedAgents = new Set();
@@ -273,6 +291,7 @@ export class AgentManager {
         this.paneStreamerManager = deps.paneStreamerManager;
         this.pluginRegistry = deps.pluginRegistry;
         this.platformDefaultBranchOf = deps.platformDefaultBranchOf;
+        this.prConversationCache = deps.prConversationCache;
         this.errorRecordStore = deps.errorRecordStore;
         this.phaseSignalWatcher = deps.phaseSignalWatcher
             ?? (deps.paneStreamerManager
@@ -299,10 +318,26 @@ export class AgentManager {
         };
     }
     withTaskLock(fn) {
-        const next = this.taskMutationQueue.then(fn);
+        const inherited = this.taskMutationScope.getStore();
+        if (inherited?.active)
+            return fn();
+        const next = this.taskMutationQueue.then(() => {
+            const scope = { active: true };
+            return this.taskMutationScope.run(scope, async () => {
+                try {
+                    return await fn();
+                }
+                finally {
+                    scope.active = false;
+                }
+            });
+        });
         this.taskMutationQueue = next.catch(() => undefined);
         return next;
     }
+    outsideTaskMutationScope(fn) {
+        return this.taskMutationScope.exit(fn);
+    }
     withAgentOperationLease(agentId, fn) {
         const previous = this.agentOperationQueues.get(agentId) ?? Promise.resolve();
         const next = previous.then(fn);
@@ -365,7 +400,7 @@ export class AgentManager {
             return true;
         }
         catch (err) {
-            console.warn(`[AgentManager] safeEmit ${event.type} failed (audit log loss; state machine unaffected):`, err);
+            console.warn(`[AgentManager] safeEmit ${event.type} failed; persistence or handler delivery may be incomplete:`, err);
             return false;
         }
     }
@@ -911,7 +946,7 @@ export class AgentManager {
                     }
                 }
                 await this.markDialogPending(agentId, creationToken);
-                void this.slowPollDialogPending(agentId, creationToken).catch((pollErr) => {
+                void this.outsideTaskMutationScope(() => this.slowPollDialogPending(agentId, creationToken)).catch((pollErr) => {
                     console.warn(`[bootstrap] slowPoll for ${agentId} crashed:`, pollErr);
                 });
                 return;
@@ -1184,10 +1219,10 @@ export class AgentManager {
         err.partial.handled = true;
         const snapshotPaneId = state.paneId;
         const snapshotTaskId = state.taskId;
-        void this.slowPollDialogPending(agentId, state.creationToken, {
+        void this.outsideTaskMutationScope(() => this.slowPollDialogPending(agentId, state.creationToken, {
             ...(snapshotPaneId !== undefined ? { expectedPaneId: snapshotPaneId } : {}),
             expectedTaskId: snapshotTaskId,
-        }).catch((pollErr) => {
+        })).catch((pollErr) => {
             console.warn(`[runtime] slowPoll for ${agentId} crashed:`, pollErr);
         });
         return true;
@@ -1255,6 +1290,7 @@ export class AgentManager {
                 return;
             const now = new Date().toISOString();
             let projectIdForEmit = '';
+            let taskIdForEmit;
             let wrote = false;
             const isBootstrapPath = creationToken !== undefined;
             if (isBootstrapPath && !(await this.runGreetingHandshake(agentId, cfg, pane))) {
@@ -1270,6 +1306,7 @@ export class AgentManager {
                     return AGENT_STORE_NOOP;
                 }
                 projectIdForEmit = fresh.projectId;
+                taskIdForEmit = fresh.taskId;
                 wrote = true;
                 if (isBootstrapPath) {
                     return {
@@ -1283,11 +1320,15 @@ export class AgentManager {
                         updatedAt: now,
                     };
                 }
+                const awaitingReason = fresh.taskId
+                    ? `Runtime dialog resolved; agent REPL ready. Open task ${fresh.taskId}: cancel it if it is still active, ` +
+                        'otherwise Resume can release the binding; Delete the agent if the binding cannot be recovered.'
+                    : 'Runtime dialog resolved; agent REPL ready. Click Resume to release the binding and let baxian pick the next task.';
                 return {
                     ...fresh,
                     paneId,
                     awaitingPhase: 'agent_dialog_resolved_runtime',
-                    awaitingReason: 'Runtime dialog resolved; agent REPL ready. Click Resume to release the binding and let baxian pick the next task.',
+                    awaitingReason,
                     updatedAt: now,
                 };
             });
@@ -1304,9 +1345,13 @@ export class AgentManager {
                 });
             }
             else {
-                await this.emitIntervention(projectIdForEmit, agentId, undefined, {
+                const note = taskIdForEmit
+                    ? `Runtime dialog resolved; agent REPL ready. Open task ${taskIdForEmit}: cancel it if it is still active, ` +
+                        'otherwise Resume can release the binding; Delete the agent if the binding cannot be recovered.'
+                    : 'Runtime dialog resolved; agent REPL ready. Click Resume to continue.';
+                await this.emitIntervention(projectIdForEmit, agentId, taskIdForEmit, {
                     phase: 'agent_dialog_resolved_runtime',
-                    note: 'Runtime dialog resolved; agent REPL ready. Click Resume to continue.',
+                    note,
                 });
             }
             return;
@@ -1317,7 +1362,7 @@ export class AgentManager {
             return;
         const controller = new AbortController();
         this.runtimeMenuWatchers.set(agentId, controller);
-        void this.runtimeMenuWatchLoop(agentId, controller.signal)
+        void this.outsideTaskMutationScope(() => this.runtimeMenuWatchLoop(agentId, controller.signal))
             .catch((err) => {
             console.warn(`[runtimeMenuWatch] ${agentId} loop crashed:`, err);
         })
@@ -1378,6 +1423,10 @@ export class AgentManager {
             }
             else if (!onMenu && pendingMenu) {
                 pendingMenu = false;
+                await this.emitIntervention(fresh.projectId, agentId, fresh.taskId, {
+                    phase: 'agent_runtime_menu_resolved',
+                    previousPhase: 'agent_runtime_menu_pending',
+                });
             }
         }
     }
@@ -2272,7 +2321,7 @@ export class AgentManager {
         if (this.needInputRetryTimer)
             return;
         this.needInputRetryTimer = setInterval(() => {
-            void this.needInputRetryPass();
+            void this.outsideTaskMutationScope(() => this.needInputRetryPass());
         }, this.needInputRetryIntervalMs);
         this.needInputRetryTimer.unref?.();
     }
@@ -2464,13 +2513,13 @@ export class AgentManager {
         if (wm !== null && bumped && mode === 'restore') {
             const delta = this.collectPredecessorNeedInputDelta(args.agentId, args.taskId, wm.epoch);
             if (delta) {
-                void this.commitNeedInputWatermark({
+                void this.outsideTaskMutationScope(() => this.commitNeedInputWatermark({
                     agentId: args.agentId,
                     taskId: args.taskId,
                     epoch: wm.epoch,
                     askSeq: Math.max(delta.askSeq, wm.askSeq),
                     answeredSeq: Math.max(delta.answeredSeq, wm.answeredSeq),
-                });
+                }));
             }
         }
         try {
@@ -3762,8 +3811,8 @@ export class AgentManager {
         const project = this.getProjectConfig(cfg.projectId);
         if (!project)
             throw new Error(`Unknown project: ${cfg.projectId}`);
-        const group = this.findAgentGroup(agentId);
-        return { targets: group?.map(agent => agent.id) ?? [agentId] };
+        const team = this.findAgentTeam(agentId);
+        return { targets: team?.map(agent => agent.id) ?? [agentId] };
     }
     async cleanupRemovedAgentRuntime(targets) {
         const failures = [];
@@ -3862,13 +3911,13 @@ export class AgentManager {
         const now = new Date().toISOString();
         if (cfg.role !== 'dev')
             throw new Error(`Agent ${cfg.id} is not a dev agent`);
-        const group = this.findAgentGroup(cfg.id);
+        const team = this.findAgentTeam(cfg.id);
         const devAgentId = cfg.id;
         const qaAgentId = input.preferredAgentId === ''
             ? '_unassigned_preview_qa'
-            : group?.find(agent => agent.role === 'qa')?.id;
+            : team?.find(agent => agent.role === 'qa')?.id;
         if (!qaAgentId)
-            throw new Error(`Agent ${cfg.id} has no qa agent in its group`);
+            throw new Error(`Agent ${cfg.id} has no qa agent in its Agent Team`);
         const fakeTask = {
             id: 'task-9999999999',
             projectId,
@@ -3910,11 +3959,11 @@ export class AgentManager {
             return undefined;
         return buildProjectDriver(project, this.pluginRegistry, this.platformDriverExec);
     }
-    findAgentGroup(anchorAgentId) {
+    findAgentTeam(anchorAgentId) {
         for (const project of this.config.project) {
-            for (const group of project.agent) {
-                if (group.some(agent => agent.id === anchorAgentId))
-                    return group;
+            for (const team of project.agent) {
+                if (team.some(agent => agent.id === anchorAgentId))
+                    return team;
             }
         }
         return undefined;
@@ -3925,8 +3974,8 @@ export class AgentManager {
             return undefined;
         let longest;
         let longestBytes = -1;
-        for (const pair of project.agent) {
-            for (const a of pair) {
+        for (const team of project.agent) {
+            for (const a of team) {
                 if (a.role !== 'dev' || !a.workdir)
                     continue;
                 const bytes = Buffer.byteLength(a.workdir, 'utf8');
@@ -3941,6 +3990,99 @@ export class AgentManager {
     async getTask(taskId) {
         return this.taskStore.get(taskId);
     }
+    async recordTaskAttention(event) {
+        if (!event.taskId)
+            return;
+        await this.withTaskLock(async () => {
+            const task = await this.taskStore.get(event.taskId);
+            if (!task)
+                return;
+            const reasonValue = typeof event.data.phase === 'string'
+                ? event.data.phase
+                : typeof event.data.reason === 'string'
+                    ? event.data.reason
+                    : 'human-intervention';
+            const reason = reasonValue.trim() || 'human-intervention';
+            const previousPhase = typeof event.data.previousPhase === 'string'
+                ? event.data.previousPhase.trim()
+                : '';
+            const clearedReason = reason === 'mr-reopened'
+                ? 'mr-closed-unmerged'
+                : reason === 'resumed'
+                    || reason === 'git-review-dispatch-hold-cleared'
+                    || reason === 'agent_runtime_menu_resolved'
+                    ? previousPhase
+                    : '';
+            if (clearedReason) {
+                if (task.attention?.reason !== clearedReason
+                    || Date.parse(event.timestamp) < Date.parse(task.attention.occurredAt))
+                    return;
+                const next = { ...task, updatedAt: new Date().toISOString() };
+                delete next.attention;
+                await this.taskStore.set(next);
+                return;
+            }
+            if (reason === 'resumed'
+                || reason === 'git-review-dispatch-hold-cleared'
+                || reason === 'agent_runtime_menu_resolved')
+                return;
+            const runbookValue = [
+                event.data.note,
+                event.data.recommendation,
+                event.data.message,
+                event.data.error,
+                ...(typeof event.data.phase === 'string' ? [event.data.reason] : []),
+            ]
+                .find(value => typeof value === 'string' && value.trim() !== '');
+            const runbook = typeof runbookValue === 'string'
+                ? runbookValue.trim()
+                : `Task ${task.id} requires human intervention for ${reason}. Inspect the task and its linked agent before choosing an action.`;
+            const occurredAt = Number.isFinite(Date.parse(event.timestamp))
+                ? event.timestamp
+                : new Date().toISOString();
+            const generation = taskAttentionGeneration(task);
+            let recommendedActions;
+            if (task.status === 'max_rounds') {
+                recommendedActions = ['verdict', 'cancel'];
+            }
+            else if (TERMINAL_STATUSES.includes(task.status)) {
+                recommendedActions = task.remoteCleanup !== undefined
+                    && task.remoteCleanup.stage !== 'manual'
+                    ? ['cancel']
+                    : ['retry'];
+            }
+            else if (task.status === 'review') {
+                recommendedActions = isSpecStagePhase(task.phase)
+                    ? ['advance', 'cancel']
+                    : ['advance', 'verdict', 'cancel'];
+            }
+            else if (task.status === 'spec-ready' || task.status === 'merge-ready') {
+                recommendedActions = ['verdict', 'cancel'];
+            }
+            else {
+                recommendedActions = ['advance', 'cancel'];
+            }
+            if (task.attention
+                && Date.parse(task.attention.occurredAt) > Date.parse(occurredAt))
+                return;
+            if (task.attention
+                && task.attention.reason === reason
+                && task.attention.runbook === runbook
+                && Date.parse(task.attention.occurredAt) >= Date.parse(occurredAt))
+                return;
+            await this.taskStore.set({
+                ...task,
+                attention: {
+                    reason,
+                    runbook,
+                    occurredAt,
+                    recommendedActions,
+                    generation,
+                },
+                updatedAt: new Date().toISOString(),
+            });
+        });
+    }
     async getAgentState(agentId) {
         return this.agentStore.get(agentId);
     }
@@ -4027,15 +4169,30 @@ export class AgentManager {
             delete next.reviewDispatch;
             delete next.reviewRoundPending;
         }
-        if (nextStatus !== task.status && next.outbox) {
-            const outbox = next.outbox.filter(entry => entry.type !== 'git.spec-verdict');
-            if (outbox.length > 0)
-                next.outbox = outbox;
-            else
-                delete next.outbox;
-        }
+        if (nextStatus !== task.status)
+            this.stripGitVerdictOutbox(next);
         return next;
     }
+    stripGitVerdictOutbox(task) {
+        if (!task.outbox)
+            return;
+        const outbox = task.outbox.filter(entry => entry.type !== 'git.spec-verdict' && entry.type !== 'git.code-verdict');
+        if (outbox.length > 0)
+            task.outbox = outbox;
+        else
+            delete task.outbox;
+    }
+    stripCodeVerdictOutboxForAnchor(task, anchorSha) {
+        if (!task.outbox)
+            return;
+        const normalizedAnchor = anchorSha.toLowerCase();
+        const outbox = task.outbox.filter(entry => entry.type !== 'git.code-verdict'
+            || entry.data.anchorSha.toLowerCase() === normalizedAnchor);
+        if (outbox.length > 0)
+            task.outbox = outbox;
+        else
+            delete task.outbox;
+    }
     async confirmPostApprovePromptDelivered(taskId, expected) {
         await this.withTaskLock(async () => {
             const task = await this.taskStore.get(taskId);
@@ -4229,6 +4386,9 @@ export class AgentManager {
     specVerdictOutbox(task) {
         return task.outbox?.find((entry) => entry.type === 'git.spec-verdict');
     }
+    codeVerdictOutbox(task) {
+        return task.outbox?.find((entry) => entry.type === 'git.code-verdict');
+    }
     async mutateTaskOutboxEntry(taskId, key, mutate) {
         return this.withTaskLock(async () => {
             const task = await this.taskStore.get(taskId);
@@ -4258,6 +4418,10 @@ export class AgentManager {
                     await this.deliverSpecVerdictOutbox(taskId, entry.key);
                     continue;
                 }
+                if (entry.type === 'git.code-verdict') {
+                    await this.deliverCodeVerdictOutbox(taskId, entry.key);
+                    continue;
+                }
                 await this.eventBus.emit({
                     id: `outbox:${entry.key}`,
                     type: 'human.intervention',
@@ -4379,6 +4543,10 @@ export class AgentManager {
                 return null;
             if (Object.hasOwn(opts, 'expectPhase') && current.phase !== opts.expectPhase)
                 return null;
+            if (current.status === 'review'
+                && current.reviewHeadAnchorSha?.toLowerCase() === opts.headSha.toLowerCase()
+                && this.codeVerdictOutbox(current) !== undefined)
+                return null;
             if (opts.patch?.branch && opts.patch.branch !== current.branch) {
                 const existing = await this.findTaskByBranch(opts.patch.branch, current.projectId);
                 if (existing && existing.id !== taskId)
@@ -4399,6 +4567,7 @@ export class AgentManager {
                 ? 'review'
                 : 'recheck');
             const next = this.stripPostApproveEpisodeFields(current);
+            this.stripGitVerdictOutbox(next);
             delete next.passProvenance;
             Object.assign(next, opts.patch ?? {}, {
                 status: 'review',
@@ -4468,6 +4637,7 @@ export class AgentManager {
                 return null;
             const now = new Date().toISOString();
             const next = this.stripPostApproveEpisodeFields(current);
+            this.stripGitVerdictOutbox(next);
             delete next.reviewDispatch;
             delete next.reviewRoundPending;
             const postApproveGeneration = createSignalToken();
@@ -4567,6 +4737,7 @@ export class AgentManager {
                 },
                 updatedAt: now,
             };
+            this.stripCodeVerdictOutboxForAnchor(next, verifiedHeadSha);
             await this.taskStore.set(next);
             if (qaHold !== undefined) {
                 const cleared = await this.clearAwaitingHuman(qaId, {
@@ -4612,6 +4783,9 @@ export class AgentManager {
             }
             next.reviewDispatchedAt = now;
             delete next.reviewDispatch;
+            if (next.attention?.reason === 'git-review-dispatch-recovery-uncertain') {
+                delete next.attention;
+            }
             await this.taskStore.set(next);
             return true;
         });
@@ -5100,20 +5274,28 @@ export class AgentManager {
             return next;
         });
     }
-    async noteReviewConversationRevision(taskId) {
+    async noteReviewConversationRevision(taskId, conversation) {
         await this.withTaskLock(async () => {
             const task = await this.taskStore.get(taskId);
             if (!task || TERMINAL_STATUSES.includes(task.status))
                 return;
             const now = new Date().toISOString();
-            await this.taskStore.set({ ...task, reviewConversationUpdatedAt: now, updatedAt: now });
+            const next = { ...task, reviewConversationUpdatedAt: now, updatedAt: now };
+            const repoKey = next.platformBinding?.repoKey;
+            if (conversation !== undefined
+                && this.prConversationCache !== undefined
+                && repoKey !== undefined
+                && next.prNumber === conversation.prNumber) {
+                this.prConversationCache.put(next.id, prReviewCacheRevision(next, repoKey), conversation.payload, next.reviewConversationUpdatedAt ?? '');
+            }
+            await this.taskStore.set(next);
         });
     }
     assertPlatformBinding(task) {
         const mismatch = platformBindingMismatch(this.config, task);
         if (mismatch === undefined)
             return;
-        void this.emitPlatformBindingIntervention(task, mismatch);
+        void this.outsideTaskMutationScope(() => this.emitPlatformBindingIntervention(task, mismatch));
         if (mismatch.reason === 'missing-binding-snapshot') {
             throw new Error(`platform binding missing for task ${task.id}; refusing platform operations`);
         }
@@ -5650,8 +5832,12 @@ export class AgentManager {
                 return null;
             if (task.prNumber !== undefined && task.prNumber !== observation.prNumber)
                 return null;
+            const repairsDeliveryConfirmation = confirmation?.source === 'human'
+                && (task.status === 'review' || task.status === 'fixing')
+                && Object.hasOwn(confirmation, 'expectedSignalToken');
             if (confirmation !== undefined) {
                 if (task.status !== 'in_progress'
+                    && !repairsDeliveryConfirmation
                     && (task.phase !== confirmation.phase
                         || task.deliveryConfirmation?.phase !== confirmation.phase))
                     return null;
@@ -5678,7 +5864,7 @@ export class AgentManager {
                 ...(confirmation !== undefined
                     ? {
                         phase: confirmation.phase,
-                        deliveryConfirmation: task.status === 'in_progress'
+                        deliveryConfirmation: task.status === 'in_progress' || repairsDeliveryConfirmation
                             ? { phase: confirmation.phase, source: confirmation.source, at: now }
                             : task.deliveryConfirmation,
                         ...(confirmation.branch !== undefined ? { branch: confirmation.branch } : {}),
@@ -5930,13 +6116,13 @@ export class AgentManager {
             }
             const genAtEntry = this.deletionGenerationOf(input.preferredAgentId);
             const target = await this.pickAgent(projectId, input.preferredAgentId);
-            const group = this.findAgentGroup(input.preferredAgentId);
-            const dev = group?.find(agent => agent.role === 'dev');
+            const team = this.findAgentTeam(input.preferredAgentId);
+            const dev = team?.find(agent => agent.role === 'dev');
             if (!dev)
-                throw new ApiError(409, `Agent ${input.preferredAgentId} has no dev agent in its group`);
-            const qa = group?.find(agent => agent.role === 'qa');
+                throw new ApiError(409, `Agent ${input.preferredAgentId} has no dev agent in its Agent Team`);
+            const qa = team?.find(agent => agent.role === 'qa');
             if (!qa)
-                throw new ApiError(409, `Agent ${input.preferredAgentId} has no qa agent in its group`);
+                throw new ApiError(409, `Agent ${input.preferredAgentId} has no qa agent in its Agent Team`);
             const participantGens = new Map([dev.id, qa.id]
                 .map(id => [id, this.deletionGenerationOf(id)]));
             const participantsFresh = () => this.deletionGenerationOf(input.preferredAgentId) === genAtEntry
@@ -5951,7 +6137,7 @@ export class AgentManager {
             };
             const persistQueuedOrReject = (reason) => {
                 if (!participantsFresh()) {
-                    throw new ApiError(409, `Agent ${input.preferredAgentId} or a group member is being deleted or recreated during task creation; please retry`);
+                    throw new ApiError(409, `Agent ${input.preferredAgentId} or an Agent Team member is being deleted or recreated during task creation; please retry`);
                 }
                 return this.persistQueuedTask(queued, reason, input.preferredAgentId);
             };
@@ -6061,6 +6247,9 @@ export class AgentManager {
     }
     async createAndStartTask(projectId, input, opts = {}) {
         const task = await this.createTask(projectId, input);
+        return this.startCreatedTask(task, opts);
+    }
+    async startCreatedTask(task, opts = {}) {
         if (task.status === 'in_progress' && task.agentId) {
             const signalToken = createSignalToken();
             await this.updateTask(task.id, this.dispatchTokenFields(signalToken));
@@ -6238,7 +6427,7 @@ export class AgentManager {
             await tmux.sendKeysLiteral(pane, command);
             await tmux.sendEnter(pane);
             guardHandedOff = true;
-            void this.waitForReplPromptReady(tmux, pane, cfg.runtime, this.compactIdleWaitMs)
+            void this.outsideTaskMutationScope(() => this.waitForReplPromptReady(tmux, pane, cfg.runtime, this.compactIdleWaitMs))
                 .catch(err => {
                 console.warn(`[AgentManager] sendSlashCommand(${agentId}, ${command}) post idle wait failed:`, err);
             })
@@ -6281,6 +6470,16 @@ export class AgentManager {
     clearPendingDispatchRetry(taskId) {
         this.pendingDispatchRetryByTask.delete(taskId);
     }
+    resetPendingDispatchRetryBudget(taskId) {
+        const entry = this.pendingDispatchRetryByTask.get(taskId);
+        if (!entry)
+            return;
+        this.pendingDispatchRetryByTask.set(taskId, {
+            ...entry,
+            since: Date.now(),
+            budgetAlerted: undefined,
+        });
+    }
     clearPendingDispatchRetryIfMatches(taskId, expected) {
         const entry = this.pendingDispatchRetryByTask.get(taskId);
         if (entry?.agentId === expected.agentId && entry.signalToken === expected.signalToken) {
@@ -6450,20 +6649,20 @@ export class AgentManager {
             }
             const now = new Date().toISOString();
             const initiallyUnassigned = fresh.preferredAgentId === '';
-            const group = initiallyUnassigned ? this.findAgentGroup(agentId) : undefined;
+            const team = initiallyUnassigned ? this.findAgentTeam(agentId) : undefined;
             const devId = initiallyUnassigned
-                ? group?.find(agent => agent.role === 'dev')?.id
+                ? team?.find(agent => agent.role === 'dev')?.id
                 : fresh.devAgentId;
             if (!devId) {
                 await this.lockManager.releaseIfOwner(agentId, taskId, lockToken);
-                return { task: fresh, errorCode: 409, error: `Agent ${agentId} has no dev agent in its group` };
+                return { task: fresh, errorCode: 409, error: `Agent ${agentId} has no dev agent in its Agent Team` };
             }
             const qaId = initiallyUnassigned
-                ? group?.find(agent => agent.role === 'qa')?.id
+                ? team?.find(agent => agent.role === 'qa')?.id
                 : fresh.qaAgentId;
             if (!qaId) {
                 await this.lockManager.releaseIfOwner(agentId, taskId, lockToken);
-                return { task: fresh, errorCode: 409, error: `Agent ${agentId} has no qa agent in its group` };
+                return { task: fresh, errorCode: 409, error: `Agent ${agentId} has no qa agent in its Agent Team` };
             }
             const participantGens = new Map([devId, qaId]
                 .map(pid => [pid, this.deletionGenerationOf(pid)]));
@@ -7780,10 +7979,10 @@ export class AgentManager {
                     if (await this.rollbackUndeliveredBootstrap(state))
                         continue;
                     await this.markDialogPending(state.id, state.creationToken);
-                    void this.slowPollDialogPending(state.id, state.creationToken, {
+                    void this.outsideTaskMutationScope(() => this.slowPollDialogPending(state.id, state.creationToken, {
                         ...(state.paneId !== undefined ? { expectedPaneId: state.paneId } : {}),
                         expectedTaskId: state.taskId,
-                    }).catch((pollErr) => {
+                    })).catch((pollErr) => {
                         console.warn(`[recover] slowPoll for ${state.id} crashed:`, pollErr);
                     });
                     continue;
@@ -8369,6 +8568,169 @@ export class AgentManager {
             return dispatched;
         }
     }
+    async advanceTask(taskId, opts = {}) {
+        let task = await this.taskStore.get(taskId);
+        if (!task)
+            throw new ApiError(404, `Task ${taskId} not found`);
+        const executor = opts.executor ?? (task.status === 'review' ? 'qa' : 'dev');
+        let updated;
+        if (task.status === 'pending') {
+            if (executor !== 'dev')
+                throw new ApiError(409, 'Pending tasks can only advance to Dev');
+            const result = await this.dispatchPendingTask(taskId, opts.agentId);
+            if (result.errorCode !== undefined)
+                throw new ApiError(result.errorCode, result.error ?? 'Dispatch failed');
+            if (!result.task)
+                throw new ApiError(404, `Task ${taskId} disappeared during dispatch`);
+            updated = result.task;
+        }
+        else if (executor === 'qa') {
+            if (task.status !== 'in_progress' && task.status !== 'fixing' && task.status !== 'review') {
+                throw new ApiError(409, `Task ${taskId} cannot advance to QA from ${task.status}`);
+            }
+            updated = await this.dispatchReviewToQa(taskId, {
+                fromStatus: [task.status],
+                confirmUncertainNotDelivered: true,
+                ...(opts.stage !== undefined ? { stage: opts.stage } : {}),
+                ...(opts.actorId !== undefined ? { actorId: opts.actorId } : {}),
+                ...(opts.prNumber !== undefined ? { prNumber: opts.prNumber } : {}),
+            });
+        }
+        else if (task.status === 'review') {
+            throw new ApiError(409, 'Review cannot advance to Dev without a request-changes verdict');
+        }
+        else if (task.status === 'in_progress' || task.status === 'fixing') {
+            if (!task.devAgentId)
+                throw new ApiError(409, `Task ${taskId} has no Dev participant`);
+            const replayed = await this.redispatchTaskPromptAfterReplRestart(task.devAgentId, taskId);
+            if (!replayed)
+                throw new ApiError(409, `Task ${taskId} changed or its Dev prompt could not be replayed`);
+            updated = (await this.taskStore.get(taskId)) ?? task;
+        }
+        else if (task.status === 'approved') {
+            if (!task.devAgentId)
+                throw new ApiError(409, `Task ${taskId} has no Dev participant`);
+            if (task.postApproveRevoked) {
+                if (opts.confirmRevoked !== true) {
+                    throw new ApiError(409, `Task ${taskId} post-approve replay is revoked; confirmRevoked=true is required`);
+                }
+                task = await this.restoreRevokedPostApprove(task);
+            }
+            const replayed = await this.redispatchTaskPromptAfterReplRestart(task.devAgentId, taskId);
+            if (!replayed)
+                throw new ApiError(409, `Task ${taskId} changed or its post-approve prompt could not be replayed`);
+            updated = (await this.taskStore.get(taskId)) ?? task;
+        }
+        else {
+            throw new ApiError(409, `Task ${taskId} cannot be advanced from ${task.status}`);
+        }
+        await this.auditHumanTaskOperation(updated, 'advance', executor, opts.note);
+        return updated;
+    }
+    async restoreRevokedPostApprove(task) {
+        if (!task.postApproveRevoked || task.prNumber === undefined) {
+            throw new ApiError(409, `Task ${task.id} has no revoked post-approve episode`);
+        }
+        const [binding, accepted] = await Promise.all([
+            this.platformVerifyPrBinding(task.id, task.prNumber),
+            this.platformVerifyAcceptedPass(task.id),
+        ]);
+        if (!binding.ok) {
+            throw new ApiError(409, `Cannot restore task ${task.id}: PR binding ${binding.reason}`);
+        }
+        if (accepted.kind !== 'valid') {
+            throw new ApiError(409, `Cannot restore task ${task.id}: ${accepted.reason}`);
+        }
+        if (accepted.pendingCount > 0) {
+            throw new ApiError(409, `Cannot restore task ${task.id}: the accepted pass has pending feedback`);
+        }
+        const reviewedPass = task.passProvenance;
+        if (!reviewedPass || binding.headSha.toLowerCase() !== reviewedPass.anchorSha.toLowerCase()) {
+            throw new ApiError(409, `Cannot restore task ${task.id}: the current PR head is not the accepted head`);
+        }
+        return this.withTaskLock(async () => {
+            const fresh = await this.taskStore.get(task.id);
+            if (!fresh || fresh.status !== 'approved'
+                || fresh.postApproveRevoked?.generation !== task.postApproveRevoked.generation
+                || fresh.prNumber !== task.prNumber
+                || !samePassProvenance(fresh.passProvenance, reviewedPass)) {
+                throw new ApiError(409, `Task ${task.id} changed while restoring post-approve replay`);
+            }
+            const generation = createSignalToken();
+            const token = createSignalTokenExcluding(generation);
+            const next = {
+                ...this.stripPostApproveEpisodeFields(fresh),
+                postApproveGeneration: generation,
+                postApproveHeadSha: binding.headSha,
+                postApproveToken: token,
+                postApprovePhase: 'installed',
+                pendingRedispatch: true,
+                redispatchCount: 0,
+                updatedAt: new Date().toISOString(),
+            };
+            await this.taskStore.set(next);
+            return next;
+        });
+    }
+    async submitTaskVerdict(taskId, action, comments, note) {
+        const task = await this.taskStore.get(taskId);
+        if (!task)
+            throw new ApiError(404, `Task ${taskId} not found`);
+        let updated;
+        if (task.status === 'spec-ready'
+            || (task.status === 'max_rounds' && isSpecStagePhase(task.phase))) {
+            if (action !== 'approve' && action !== 'request-changes') {
+                throw new ApiError(409, `Task ${taskId} requires a spec approve or request-changes verdict`);
+            }
+            updated = await this.submitSpecVerdict(taskId, action, comments);
+        }
+        else if (task.status === 'review' && !isSpecStagePhase(task.phase)) {
+            if (action !== 'pass' && action !== 'request-changes') {
+                throw new ApiError(409, `Task ${taskId} requires a code pass or request-changes verdict`);
+            }
+            updated = await this.submitCodeVerdict(taskId, action, comments);
+        }
+        else if (task.status === 'max_rounds') {
+            if (action === 'continue')
+                updated = await this.continueDevRound(taskId);
+            else if (action === 'complete')
+                updated = await this.markTaskComplete(taskId);
+            else
+                throw new ApiError(409, `Task ${taskId} requires continue or complete at code max_rounds`);
+        }
+        else if (task.status === 'merge-ready') {
+            if (action !== 'confirm-merge') {
+                throw new ApiError(409, `Task ${taskId} requires confirm-merge`);
+            }
+            updated = await this.markTaskComplete(taskId);
+        }
+        else {
+            throw new ApiError(409, `Task ${taskId} cannot accept a verdict from ${task.status}`);
+        }
+        await this.auditHumanTaskOperation(updated, 'verdict', action, note);
+        return updated;
+    }
+    async auditHumanTaskOperation(task, operation, action, note, details = {}) {
+        const emitted = await this.safeEmit({
+            id: '',
+            type: 'task.updated',
+            timestamp: new Date().toISOString(),
+            projectId: task.projectId,
+            ...(task.agentId ? { agentId: task.agentId } : {}),
+            taskId: task.id,
+            data: {
+                ...details,
+                operation,
+                action,
+                actor: 'human',
+                provenance: 'human',
+                note: note?.trim() || `${operation}:${action}`,
+            },
+        });
+        if (!emitted) {
+            throw new ApiError(500, `Task ${task.id} ${operation} completed, but its audit event could not be persisted; verify the task state before retrying`);
+        }
+    }
     async dispatchGitFixToDev(taskId) {
         const task = await this.taskStore.get(taskId);
         if (!task || task.status !== 'fixing')
@@ -8461,7 +8823,7 @@ export class AgentManager {
         const devState = await this.agentStore.get(devAgentId);
         if (devState?.taskId !== taskId || !devState.workdir) {
             throw new ApiError(409, `Dev ${devAgentId} no longer holds task ${taskId}'s Workdir (cannot continue); ` +
-                `use mark-complete to merge the PR as-is, or cancel the task`);
+                `submit a complete verdict to merge the PR as-is, or cancel the task`);
         }
         const prevReviewRound = task.reviewRound;
         const transitioned = await this.transitionTaskStatus(taskId, 'fixing', { fromStatus: ['max_rounds'] }, { reviewRound: prevReviewRound + 1, fixDispatchedAt: new Date().toISOString() });
@@ -8553,26 +8915,53 @@ export class AgentManager {
             const t = await this.taskStore.get(taskId);
             if (!t)
                 throw new ApiError(404, 'Task not found');
-            const retryable = TERMINAL_STATUSES.includes(t.status)
-                || (t.status === 'max_rounds' && isSpecStagePhase(t.phase));
-            if (!retryable) {
+            if (!TERMINAL_STATUSES.includes(t.status)) {
                 throw new ApiError(409, `Task ${taskId} cannot be retried in status "${t.status}"; cancel it first or wait for completion`);
             }
+            if (t.replacementTaskId !== undefined) {
+                throw new ApiError(409, `Task ${taskId} was already retried as ${t.replacementTaskId}`);
+            }
+            if (this.retryTaskInFlight.has(taskId)) {
+                throw new ApiError(409, `Task ${taskId} retry is already in progress`);
+            }
+            this.retryTaskInFlight.add(taskId);
             return t;
         });
-        const input = {
-            title: old.title,
-            description: old.description,
-            preferredAgentId: this.resolveRetryPreferredAgentId(old),
-        };
-        if (old.images?.length) {
-            input.images = await this.readStagedImages(old.id, old.images);
+        try {
+            const input = {
+                title: old.title,
+                description: old.description,
+                preferredAgentId: this.resolveRetryPreferredAgentId(old),
+            };
+            if (old.images?.length) {
+                input.images = await this.readStagedImages(old.id, old.images);
+            }
+            await this.validateTaskDispatch(old.projectId, input);
+            const replacement = await this.createTask(old.projectId, input);
+            await this.withTaskLock(async () => {
+                const source = await this.taskStore.get(taskId);
+                if (!source)
+                    throw new ApiError(404, `Task ${taskId} disappeared while recording its retry`);
+                if (source.replacementTaskId !== undefined && source.replacementTaskId !== replacement.id) {
+                    throw new ApiError(409, `Task ${taskId} was already retried as ${source.replacementTaskId}`);
+                }
+                const next = {
+                    ...source,
+                    replacementTaskId: replacement.id,
+                    updatedAt: new Date().toISOString(),
+                };
+                if (old.attention !== undefined
+                    && source.attention?.reason === old.attention.reason
+                    && source.attention.occurredAt === old.attention.occurredAt) {
+                    delete next.attention;
+                }
+                await this.taskStore.set(next);
+            });
+            return this.startCreatedTask(replacement);
         }
-        await this.validateTaskDispatch(old.projectId, input);
-        if (!TERMINAL_STATUSES.includes(old.status)) {
-            await this.cancelTask(old.id);
+        finally {
+            this.retryTaskInFlight.delete(taskId);
         }
-        return this.createAndStartTask(old.projectId, input);
     }
     resolveRetryPreferredAgentId(task) {
         const configured = this.getAgentConfig(task.preferredAgentId);
@@ -8582,7 +8971,7 @@ export class AgentManager {
         const anchors = new Set([task.qaAgentId, task.devAgentId, task.agentId]
             .filter((agentId) => typeof agentId === 'string' && agentId !== ''));
         for (const anchor of anchors) {
-            const dev = this.findAgentGroup(anchor)?.find(agent => TASK_OWNER_ROLES.has(agent.role));
+            const dev = this.findAgentTeam(anchor)?.find(agent => TASK_OWNER_ROLES.has(agent.role));
             const current = dev ? this.getAgentConfig(dev.id) : undefined;
             if (current?.projectId === task.projectId)
                 return current.id;
@@ -8624,13 +9013,13 @@ export class AgentManager {
                     }
                     if (!TASK_OWNER_ROLES.has(cfg.role))
                         throw new ApiError(400, 'Agent is not a dev agent');
-                    const group = this.findAgentGroup(cfg.id);
-                    const dev = group?.find(agent => agent.role === 'dev');
+                    const team = this.findAgentTeam(cfg.id);
+                    const dev = team?.find(agent => agent.role === 'dev');
                     if (!dev)
-                        throw new ApiError(409, `Agent ${cfg.id} has no dev agent in its group`);
-                    const qa = group?.find(agent => agent.role === 'qa');
+                        throw new ApiError(409, `Agent ${cfg.id} has no dev agent in its Agent Team`);
+                    const qa = team?.find(agent => agent.role === 'qa');
                     if (!qa)
-                        throw new ApiError(409, `Agent ${cfg.id} has no qa agent in its group`);
+                        throw new ApiError(409, `Agent ${cfg.id} has no qa agent in its Agent Team`);
                     task.preferredAgentId = patch.preferredAgentId;
                     task.devAgentId = dev.id;
                     task.qaAgentId = qa.id;
@@ -8668,22 +9057,22 @@ export class AgentManager {
                 throw new ApiError(409, `Task ${taskId} is not at max_rounds (status=${task.status})`);
             }
             if (isSpecStagePhase(task.phase)) {
-                throw new ApiError(409, `Mark complete is only supported for code-phase tasks`);
+                throw new ApiError(409, `Complete verdict is only supported for code-phase tasks`);
             }
             if (!task.prNumber || !task.branch) {
-                throw new ApiError(400, `Task ${taskId} has no PR/branch; cannot mark complete`);
+                throw new ApiError(400, `Task ${taskId} has no PR/branch; cannot complete`);
             }
             for (const agentId of [task.agentId, task.qaAgentId]) {
                 if (!agentId)
                     continue;
                 const state = await this.agentStore.get(agentId);
                 if (state?.status === 'awaiting_human' && state.taskId === taskId) {
-                    throw new ApiError(409, `Agent ${agentId} is awaiting human intervention on this task; resume/restart/delete it before marking complete`);
+                    throw new ApiError(409, `Agent ${agentId} is awaiting human intervention on this task; resume/restart/delete it before completing`);
                 }
             }
             const claimed = await this.transitionTaskStatus(taskId, 'merge-ready', { fromStatus: ['max_rounds'] });
             if (!claimed) {
-                throw new ApiError(409, `Task ${taskId} changed status during mark-complete; aborted`);
+                throw new ApiError(409, `Task ${taskId} changed status during complete verdict; aborted`);
             }
             try {
                 await this.mergePr(taskId, { humanOverride: true });
@@ -9193,6 +9582,247 @@ export class AgentManager {
         }
         return parked;
     }
+    async submitCodeVerdict(taskId, verdict, comments) {
+        const trimmed = comments?.trim() ?? '';
+        if (verdict === 'request-changes' && !trimmed) {
+            throw new ApiError(400, 'comments is required for request-changes');
+        }
+        if (extractReviewTokens(trimmed).length > 0) {
+            throw new ApiError(400, 'comments must not contain baxian review markers');
+        }
+        const task = await this.withTaskLock(async () => {
+            const fresh = await this.taskStore.get(taskId);
+            if (!fresh)
+                throw new ApiError(404, `Task ${taskId} not found`);
+            const pending = this.codeVerdictOutbox(fresh);
+            const kind = verdict === 'pass' ? 'pass' : 'fail';
+            if (pending !== undefined
+                && (pending.data.kind !== kind || pending.data.comments !== trimmed)) {
+                throw new ApiError(409, `Task ${taskId} has a different code verdict already in progress`);
+            }
+            if (pending === undefined && (fresh.status !== 'review' || isSpecStagePhase(fresh.phase))) {
+                throw new ApiError(409, `Task ${taskId} is not awaiting a code review verdict`);
+            }
+            if (this.codeVerdictInFlight.has(taskId)) {
+                throw new ApiError(409, `Task ${taskId} code verdict is already being processed`);
+            }
+            this.codeVerdictInFlight.add(taskId);
+            return fresh;
+        });
+        try {
+            return await this.executeCodeVerdict(task, verdict, trimmed);
+        }
+        finally {
+            this.codeVerdictInFlight.delete(taskId);
+        }
+    }
+    codeVerdictCommentBody(entry) {
+        const lines = [
+            entry.data.kind === 'pass'
+                ? 'Human code verdict: pass'
+                : 'Human code verdict: request changes',
+        ];
+        if (entry.data.comments)
+            lines.push('', entry.data.comments);
+        lines.push('', buildReviewTokenLine({
+            kind: entry.data.kind,
+            anchorSha: entry.data.anchorSha,
+            token: entry.data.token,
+        }));
+        const body = lines.join('\n');
+        try {
+            validateCommentBody(body);
+        }
+        catch (err) {
+            throw new ApiError(400, `Invalid code verdict comment: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return body;
+    }
+    async scanCodeVerdictMarker(driver, entry, oppositeToken) {
+        const scans = await this.platformScanComments(driver, entry.data.prNumber);
+        if (scans.some(scan => !scan.ok))
+            return 'unknown';
+        const dead = deadTokens(scans);
+        if (dead.has(entry.data.token))
+            return 'dead';
+        let present = false;
+        let opposite = false;
+        for (const scan of scans) {
+            for (const row of scan.rows) {
+                if (row.system === true || versionTimeOf(row) === undefined)
+                    continue;
+                for (const marker of rowTokens(row)) {
+                    if (dead.has(marker.token))
+                        continue;
+                    if (marker.anchorSha.toLowerCase() !== entry.data.anchorSha.toLowerCase())
+                        continue;
+                    if (marker.kind === entry.data.kind && marker.token === entry.data.token)
+                        present = true;
+                    if (marker.kind !== entry.data.kind && marker.token === oppositeToken)
+                        opposite = true;
+                }
+            }
+        }
+        if (opposite)
+            return 'opposite';
+        return present ? 'present' : 'absent';
+    }
+    async reconcileCodeVerdictComment(driver, entry) {
+        const expectedDigest = bodyDigest(this.codeVerdictCommentBody(entry));
+        const scans = await this.platformScanComments(driver, entry.data.prNumber);
+        if (scans.some(scan => !scan.ok))
+            return 'unknown';
+        if (deadTokens(scans).has(entry.data.token))
+            return 'dead';
+        if (scans.some(scan => scan.rows.some(row => row.system !== true
+            && versionTimeOf(row) !== undefined
+            && row.bodyDigest === expectedDigest)))
+            return 'present';
+        return 'absent';
+    }
+    async verifyCodeVerdictHead(taskId, prNumber, anchorSha) {
+        try {
+            const binding = await this.platformVerifyPrBinding(taskId, prNumber);
+            if (!binding.ok)
+                return { ok: false, reason: `the PR binding is ${binding.reason}` };
+            if (binding.headSha.toLowerCase() !== anchorSha.toLowerCase()) {
+                return { ok: false, reason: 'the PR head changed' };
+            }
+            return { ok: true };
+        }
+        catch (err) {
+            throw new ApiError(503, `Cannot verify code verdict head for task ${taskId}: ${safeDriverErrorText(err)}`);
+        }
+    }
+    async deliverCodeVerdictOutbox(taskId, key) {
+        let task = await this.taskStore.get(taskId);
+        let entry = task ? this.codeVerdictOutbox(task) : undefined;
+        if (!task || !entry || entry.key !== key)
+            return;
+        const driver = this.platformDriverFor(task.projectId);
+        if (!driver)
+            throw new ApiError(503, `Git driver unavailable for task ${task.id}`);
+        const binding = await this.verifyCodeVerdictHead(task.id, entry.data.prNumber, entry.data.anchorSha);
+        if (!binding.ok) {
+            await this.mutateTaskOutboxEntry(task.id, key, current => current.type === 'git.code-verdict' ? undefined : null);
+            throw new ApiError(409, `Cannot write code verdict for task ${task.id}: ${binding.reason}`);
+        }
+        if (entry.data.writeAttemptedAt !== undefined) {
+            const reconciled = await this.reconcileCodeVerdictComment(driver, entry);
+            if (reconciled === 'dead') {
+                await this.mutateTaskOutboxEntry(task.id, key, current => current.type === 'git.code-verdict' ? undefined : null);
+                throw new ApiError(409, `Code verdict token for task ${task.id} was dismissed; advance QA to create a new review pass`);
+            }
+            if (reconciled === 'present') {
+                return;
+            }
+            if (reconciled === 'unknown'
+                || Date.now() - Date.parse(entry.data.writeAttemptedAt) < driver.visibilityLagMs) {
+                throw new ApiError(503, `Code verdict comment outcome is still being reconciled for task ${task.id}`);
+            }
+        }
+        const expectedAttempt = entry.data.writeAttemptedAt;
+        const claimed = await this.mutateTaskOutboxEntry(task.id, entry.key, current => current.type === 'git.code-verdict' && current.data.writeAttemptedAt === expectedAttempt
+            ? { ...current, data: { ...current.data, writeAttemptedAt: new Date().toISOString() } }
+            : null);
+        const claimedEntry = claimed ? this.codeVerdictOutbox(claimed) : undefined;
+        if (!claimed || claimedEntry?.key !== entry.key) {
+            throw new ApiError(503, `Code verdict comment write is already claimed for task ${task.id}`);
+        }
+        task = claimed;
+        entry = claimedEntry;
+        let writeFailure;
+        try {
+            await driver.runOp('comment', {
+                prNumber: entry.data.prNumber,
+                body: this.codeVerdictCommentBody(entry),
+            });
+        }
+        catch (error) {
+            writeFailure = { error };
+        }
+        const reconciled = await this.reconcileCodeVerdictComment(driver, entry);
+        if (reconciled === 'dead') {
+            await this.mutateTaskOutboxEntry(task.id, key, current => current.type === 'git.code-verdict' ? undefined : null);
+            throw new ApiError(409, `Code verdict token for task ${task.id} was dismissed; advance QA to create a new review pass`);
+        }
+        if (writeFailure !== undefined && reconciled !== 'present') {
+            const { error } = writeFailure;
+            const uncertain = !(error instanceof DriverOpError)
+                || error.info.exitCode === 255
+                || isTransientNetworkFailure(error.info.stderrTail ?? '')
+                || isTransientNetworkFailure(error.message);
+            if (reconciled === 'unknown' || uncertain) {
+                throw new ApiError(503, `Code verdict comment outcome is unknown for task ${task.id}; the persisted outbox will reconcile it`);
+            }
+            await this.mutateTaskOutboxEntry(task.id, key, current => current.type === 'git.code-verdict' ? undefined : null);
+            throw new ApiError(502, `Code verdict comment was rejected for task ${task.id}: ${safeDriverErrorText(error)}`);
+        }
+        if (reconciled !== 'present') {
+            throw new ApiError(503, `Code verdict comment is not yet visible for task ${task.id}; the persisted outbox will reconcile it`);
+        }
+    }
+    async executeCodeVerdict(task, verdict, comments) {
+        if (task.status !== 'review' || isSpecStagePhase(task.phase)
+            || task.prNumber === undefined || task.reviewHeadAnchorSha === undefined
+            || task.passToken === undefined || task.failToken === undefined) {
+            throw new ApiError(409, `Task ${task.id} has no complete code review generation`);
+        }
+        const kind = verdict === 'pass' ? 'pass' : 'fail';
+        const token = kind === 'pass' ? task.passToken : task.failToken;
+        const existingEntry = this.codeVerdictOutbox(task);
+        const entry = existingEntry ?? {
+            key: token,
+            type: 'git.code-verdict',
+            data: {
+                prNumber: task.prNumber,
+                kind,
+                anchorSha: task.reviewHeadAnchorSha,
+                token,
+                comments,
+            },
+        };
+        this.codeVerdictCommentBody(entry);
+        const driver = this.platformDriverFor(task.projectId);
+        if (!driver)
+            throw new ApiError(503, `Git driver unavailable for task ${task.id}`);
+        const binding = await this.verifyCodeVerdictHead(task.id, task.prNumber, task.reviewHeadAnchorSha);
+        if (!binding.ok) {
+            throw new ApiError(409, `Cannot submit code verdict for task ${task.id}: ${binding.reason}`);
+        }
+        if (existingEntry === undefined) {
+            const marker = await this.scanCodeVerdictMarker(driver, entry, kind === 'pass' ? task.failToken : task.passToken);
+            if (marker === 'present')
+                return task;
+            if (marker === 'opposite') {
+                throw new ApiError(409, `Task ${task.id} already has the opposite verdict on the current review head`);
+            }
+            if (marker === 'dead') {
+                throw new ApiError(409, `Code verdict token for task ${task.id} was dismissed; advance QA to create a new review pass`);
+            }
+            if (marker === 'unknown') {
+                throw new ApiError(503, `Cannot safely check existing code verdict comments for task ${task.id}`);
+            }
+            const created = await this.withTaskLock(async () => {
+                const fresh = await this.taskStore.get(task.id);
+                if (!fresh || !taskMatchesGeneration(fresh, taskGenerationGuard(task))
+                    || this.codeVerdictOutbox(fresh) !== undefined)
+                    return null;
+                const next = {
+                    ...fresh,
+                    outbox: [...(fresh.outbox ?? []), entry],
+                    updatedAt: new Date().toISOString(),
+                };
+                await this.taskStore.set(next);
+                return next;
+            });
+            if (!created)
+                throw new ApiError(409, `Task ${task.id} changed while recording the code verdict`);
+            task = created;
+        }
+        await this.deliverCodeVerdictOutbox(task.id, entry.key);
+        return (await this.taskStore.get(task.id)) ?? task;
+    }
     async submitSpecVerdict(taskId, verdict, comments) {
         const trimmed = comments?.trim();
         if (verdict === 'request-changes' && !trimmed) {
@@ -9849,8 +10479,8 @@ export class AgentManager {
 function buildAgentIndex(config) {
     const index = new Map();
     for (const project of config.project) {
-        for (const pair of project.agent) {
-            for (const agent of pair) {
+        for (const team of project.agent) {
+            for (const agent of team) {
                 index.set(agent.id, { ...agent, projectId: project.id });
             }
         }