baxian 1.2.60 → 2.0.0

package/dist/agent/manager.d.ts

@@ -1,12 +1,13 @@
-import type { AfterDone, BaxianConfig, AgentConfig, AgentBindingFacts, HostConfig, ProjectConfig, ReviewMode, ReviewPhase, SpecDocument, TaskState, TaskStatus } from '../shared/index.js';
-import type { GitDriver } from '../platform/git-driver.js';
+import { type AgentGitPreflight } from './preflight.js';
+import type { AfterDone, BaxianConfig, AgentConfig, AgentBindingFacts, HostConfig, ProjectConfig, ReviewMode, ReviewDispatchLease, ReviewPhase, ServerSignalKind, ServerSignalRecovery, ServerSignalRecoveryReason, SpecDocument, TaskPhase, TaskState, TaskStatus } from '../shared/index.js';
+import { GitDriver } from '../platform/git-driver.js';
 import type { PluginRegistry } from '../platform/plugin-registry.js';
 import type { NormalizedRow } from '../platform/row-schema.js';
 import { type PrRejection } from '../platform/pr-binding.js';
 import { type PendingFeedbackResult } from '../platform/feedback.js';
+import { type PlatformBindingMismatch } from '../platform/startup.js';
 import type { AgentStore } from '../state/agent-store.js';
 import type { TaskStore } from '../state/task-store.js';
-import { PostApproveStore, type PostApproveCompletion } from '../state/post-approve-store.js';
 import type { LockManager } from '../state/lock.js';
 import type { EventBus } from '../event/bus.js';
 import type { ErrorRecordStore } from '../state/error-record-store.js';
@@ -16,11 +17,11 @@ import { type LineageViolation } from './lineage.js';
 import { type TmuxSessionRef, type PaneRef } from './tmux.js';
 import { RepoStore, type RepoStoreCache } from './repo-store.js';
 import type { PaneStreamerManager } from './pane-streamer-manager.js';
-import { PhaseSignalWatcher } from './phase-signal-watcher.js';
+import { PhaseSignalWatcher, type NeedInputCommitIntent, type NeedInputCommitResult } from './phase-signal-watcher.js';
 import type { PhaseSignalKind } from './phase-signal.js';
 import { ReviewTransport } from './review-transport.js';
