baxian 1.2.61 → 2.0.1

package/dist/agent/manager.d.ts

@@ -1,13 +1,13 @@
 import { type AgentGitPreflight } from './preflight.js';
-import type { AfterDone, BaxianConfig, AgentConfig, AgentBindingFacts, HostConfig, ProjectConfig, ReviewMode, ReviewPhase, SpecDocument, TaskState, TaskStatus } from '../shared/index.js';
+import type { AfterDone, BaxianConfig, AgentConfig, AgentRuntimeConfig, AgentBindingFacts, HostConfig, ProjectConfig, ReviewMode, ReviewDispatchLease, ReviewPhase, ReviewRound, ServerSignalKind, ServerSignalRecovery, ServerSignalRecoveryReason, SpecDocument, TaskPhase, TaskGenerationGuard, 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';
@@ -20,8 +20,10 @@ import type { PaneStreamerManager } from './pane-streamer-manager.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, type PlatformCliDescriptor } from './prompt.js';
+import { type ReviewStore } from '../state/review-store.js';
+import { type PostMergeCleanupContext, type PlatformCliDescriptor, type ServerFeedbackCorrectionPrompt } from './prompt.js';
+import { ApiError } from '../errors.js';
+export declare function isBenignDispatchConflict(err: unknown): err is ApiError;
 export interface EnsureSessionResult {
     ok: true;
     createdSession: boolean;
@@ -73,6 +75,8 @@ export declare class DispatchTerminalError extends Error {
     constructor(reason: DispatchTerminalReason, message: string, replDrained?: boolean);
 }
 export type EnsureSessionMode = 'create' | 'runtime' | 'recover';
+export type RedispatchCurrentPhaseGuard = TaskGenerationGuard;
+export type RedispatchCurrentPhaseResult = 'dispatched' | 'stale' | 'unsupported';
 export type DeletionClaimOutcome = {
     ok: true;
 } | {
@@ -93,9 +97,9 @@ export type DeletionClaimOutcome = {
     code: 'already-deleting';
     agentId: string;
 };
-export declare function buildLaunchCommand(agent: AgentConfig): string;
-export declare function launchCommandIn(dir: string, agent: AgentConfig): string;
-export declare function skillSubdirFor(runtime: AgentConfig['runtime']): string;
+export declare function buildLaunchCommand(agent: AgentRuntimeConfig): string;
+export declare function launchCommandIn(dir: string, agent: AgentRuntimeConfig): string;
+export declare function skillSubdirFor(runtime: AgentRuntimeConfig['runtime']): string;
 export interface AgentManagerDeps {
     config: BaxianConfig;
     agentStore: AgentStore;
@@ -108,7 +112,6 @@ 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;
@@ -123,13 +126,10 @@ export interface AgentManagerDeps {
     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;
@@ -151,6 +151,8 @@ interface SessionDispatchOpts {
         total: number;
     };
     serverPriorFindings?: string;
+    serverFindingsDigest?: string;
+    serverFeedbackCorrection?: ServerFeedbackCorrectionPrompt;
     serverPriorResponse?: string;
     specDocuments?: readonly SpecDocument[];
     armBeforeInject?: (ctx: DispatchArmContext) => Promise<boolean>;
@@ -158,13 +160,15 @@ 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;
     };
 }
 export interface ContinueSessionOpts extends SessionDispatchOpts {
-    postApproveRedispatchCount?: number;
+    postApproveEpisode?: PostApproveEpisodeKey;
+    serverReviewCheckout?: 'base';
     serverAfterDone?: {
         kind: 'branch' | 'pr';
         branch: string;
@@ -185,6 +189,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;
@@ -196,8 +206,18 @@ export type CodeInterdiffResult = {
     reason: 'released';
 };
 export interface ServerReviewDriver {
-    dispatchCodeReview(task: TaskState): Promise<boolean>;
-    dispatchSpecReview(task: TaskState): Promise<boolean>;
+    dispatchCodeReview(task: TaskState, opts?: {
+        bumpRound?: boolean;
+        expectedTask?: TaskGenerationGuard;
+        onSideEffect?: () => void;
+        settlePermit?: unknown;
+    }): Promise<boolean>;
+    dispatchSpecReview(task: TaskState, opts?: {
+        bumpRound?: boolean;
+        expectedTask?: TaskGenerationGuard;
+        onSideEffect?: () => void;
+        settlePermit?: unknown;
+    }): Promise<boolean>;
 }
 export declare function canDispatchWithBinding(binding: AgentBindingFacts | null | undefined): boolean;
 export declare const RECOVERABLE_QA_DISPATCH_HOLD_PHASES: Set<string>;
@@ -210,6 +230,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;
@@ -221,7 +249,6 @@ 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;
@@ -235,6 +262,7 @@ export declare class AgentManager {
     protected dispatchSettleTimeoutMs: number;
     protected dispatchAckResendIntervalMs: number;
     private taskMutationQueue;
+    private agentOperationQueues;
     private agentIndex;
     private platformRunner;
     private imageStagingRoot;
@@ -247,6 +275,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;
@@ -260,22 +289,36 @@ 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;
     getReviewStore(): ReviewStore | undefined;
+    putReviewRoundIfCurrent(taskId: string, data: ReviewRound, expectedTask: TaskGenerationGuard): Promise<boolean>;
+    deleteReviewExchangeIfCurrent(taskId: string, agent: AgentConfig, artifact: 'findings' | 'response', expectedTask: TaskGenerationGuard, expectedRecovery?: Pick<ServerSignalRecovery, 'mode' | 'signalKind' | 'phase' | 'round' | 'sourceToken' | 'failureSignature' | 'createdAt'>): Promise<boolean>;
     setServerReviewDriver(driver: ServerReviewDriver): void;
     effectiveReviewMode(projectId: string): ReviewMode;
     resolveAfterDone(task: TaskState): AfterDone;
     private coerceAfterDone;
+    commitServerAfterDone(taskId: string, expectedTask?: TaskGenerationGuard): 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;
@@ -285,6 +328,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;
@@ -341,7 +392,9 @@ export declare class AgentManager {
         allowAwaitingHuman?: boolean;
         clearAwaitingHuman?: boolean;
         fromCancelCleanup?: boolean;
-        expectedTask?: Pick<TaskState, 'status' | 'phase' | 'signalToken'>;
+        expectedTask?: Partial<TaskGenerationGuard>;
+        expectedReviewDispatch?: Pick<ReviewDispatchLease, 'generation' | 'claimId' | 'signalToken'>;
+        expectedPostApproveEpisode?: PostApproveEpisodeKey;
         expectedHold?: {
             phase: string | undefined;
             since: string | undefined;
@@ -355,6 +408,7 @@ export declare class AgentManager {
     reconcileTaskBranches(): Promise<void>;
     private readonly needInputRetry;
     private readonly needInputRetryInFlight;
+    private readonly gitReviewQaConfigAlerted;
     private readonly needInputWritesInFlight;
     private needInputWriteSeq;
     private readonly needInputArmLocks;
@@ -376,6 +430,7 @@ export declare class AgentManager {
     private confirmNeedInputAnswered;
     notifyHumanTerminalInput(agentId: string): Promise<void>;
     clearAwaitingHuman(agentId: string, opts?: {
+        expectedTaskId?: string;
         expectedHold?: {
             phase?: string;
             since?: string;
@@ -407,7 +462,12 @@ 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;
+        expectedTask?: TaskGenerationGuard;
+        expectedLockToken?: string;
+    }): Promise<void>;
     failTasksForAgent(agentId: string, reason: string, opts?: {
         deferPartnerCleanup?: boolean;
     }): Promise<{
@@ -423,10 +483,12 @@ export declare class AgentManager {
         phase: string | undefined;
         since: string | undefined;
         nonce: string | undefined;
-    }): Promise<boolean>;
-    redispatchTaskPromptAfterReplRestart(agentId: string, taskId: string): Promise<boolean>;
+    }, extraCurrent?: (fresh: TaskState) => Promise<boolean>): Promise<boolean>;
+    private runRotatedReplay;
+    redispatchTaskPromptAfterReplRestart(agentId: string, taskId: string, expected?: RedispatchCurrentPhaseGuard): Promise<boolean>;
+    redispatchCurrentTaskPhase(taskId: string, expected: RedispatchCurrentPhaseGuard): Promise<RedispatchCurrentPhaseResult>;
     private replayApprovedHolderAfterReplRestart;
-    private rebuildPostApproveCompletion;
+    private holdIncompleteGitPostApproveEpisode;
     prepareRemoveTargets(agentId: string): {
         targets: string[];
     };
@@ -440,26 +502,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;
@@ -469,13 +528,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';
@@ -500,10 +562,44 @@ 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;
+        expectedTask?: TaskGenerationGuard;
+        allowDuringComplete?: boolean;
+        patch?: Partial<Pick<TaskState, 'prNumber' | 'prUrl' | 'latestHeadSha' | 'branch' | 'baseBranch' | 'replyActorId' | 'replyActorStatus' | 'pendingPrSignalToken'>>;
+    }): Promise<TransitionResult | null>;
+    claimGitReviewDispatch(taskId: string, expectedGeneration?: string, expectedTask?: TaskGenerationGuard): 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;
@@ -515,26 +611,17 @@ 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>;
@@ -543,6 +630,7 @@ export declare class AgentManager {
     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<{
@@ -556,15 +644,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>;
@@ -576,17 +668,39 @@ 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' | 'agentId' | '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[];
+        expectTask?: TaskGenerationGuard;
         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;
+        expectAgentLock?: {
+            agentId: string;
+            token: string;
+        };
+    }, patch?: Partial<Pick<TaskState, 'reviewRound' | 'agentId' | 'prNumber' | 'prUrl' | 'baseBranch' | 'qaAgentId' | 'latestHeadSha' | 'reviewHeadAnchorSha' | 'reviewDispatchedAt' | 'fixDispatchedAt' | 'specReviewRound' | 'signalToken' | 'passToken' | 'failToken' | 'reviewRoundPending' | 'reviewDispatch' | 'phase' | 'batchIndex' | 'batchTotal' | 'reviewCheckoutMode' | 'branch' | 'maxRoundsContinues'>>): Promise<TransitionResult | null>;
     private createRunnerFor;
     private createRepoStore;
     private ensureWorkdir;
@@ -659,7 +773,9 @@ export declare class AgentManager {
     markAgentWaiting(agentId: string, expectedTaskId: string, opts?: {
         allowAwaitingHuman?: boolean;
         clearAwaitingHuman?: boolean;
-        expectedTask?: Pick<TaskState, 'status' | 'phase' | 'signalToken'>;
+        expectedTask?: Partial<TaskGenerationGuard>;
+        expectedReviewDispatch?: Pick<ReviewDispatchLease, 'generation' | 'claimId' | 'signalToken'>;
+        expectedPostApproveEpisode?: PostApproveEpisodeKey;
         expectedHold?: {
             phase: string | undefined;
             since: string | undefined;
@@ -680,22 +796,36 @@ export declare class AgentManager {
         description: string;
         preferredAgentId: string;
     }): Promise<void>;
+    private gitReviewClaimMatches;
+    private gitReviewDispatchMatches;
+    dispatchGitReviewLease(taskId: string, opts?: {
+        expectedGeneration?: string;
+        expectedTask?: TaskGenerationGuard;
+        pendingBudget?: {
+            since: number;
+            budgetAlerted?: boolean;
+        };
+        onQaAcquired?: (lockToken: string) => void;
+        onSideEffect?: () => void;
+    }): Promise<TaskState>;
     dispatchReviewToQa(taskId: string, opts?: {
         fromStatus?: TaskStatus[];
         bumpRound?: boolean;
         expectSignalToken?: string;
+        expectPhase?: TaskPhase;
+        expectedTask?: TaskGenerationGuard;
         qaPhase?: 'review' | 'recheck';
         pendingBudget?: {
             since: number;
             budgetAlerted?: boolean;
         };
-        expectReviewDispatchPending?: boolean;
         onPassArmed?: (armedToken: string) => void;
+        onQaAcquired?: (lockToken: string) => void;
+        onSideEffect?: () => void;
+        confirmUncertainNotDelivered?: boolean;
     }): Promise<TaskState>;
     private runManualServerReview;
     continueDevRound(taskId: string): Promise<TaskState>;
-    private rollbackDispatchReviewPhase1;
-    private tearDownWatcherIfTaskTerminal;
     private devInitialSignalKinds;
     private resolveInitialDispatch;
     private mapTaskStateToExpectedWatchers;
@@ -706,7 +836,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;
@@ -738,31 +867,16 @@ 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;
+        expectedTask?: TaskGenerationGuard;
     }): Promise<TaskState | null>;
     submitSpecVerdict(taskId: string, verdict: 'approve' | 'request-changes' | 'archive', comments?: string): Promise<TaskState>;
     private executeSpecVerdict;
@@ -773,11 +887,12 @@ export declare class AgentManager {
     private synthesizeEmptyCodeRound;
     private isResearchHandoff;
     private dispatchCodePhasePrompt;
-    transitionToCodePhase(taskId: string): Promise<TaskState | null>;
+    transitionToCodePhase(taskId: string, expectedTask?: TaskGenerationGuard): Promise<TaskState | null>;
     dispatchServerReviewToQa(taskId: string, opts: {
         phase: ReviewPhase;
         recheck?: boolean;
         continuation?: boolean;
+        bumpRound?: boolean;
         content: string;
         interdiff?: string;
         diffstat?: string;
@@ -790,8 +905,15 @@ export declare class AgentManager {
         priorFindingsJson?: string;
         priorResponseJson?: string;
         reviewHeadAnchorSha?: string;
+        callerOwnsConsumedSignalFailure?: boolean;
+        settlePermit?: unknown;
+        expectedTask?: TaskGenerationGuard;
+        onSideEffect?: () => void;
+    }): Promise<TaskState | null>;
+    dispatchServerFixToDev(taskId: string, _findingsJson: string, opts?: {
+        callerOwnsConsumedSignalFailure?: boolean;
+        expectedTask?: TaskGenerationGuard;
     }): 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>;