-import type { ReviewStore } from '../state/review-store.js';
-import { type PostMergeCleanupContext } from './prompt.js';
+import { type ReviewStore } from '../state/review-store.js';
+import { type PostMergeCleanupContext, type PlatformCliDescriptor, type ServerFeedbackCorrectionPrompt } from './prompt.js';
 export interface EnsureSessionResult {
     ok: true;
     createdSession: boolean;
@@ -107,8 +108,8 @@ export interface AgentManagerDeps {
     imageStagingRoot?: string;
     repoStoreFactory?: (runner: CommandRunner, repoSlug: string, mode: AgentConfig['mode'], host: HostConfig | undefined, cache: RepoStoreCache, agentId: string, workdir?: string) => RepoStore;
     paneStreamerManager?: PaneStreamerManager;
-    postApproveStore?: PostApproveStore;
     pluginRegistry?: PluginRegistry;
+    platformDefaultBranchOf?: (projectId: string) => string | undefined;
     phaseSignalWatcher?: PhaseSignalWatcher;
     errorRecordStore?: ErrorRecordStore;
     reviewStore?: ReviewStore;
@@ -118,15 +119,13 @@ export interface AgentManagerDeps {
         greeting?: number;
     };
     dispatchAckTimeoutMs?: number;
+    needInputRetryIntervalMs?: number;
     dispatchSettleTimeoutMs?: number;
 }
-export declare class PlatformCloseError extends Error {
-    readonly step: 'close' | 'deleteBranch';
-    constructor(step: 'close' | 'deleteBranch', cause: unknown);
-}
 export declare class PlatformMergeRecheckError extends Error {
+    readonly kind: 'pending-feedback' | 'provenance-invalid';
     readonly reason: string;
-    constructor(reason: string);
+    constructor(kind: 'pending-feedback' | 'provenance-invalid', reason: string);
 }
 export interface TransitionResult {
     task: TaskState;
@@ -148,6 +147,8 @@ interface SessionDispatchOpts {
         total: number;
     };
     serverPriorFindings?: string;
+    serverFindingsDigest?: string;
+    serverFeedbackCorrection?: ServerFeedbackCorrectionPrompt;
     serverPriorResponse?: string;
     specDocuments?: readonly SpecDocument[];
     armBeforeInject?: (ctx: DispatchArmContext) => Promise<boolean>;
@@ -155,6 +156,7 @@ interface SessionDispatchOpts {
 interface StartSessionOpts extends SessionDispatchOpts {
     preserveBindingOnFailure?: boolean;
     dispatchPassToken?: string;
+    dispatchReviewLease?: Pick<ReviewDispatchLease, 'generation' | 'claimId' | 'signalToken' | 'headSha' | 'passToken' | 'failToken' | 'effectiveRound' | 'qaPhase'>;
     dispatchPendingBudget?: {
         since: number;
         budgetAlerted?: boolean;
@@ -162,6 +164,7 @@ interface StartSessionOpts extends SessionDispatchOpts {
 }
 export interface ContinueSessionOpts extends SessionDispatchOpts {
     postApproveRedispatchCount?: number;
+    postApproveEpisode?: PostApproveEpisodeKey;
     serverAfterDone?: {
         kind: 'branch' | 'pr';
         branch: string;
@@ -182,6 +185,12 @@ export interface MergePrOpts {
     matchHeadSha?: string;
     humanOverride?: boolean;
 }
+export interface PostApproveEpisodeKey {
+    generation: string;
+    token: string;
+    headSha: string;
+}
+type ReviewDispatchFence = Pick<ReviewDispatchLease, 'generation' | 'signalToken' | 'headSha' | 'passToken' | 'failToken' | 'effectiveRound' | 'qaPhase'>;
 export type CodeInterdiffResult = {
     ok: true;
     diff: string;
@@ -193,8 +202,12 @@ export type CodeInterdiffResult = {
     reason: 'released';
 };
 export interface ServerReviewDriver {
-    dispatchCodeReview(task: TaskState): Promise<boolean>;
-    dispatchSpecReview(task: TaskState): Promise<boolean>;
+    dispatchCodeReview(task: TaskState, opts?: {
+        bumpRound?: boolean;
+    }): Promise<boolean>;
+    dispatchSpecReview(task: TaskState, opts?: {
+        bumpRound?: boolean;
+    }): Promise<boolean>;
 }
 export declare function canDispatchWithBinding(binding: AgentBindingFacts | null | undefined): boolean;
 export declare const RECOVERABLE_QA_DISPATCH_HOLD_PHASES: Set<string>;
@@ -207,6 +220,14 @@ export interface PendingDispatchRetry {
     since: number;
     budgetAlerted?: boolean;
 }
+export interface PostApproveCompletion {
+    token: string;
+    approvedHeadSha: string;
+    generation: string;
+    updatedAt: string;
+    redispatchCount?: number;
+    pendingRedispatch?: boolean;
+}
 export declare class AgentManager {
     private config;
     protected agentStore: AgentStore;
@@ -218,8 +239,8 @@ export declare class AgentManager {
     protected repoStoreFactory?: AgentManagerDeps['repoStoreFactory'];
     protected repoCache: RepoStoreCache;
     protected paneStreamerManager?: PaneStreamerManager;
-    protected postApproveStore: PostApproveStore;
     protected pluginRegistry?: PluginRegistry;
+    private platformDefaultBranchOf?;
     private readonly platformDriverExec;
     protected phaseSignalWatcher?: PhaseSignalWatcher;
     protected errorRecordStore?: ErrorRecordStore;
@@ -227,9 +248,11 @@ export declare class AgentManager {
     private reviewTransportInstance?;
     private serverReviewDriver?;
     protected dispatchAckTimeoutMs: number;
+    private readonly needInputRetryIntervalMs;
     protected dispatchSettleTimeoutMs: number;
     protected dispatchAckResendIntervalMs: number;
     private taskMutationQueue;
+    private agentOperationQueues;
     private agentIndex;
     private platformRunner;
     private imageStagingRoot;
@@ -242,6 +265,7 @@ export declare class AgentManager {
     protected manualCompactWaitMs: number;
     protected runtimeLivenessProbeMs: number;
     protected cleanComposerWaitMs: number;
+    protected platformVerificationRetryDelayMs: number;
     protected readyStableSamples: number;
     protected readyStableSpacingMs: number;
     private pendingDispatchRetryByTask;
@@ -255,8 +279,10 @@ export declare class AgentManager {
     private divergedAgents;
     private deletionGeneration;
     private compactInFlight;
+    private configInterventionKeys;
     constructor(deps: AgentManagerDeps);
     private withTaskLock;
+    private withAgentOperationLease;
     private resolveTaskLockToken;
     private assertTaskLockOwner;
     private assertTaskGeneration;
@@ -265,12 +291,22 @@ export declare class AgentManager {
     effectiveReviewMode(projectId: string): ReviewMode;
     resolveAfterDone(task: TaskState): AfterDone;
     private coerceAfterDone;
+    commitServerAfterDone(taskId: string): Promise<AfterDone>;
     getReviewTransport(): ReviewTransport;
     private prepareDispatchArtifacts;
     private bindingWorkdirCache;
     refreshWorkdirCacheFor(agentId: string): Promise<string | undefined>;
     private safeEmit;
     private emitIntervention;
+    emitConfigIntervention(projectId: string, data: Record<string, unknown> & {
+        phase: string;
+    }): Promise<void>;
+    configInterventionKey(projectId: string, data: Record<string, unknown> & {
+        phase: string;
+    }): string;
+    platformBindingInterventionKey(task: TaskState, mismatch: PlatformBindingMismatch): string;
+    retainConfigInterventionKeys(keys: ReadonlySet<string>): void;
+    emitPlatformBindingIntervention(task: TaskState, mismatch: PlatformBindingMismatch): Promise<void>;
     private recordError;
     replaceConfig(validated: BaxianConfig): void;
     getConfig(): BaxianConfig;
@@ -280,6 +316,14 @@ export declare class AgentManager {
     tryClaimDeletion(agentIds: readonly string[]): string | null;
     scanActiveThenClaimDeletion(targets: readonly string[]): Promise<DeletionClaimOutcome>;
     releaseDeletionClaim(agentIds: readonly string[]): void;
+    listActiveParticipantSeats(): Promise<Array<{
+        taskId: string;
+        projectId: string;
+        participants: Array<{
+            agentId: string;
+            expectedRole?: AgentConfig['role'];
+        }>;
+    }>>;
     bumpDeletionGeneration(agentId: string): void;
     deletionGenerationOf(agentId: string): number;
     private deletionGateOpen;
@@ -289,6 +333,7 @@ export declare class AgentManager {
         expectedGeneration?: number;
     }): Promise<EnsureSessionResult>;
     private ensureSessionLocked;
+    private agentSkillScope;
     private provisionRepoSkills;
     private sessionLifecycleChain;
     private adoptGeneration;
@@ -336,6 +381,8 @@ export declare class AgentManager {
         clearAwaitingHuman?: boolean;
         fromCancelCleanup?: boolean;
         expectedTask?: Pick<TaskState, 'status' | 'phase' | 'signalToken'>;
+        expectedReviewDispatch?: Pick<ReviewDispatchLease, 'generation' | 'claimId' | 'signalToken'>;
+        expectedPostApproveEpisode?: PostApproveEpisodeKey;
         expectedHold?: {
             phase: string | undefined;
             since: string | undefined;
@@ -347,10 +394,31 @@ export declare class AgentManager {
     private clearBranchLocalCleaned;
     private releaseAgentIfBound;
     reconcileTaskBranches(): Promise<void>;
-    private setAgentNeedInput;
+    private readonly needInputRetry;
+    private readonly needInputRetryInFlight;
+    private readonly gitReviewQaConfigAlerted;
+    private readonly needInputWritesInFlight;
+    private needInputWriteSeq;
+    private readonly needInputArmLocks;
+    private needInputRetryTimer;
+    private needInputRetryKey;
+    private parseNeedInputRetryKey;
+    commitNeedInputWatermark(intent: NeedInputCommitIntent): Promise<NeedInputCommitResult>;
+    private writeNeedInputWatermark;
+    private enqueueNeedInputRetry;
+    private settleNeedInputRetry;
+    private clearNeedInputRetryFor;
+    private ensureNeedInputRetryTimer;
+    private needInputRetryPass;
+    private collectSameEpochNeedInput;
+    private collectPredecessorNeedInputDelta;
+    private withNeedInputArmLock;
+    private bumpNeedInputEpochForArm;
     private startPhaseSignalWatch;
+    private confirmNeedInputAnswered;
     notifyHumanTerminalInput(agentId: string): Promise<void>;
     clearAwaitingHuman(agentId: string, opts?: {
+        expectedTaskId?: string;
         expectedHold?: {
             phase?: string;
             since?: string;
@@ -382,7 +450,11 @@ export declare class AgentManager {
     private markPaneCancelClearing;
     private claimCancelCleanup;
     private releaseCancelCleanup;
-    failTaskForDispatchError(taskId: string, phase: string, agentId: string, err: DispatchTerminalError): Promise<void>;
+    failTaskForDispatchError(taskId: string, phase: string, agentId: string, err: DispatchTerminalError, opts?: {
+        expectedPostApproveEpisode?: PostApproveEpisodeKey;
+        expectedReviewDispatch?: ReviewDispatchFence;
+        expectedLockToken?: string;
+    }): Promise<void>;
     failTasksForAgent(agentId: string, reason: string, opts?: {
         deferPartnerCleanup?: boolean;
     }): Promise<{
@@ -398,10 +470,11 @@ export declare class AgentManager {
         phase: string | undefined;
         since: string | undefined;
         nonce: string | undefined;
-    }): Promise<boolean>;
+    }, extraCurrent?: (fresh: TaskState) => Promise<boolean>): Promise<boolean>;
+    private runRotatedReplay;
     redispatchTaskPromptAfterReplRestart(agentId: string, taskId: string): Promise<boolean>;
     private replayApprovedHolderAfterReplRestart;
-    private rebuildPostApproveCompletion;
+    private holdIncompleteGitPostApproveEpisode;
     prepareRemoveTargets(agentId: string): {
         targets: string[];
     };
@@ -415,26 +488,23 @@ export declare class AgentManager {
         projectId: string;
     }>;
     getProjectConfig(projectId: string): ProjectConfig | undefined;
-    getProjectByRepo(repo: string): ProjectConfig | undefined;
-    getProjectByRepoIdentity(repoKey: string): ProjectConfig | undefined;
     platformDriverFor(projectId: string): GitDriver | undefined;
     private findAgentGroup;
     private longestDevWorkdirInProject;
     getTask(taskId: string): Promise<TaskState | null>;
     getAgentState(agentId: string): Promise<AgentBindingFacts | null>;
     getPostApproveCompletion(taskId: string): Promise<PostApproveCompletion | null>;
-    private gitCompletionOf;
-    private stripGitCompletionFields;
-    setPostApproveCompletion(taskId: string, value: {
-        token: string;
-        approvedHeadSha: string;
-        redispatchCount?: number;
-        pendingRedispatch?: boolean;
-    }, opts?: {
-        clearRevocation?: boolean;
+    private completionOf;
+    private postApproveEpisodeMatches;
+    armGitPostApproveEpisode(taskId: string, expected: PostApproveEpisodeKey, opts?: {
+        recovered?: boolean;
     }): Promise<boolean>;
-    confirmPostApprovePromptDelivered(taskId: string, token: string): Promise<void>;
-    markPostApproveSignalReceived(taskId: string, token: string): Promise<void>;
+    rotateGitPostApproveEpisode(taskId: string, expected: PostApproveEpisodeKey, redispatchCount: number): Promise<PostApproveEpisodeKey | null>;
+    private stripPostApproveFields;
+    private stripPostApproveEpisodeFields;
+    private stripGitStatusScopedState;
+    confirmPostApprovePromptDelivered(taskId: string, expected: string | PostApproveEpisodeKey): Promise<void>;
+    markPostApproveSignalReceived(taskId: string, expected: string | PostApproveEpisodeKey): Promise<void>;
     clearPostApproveCompletion(taskId: string): Promise<void>;
     updatePostApproveCompletionIfToken(taskId: string, expectedToken: string, patch: {
         redispatchCount?: number;
@@ -444,13 +514,16 @@ export declare class AgentManager {
             key: string;
             versionTime: number;
         };
+        expectedGeneration?: string;
+        expectedHeadSha?: string;
     }): Promise<boolean>;
     revokePostApproveCompletion(taskId: string, reason: 'request-changes' | 'redispatch-cap', opts?: {
         expectedToken?: string;
         expectedHeadSha?: string;
+        expectedGeneration?: string;
     }): Promise<boolean>;
-    clearPostApproveCompletionIfMatches(taskId: string, token: string): Promise<boolean>;
-    completeApprovedPassToMergeReady(taskId: string, expectedToken: string): Promise<{
+    clearPostApproveCompletionIfMatches(taskId: string, expected: string | PostApproveEpisodeKey): Promise<boolean>;
+    completeApprovedPassToMergeReady(taskId: string, expected: string | PostApproveEpisodeKey): Promise<{
         task: TaskState;
     } | {
         refused: 'stale' | 'pending';
@@ -462,6 +535,7 @@ export declare class AgentManager {
     rearmPostApproveSignal(taskId: string, opts?: {
         skipSnapshot?: boolean;
     }): Promise<boolean>;
+    ensurePluginSkillPools(next: BaxianConfig): Promise<void>;
     guardGitConfigCommit(current: BaxianConfig, next: BaxianConfig, scan: (manager: AgentManager, current: BaxianConfig, next: BaxianConfig) => Promise<Array<{
         projectId: string;
         taskIds: string[];
@@ -474,10 +548,43 @@ export declare class AgentManager {
             taskIds: string[];
         }>;
     }>;
-    flushGitOutbox(): Promise<void>;
-    clearReviewDispatchPending(taskId: string, expectedToken: string): Promise<void>;
+    flushTaskOutboxes(): Promise<void>;
+    private gitReviewLeaseMatches;
+    private gitReviewQaConfigUsable;
+    beginGitReviewPass(taskId: string, opts: {
+        fromStatus: TaskStatus[];
+        headSha: string;
+        bumpRound: boolean;
+        qaPhase?: 'review' | 'recheck';
+        expectSignalToken?: string;
+        expectPhase?: TaskPhase;
+        allowDuringComplete?: boolean;
+        patch?: Partial<Pick<TaskState, 'prNumber' | 'prUrl' | 'latestHeadSha' | 'branch' | 'baseBranch' | 'replyActorId' | 'replyActorStatus' | 'pendingPrSignalToken'>>;
+    }): Promise<TransitionResult | null>;
+    claimGitReviewDispatch(taskId: string, expectedGeneration?: string): Promise<{
+        task: TaskState;
+        lease: ReviewDispatchLease & {
+            phase: 'claimed';
+            claimId: string;
+            claimedAt: string;
+        };
+    } | null>;
+    approveGitReviewPass(taskId: string, opts: {
+        expectedSignalToken: string;
+        headSha: string;
+        reviewRound: number;
+        prNumber?: number;
+        prUrl?: string;
+        provenance: NonNullable<TaskState['passProvenance']>;
+    }): Promise<TaskState | null>;
+    private resetGitReviewDispatchClaim;
+    private markGitReviewDispatchUncertain;
+    private confirmUncertainGitReviewDispatch;
+    private completeGitReviewDispatch;
+    private recoverPendingGitReviewDispatchHold;
+    recoverClaimedGitReviewDispatches(): Promise<void>;
     retryPendingGitReviewDispatches(): Promise<void>;
-    retryGitRemoteBranchCleanup(): Promise<void>;
+    retryGitRemoteCleanupIntents(): Promise<void>;
     consumeGitFeedbackRevision(taskId: string, consume: {
         key: string;
         versionTime: number;
@@ -489,30 +596,26 @@ export declare class AgentManager {
         kind: 'returned' | 'pending';
         task: TaskState;
     }>;
-    returnMergeReadyToApproved(taskId: string, consume: {
-        key: string;
-        versionTime: number;
-    }): Promise<TaskState | null>;
     setupRecoveredPostApproveSignals(): Promise<void>;
     setupRecoveredSpecSignals(): Promise<void>;
+    private recoverServerSignalRecovery;
     private setupRecoveredWatcherForMapping;
-    prHasDevReplySince(taskId: string, sinceIso: string): Promise<boolean>;
-    private ghCreatedAt;
-    fetchPrHeadSha(taskId: string): Promise<string>;
     verifyPaneSignalPrNumber(taskId: string, prNumber: number): Promise<{
         headRefName: string;
         headSha: string;
-    } | undefined>;
-    fetchPrHeadRef(prNumber: number, projectId: string): Promise<{
-        headRefName: string;
-        headSha: string;
-        body: string;
+        targetBranch: string;
     } | undefined>;
     platformBindingFields(projectId: string): Partial<TaskState>;
+    private platformBindingFor;
+    agentGitPreflightContext(projectId: string): AgentGitPreflight | undefined;
+    platformCliContextOf(task: TaskState): PlatformCliDescriptor | undefined;
+    ensureGitBaseSnapshot(task: TaskState, phase: string): Promise<TaskState>;
+    noteReviewConversationRevision(taskId: string): Promise<void>;
     private assertPlatformBinding;
     private platformTaskAndDriver;
     listActiveGitTasks(projectId?: string): Promise<TaskState[]>;
     platformFetchPrView(taskId: string): Promise<NormalizedRow>;
+    platformFetchPrHeadSha(taskId: string): Promise<string>;
     platformVerifyPrBinding(taskId: string, prNumber: number, opts?: {
         branchOverride?: string;
     }): Promise<{
@@ -526,15 +629,19 @@ export declare class AgentManager {
         prBranch?: string;
     }>;
     stopPhaseSignalWatcherAgent(taskId: string, agentId: string): void;
-    platformClosePr(taskId: string, opts: {
-        deleteBranch: boolean;
-    }): Promise<void>;
+    private mutateRemoteCleanup;
+    private recordRemoteCleanupFailure;
+    private markRemoteCleanupManual;
+    processGitRemoteCleanup(taskId: string, expectedGeneration?: string): Promise<void>;
     private platformScanComments;
     platformVerifyAcceptedPass(taskId: string): Promise<{
-        ok: true;
+        kind: 'valid';
         pendingCount: number;
     } | {
-        ok: false;
+        kind: 'retryable';
+        reason: string;
+    } | {
+        kind: 'provenance-invalid';
         reason: string;
     }>;
     platformPendingFeedback(taskId: string): Promise<PendingFeedbackResult>;
@@ -546,17 +653,34 @@ export declare class AgentManager {
         passToken: string;
         failToken: string;
     };
-    listTasksByProject(projectId: string): Promise<TaskState[]>;
+    private taskBelongsToPlatformEntry;
+    listTasksForPlatformEntry(projectId: string): Promise<TaskState[]>;
     findTaskByBranch(branch: string, projectId: string): Promise<TaskState | undefined>;
-    listTasksByPrNumber(prNumber: number, projectId?: string): Promise<TaskState[]>;
-    updateTaskStatus(taskId: string, status: TaskStatus): Promise<void>;
-    updateTaskIfStatus(taskId: string, expectedStatus: TaskStatus, updates: Partial<TaskState>, alsoExpect?: Partial<Pick<TaskState, 'signalToken' | 'reviewRound'>>): Promise<boolean>;
+    adoptServerPr(taskId: string, pr: {
+        prNumber: number;
+        prUrl?: string;
+        headSha?: string;
+        targetBranch?: string;
+    }): Promise<boolean>;
+    updateTaskIfStatus(taskId: string, expectedStatus: TaskStatus, updates: Partial<TaskState>, alsoExpect?: Partial<Pick<TaskState, 'signalToken' | 'phase' | 'reviewRound' | 'specReviewRound'>>): Promise<boolean>;
+    claimServerSignalRecovery(taskAtEntry: TaskState, agentId: string, signalKind: ServerSignalKind, input: Omit<ServerSignalRecovery, 'signalKind' | 'sourceToken' | 'createdAt'>): Promise<TaskState | null>;
+    holdConsumedServerSignal(taskAtEntry: TaskState, agentId: string, signalKind: ServerSignalKind, input: {
+        phase: 'spec' | 'code';
+        round: number;
+        reason: ServerSignalRecoveryReason;
+        failurePhase: string;
+    }): Promise<TaskState | null>;
+    setServerSignalRecoveryMode(taskId: string, successorToken: string, mode: 'correct-response' | 'hold'): Promise<TaskState | null>;
+    holdServerSignalRecovery(taskId: string, agentId: string, successorToken: string, holdPhase: string, reason: string): Promise<TaskState | null>;
+    dispatchServerFeedbackCorrection(taskId: string, findingsJson: string): Promise<boolean>;
     updateTask(taskId: string, updates: Partial<TaskState>): Promise<void>;
     transitionTaskStatus(taskId: string, toStatus: TaskStatus, guard: {
         fromStatus: TaskStatus[];
         expectSignalToken?: string;
-    }, patch?: Partial<Pick<TaskState, 'reviewRound' | 'agentId' | 'prNumber' | 'prUrl' | 'qaAgentId' | 'latestHeadSha' | 'reviewHeadAnchorSha' | 'reviewDispatchedAt' | 'fixDispatchedAt' | 'specReviewRound' | 'signalToken' | 'passToken' | 'failToken' | 'reviewRoundPending' | 'reviewDispatchPending' | 'phase' | 'batchIndex' | 'batchTotal' | 'branch' | 'maxRoundsContinues'>>): Promise<TransitionResult | null>;
-    consumeReviewRoundIntent(taskId: string, expectedToken: string): Promise<void>;
+        expectPhase?: TaskPhase;
+        expectPostApproveEpisode?: PostApproveEpisodeKey;
+        expectReviewDispatch?: ReviewDispatchFence;
+    }, patch?: Partial<Pick<TaskState, 'reviewRound' | 'agentId' | 'prNumber' | 'prUrl' | 'qaAgentId' | 'latestHeadSha' | 'reviewHeadAnchorSha' | 'reviewDispatchedAt' | 'fixDispatchedAt' | 'specReviewRound' | 'signalToken' | 'passToken' | 'failToken' | 'reviewRoundPending' | 'reviewDispatch' | 'phase' | 'batchIndex' | 'batchTotal' | 'branch' | 'maxRoundsContinues'>>): Promise<TransitionResult | null>;
     private createRunnerFor;
     private createRepoStore;
     private ensureWorkdir;
@@ -630,6 +754,8 @@ export declare class AgentManager {
         allowAwaitingHuman?: boolean;
         clearAwaitingHuman?: boolean;
         expectedTask?: Pick<TaskState, 'status' | 'phase' | 'signalToken'>;
+        expectedReviewDispatch?: Pick<ReviewDispatchLease, 'generation' | 'claimId' | 'signalToken'>;
+        expectedPostApproveEpisode?: PostApproveEpisodeKey;
         expectedHold?: {
             phase: string | undefined;
             since: string | undefined;
@@ -650,22 +776,32 @@ export declare class AgentManager {
         description: string;
         preferredAgentId: string;
     }): Promise<void>;
+    private gitReviewClaimMatches;
+    private gitReviewDispatchMatches;
+    dispatchGitReviewLease(taskId: string, opts?: {
+        expectedGeneration?: string;
+        pendingBudget?: {
+            since: number;
+            budgetAlerted?: boolean;
+        };
+        onQaAcquired?: (lockToken: string) => void;
+    }): Promise<TaskState>;
     dispatchReviewToQa(taskId: string, opts?: {
         fromStatus?: TaskStatus[];
         bumpRound?: boolean;
         expectSignalToken?: string;
+        expectPhase?: TaskPhase;
         qaPhase?: 'review' | 'recheck';
         pendingBudget?: {
             since: number;
             budgetAlerted?: boolean;
         };
-        expectReviewDispatchPending?: boolean;
         onPassArmed?: (armedToken: string) => void;
+        onQaAcquired?: (lockToken: string) => void;
+        confirmUncertainNotDelivered?: boolean;
     }): Promise<TaskState>;
     private runManualServerReview;
     continueDevRound(taskId: string): Promise<TaskState>;
-    private rollbackDispatchReviewPhase1;
-    private tearDownWatcherIfTaskTerminal;
     private devInitialSignalKinds;
     private resolveInitialDispatch;
     private mapTaskStateToExpectedWatchers;
@@ -676,7 +812,6 @@ export declare class AgentManager {
         replaceScope?: 'task' | 'agent';
         tokenOverride?: string;
     }): Promise<boolean>;
-    private emitManualReviewDevParkedQaFailedIntervention;
     retryTask(taskId: string): Promise<TaskState>;
     editTask(taskId: string, patch: {
         title?: string;
@@ -708,29 +843,13 @@ export declare class AgentManager {
     rearmGitReconciliationWatcher(taskId: string, opts?: {
         skipSnapshot?: boolean;
     }): Promise<void>;
-    rotateAndSetupPhaseSignal(taskId: string, agentId: string, expectedKinds: PhaseSignalKind | readonly PhaseSignalKind[]): Promise<{
+    rotateAndSetupPhaseSignal(taskId: string, agentId: string, expectedKinds: PhaseSignalKind | readonly PhaseSignalKind[], guard?: {
+        expectedStatus: TaskStatus;
+        expectedToken?: string;
+    }): Promise<{
         token: string;
         armed: boolean;
     }>;
-    rollbackVerdictArmFailure(taskId: string, restore: {
-        status: TaskStatus;
-        signalToken?: string;
-        reviewHeadAnchorSha?: string;
-        reviewDispatchedAt?: string;
-        reviewRoundPending?: boolean;
-        passToken?: string;
-        failToken?: string;
-        restorePair?: boolean;
-    }, opts?: {
-        expect?: {
-            status: TaskStatus;
-            signalToken?: string;
-        };
-        rearmSkipSnapshot?: boolean;
-    }): Promise<boolean>;
-    rearmPhaseSignalForCurrentPass(taskId: string, opts?: {
-        skipSnapshot?: boolean;
-    }): Promise<void>;
     parkTaskAtSpecReady(taskId: string, opts?: {
         specReviewRound?: number;
     }): Promise<TaskState | null>;
@@ -748,6 +867,7 @@ export declare class AgentManager {
         phase: ReviewPhase;
         recheck?: boolean;
         continuation?: boolean;
+        bumpRound?: boolean;
         content: string;
         interdiff?: string;
         diffstat?: string;
@@ -760,8 +880,11 @@ export declare class AgentManager {
         priorFindingsJson?: string;
         priorResponseJson?: string;
         reviewHeadAnchorSha?: string;
+        callerOwnsConsumedSignalFailure?: boolean;
+    }): Promise<TaskState | null>;
+    dispatchServerFixToDev(taskId: string, _findingsJson: string, opts?: {
+        callerOwnsConsumedSignalFailure?: boolean;
     }): Promise<TaskState | null>;
-    dispatchServerFixToDev(taskId: string, findingsJson: string): Promise<TaskState | null>;
     private projectRepoKey;
     computeCodeInterdiff(taskId: string, round: number): Promise<CodeInterdiffResult>;
     findLineageViolation(taskId: string, baseSha?: string): Promise<LineageViolation | null>;