brainclaw 1.28.1 → 1.28.2

package/dist/core/loops/attempt-takeover.js

@@ -1,16 +1,36 @@
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import { ensureAgentRunProjection, loadAgentRun, transitionAgentRun } from '../agentruns.js';
-import { loadAssignment } from '../assignments.js';
+import { convergeAssignmentToTerminal, loadAssignment, transitionAssignment } from '../assignments.js';
 import { createRuntimeEvent } from '../events.js';
 import { nowISO } from '../ids.js';
 import { prepareAttemptTakeoverV2 } from './attempt-authority.js';
-import { generationDigest } from './attempt-generations.js';
+import { generationDigest, resolveTurnGenerationChain } from './attempt-generations.js';
 import { commitViaIntent } from './commit-intent.js';
 import { evidenceDigest } from './evidence.js';
 import { withLoopLock } from './lock.js';
 import { getReservation } from './attempt-reservation.js';
 import { getLoop, listLoopEvents } from './store.js';
+/**
+ * Signals that the immutable successor generation already won even though a
+ * replayable projection failed afterward. Callers must never roll claims back
+ * on this error; replaying the same takeover input repairs the projections.
+ */
+export class AttemptTakeoverCommittedError extends Error {
+    turn_id;
+    assignment_id;
+    run_id;
+    attempt_epoch;
+    constructor(takeover, cause) {
+        super(`takeover generation ${takeover.next_generation.attempt_epoch} committed; projection repair required: ${cause instanceof Error ? cause.message : String(cause)}`);
+        this.name = 'AttemptTakeoverCommittedError';
+        this.turn_id = takeover.next_generation.turn_id;
+        this.assignment_id = takeover.next_generation.assignment_id;
+        this.run_id = takeover.next_generation.run_id;
+        this.attempt_epoch = takeover.next_generation.attempt_epoch;
+        this.cause = cause;
+    }
+}
 /**
  * Operator/engine takeover transaction.
  *
@@ -25,66 +45,137 @@ export function takeoverLoopAttempt(input) {
         throw new Error(`takeover workspace must already exist as an isolated directory: ${input.next_workspace_path}`);
     }
     const authorityActor = input.actor_id ?? input.actor;
-    const transaction = withLoopLock({
-        cwd: input.cwd,
-        intent: 'attempt-takeover',
-        agentId: authorityActor,
-        scope: { kind: 'loop', loopId: input.loop_id },
-        work: () => {
-            const loop = getLoop(input.loop_id, input.cwd);
-            if (!loop || loop.status !== 'open')
-                throw new Error(`loop ${input.loop_id} is not open`);
-            if (loop.created_by !== authorityActor) {
-                throw new Error(`attempt takeover requires loop coordinator ${loop.created_by}; caller is ${authorityActor}`);
+    let committed;
+    let transaction;
+    try {
+        transaction = withLoopLock({
+            cwd: input.cwd,
+            intent: 'attempt-takeover',
+            agentId: authorityActor,
+            scope: { kind: 'loop', loopId: input.loop_id },
+            work: () => {
+                const loop = getLoop(input.loop_id, input.cwd);
+                if (!loop || loop.status !== 'open')
+                    throw new Error(`loop ${input.loop_id} is not open`);
+                if (loop.created_by !== authorityActor) {
+                    throw new Error(`attempt takeover requires loop coordinator ${loop.created_by}; caller is ${authorityActor}`);
+                }
+                const slot = loop.slots.find((candidate) => candidate.slot_id === input.slot_id);
+                if (!slot)
+                    throw new Error(`slot ${input.slot_id} not found in loop ${input.loop_id}`);
+                const reservation = getReservation(input.turn_id, input.cwd);
+                if (!reservation || reservation.loop_id !== loop.id || reservation.slot_id !== slot.slot_id) {
+                    throw new Error(`turn ${input.turn_id} does not own ${loop.id}/${slot.slot_id}`);
+                }
+                const activeGeneration = resolveTurnGenerationChain(input.cwd, input.turn_id)?.latest_generation;
+                const activeAssignmentId = activeGeneration?.assignment_id ?? reservation.child_ids.assignment_id;
+                if (slot.current_turn_id !== input.turn_id || slot.assignment_id !== activeAssignmentId) {
+                    throw new Error(`slot ${slot.slot_id} is no longer bound to turn ${input.turn_id}`);
+                }
+                const takeover = prepareAttemptTakeoverV2({ ...input, actor: authorityActor });
+                committed = takeover;
+                input.on_stage?.('authority_committed');
+                const duplicate = listLoopEvents(loop.id, input.cwd).some((event) => event.kind === 'attempt_generation_changed'
+                    && event.turn_id === input.turn_id
+                    && event.to_epoch === takeover.next_generation.attempt_epoch
+                    && event.to_run_id === takeover.next_generation.run_id);
+                if (duplicate)
+                    return { loop, takeover, reservation };
+                const now = nowISO();
+                const mutationId = crypto.randomUUID();
+                const executor = takeover.next_generation.executor ?? {
+                    agent: reservation.agent,
+                    agent_id: reservation.agent_id,
+                    claim_id: reservation.claim_id,
+                    capability_snapshot: reservation.capability_snapshot,
+                };
+                const event = {
+                    event_id: crypto.randomUUID(),
+                    loop_id: loop.id,
+                    seq: loop.version + 1,
+                    at: now,
+                    by: authorityActor,
+                    mutation_id: mutationId,
+                    kind: 'attempt_generation_changed',
+                    slot_id: slot.slot_id,
+                    turn_id: input.turn_id,
+                    assignment_id: takeover.next_generation.assignment_id,
+                    claim_id: executor.claim_id,
+                    agent: executor.agent,
+                    agent_id: executor.agent_id,
+                    from_epoch: takeover.previous_generation.attempt_epoch,
+                    to_epoch: takeover.next_generation.attempt_epoch,
+                    from_run_id: takeover.previous_generation.run_id,
+                    to_run_id: takeover.next_generation.run_id,
+                    close_digest: evidenceDigest(takeover.close_cell),
+                    cause: input.cause,
+                };
+                const next = {
+                    ...loop,
+                    version: loop.version + 1,
+                    mutation_id: mutationId,
+                    slots: loop.slots.map((candidate) => candidate.slot_id === slot.slot_id
+                        ? {
+                            ...candidate,
+                            agent: executor.agent,
+                            agent_id: executor.agent_id,
+                            assignment_id: takeover.next_generation.assignment_id,
+                            claim_id: executor.claim_id,
+                            current_turn_id: input.turn_id,
+                            status: 'assigned',
+                        }
+                        : candidate),
+                    updated_at: now,
+                };
+                commitViaIntent({ loop_id: loop.id, base_version: loop.version, events: [event], thread_snapshot: next }, input.cwd);
+                input.on_stage?.('loop_committed');
+                return { loop: next, takeover, reservation };
+            },
+        });
+    }
+    catch (error) {
+        if (committed)
+            throw new AttemptTakeoverCommittedError(committed, error);
+        throw error;
+    }
+    const { takeover, reservation } = transaction;
+    const executor = takeover.next_generation.executor ?? {
+        agent: reservation.agent,
+        agent_id: reservation.agent_id,
+        claim_id: reservation.claim_id,
+        capability_snapshot: reservation.capability_snapshot,
+    };
+    if (takeover.previous_generation.assignment_id !== takeover.next_generation.assignment_id) {
+        try {
+            const previousAssignmentId = takeover.previous_generation.assignment_id;
+            const previousAssignment = loadAssignment(previousAssignmentId, input.cwd);
+            const predecessorTerminal = input.predecessor_assignment_terminal ?? 'cancelled';
+            const statusReason = `fenced by ${input.mode ?? 'takeover'} to epoch ${takeover.next_generation.attempt_epoch}`;
+            // System convergence intentionally covers only file-worker states
+            // (offered/accepted/started). A takeover can win before launch while the
+            // predecessor is still created, or during retry setup; both states have
+            // a legal direct cancellation edge and must be terminal before the stable
+            // claim is rebound to the successor generation.
+            if (predecessorTerminal === 'rerouted' && previousAssignment && previousAssignment.status !== 'rerouted') {
+                transitionAssignment(previousAssignmentId, 'rerouted', {
+                    actor: input.actor,
+                    syncAgentRun: false,
+                    status_reason: statusReason,
+                }, input.cwd);
             }
-            const slot = loop.slots.find((candidate) => candidate.slot_id === input.slot_id);
-            if (!slot)
-                throw new Error(`slot ${input.slot_id} not found in loop ${input.loop_id}`);
-            const reservation = getReservation(input.turn_id, input.cwd);
-            if (!reservation || reservation.loop_id !== loop.id || reservation.slot_id !== slot.slot_id) {
-                throw new Error(`turn ${input.turn_id} does not own ${loop.id}/${slot.slot_id}`);
+            else if (previousAssignment?.status === 'created' || previousAssignment?.status === 'retrying') {
+                transitionAssignment(previousAssignmentId, 'cancelled', {
+                    actor: input.actor,
+                    syncAgentRun: false,
+                    status_reason: statusReason,
+                }, input.cwd);
             }
-            if (slot.current_turn_id !== input.turn_id || slot.assignment_id !== reservation.child_ids.assignment_id) {
-                throw new Error(`slot ${slot.slot_id} is no longer bound to turn ${input.turn_id}`);
+            else {
+                convergeAssignmentToTerminal(previousAssignmentId, 'cancelled', statusReason, input.cwd);
             }
-            const takeover = prepareAttemptTakeoverV2({ ...input, actor: authorityActor });
-            const duplicate = listLoopEvents(loop.id, input.cwd).some((event) => event.kind === 'attempt_generation_changed'
-                && event.turn_id === input.turn_id
-                && event.to_epoch === takeover.next_generation.attempt_epoch
-                && event.to_run_id === takeover.next_generation.run_id);
-            if (duplicate)
-                return { loop, takeover, reservation };
-            const now = nowISO();
-            const mutationId = crypto.randomUUID();
-            const event = {
-                event_id: crypto.randomUUID(),
-                loop_id: loop.id,
-                seq: loop.version + 1,
-                at: now,
-                by: authorityActor,
-                mutation_id: mutationId,
-                kind: 'attempt_generation_changed',
-                slot_id: slot.slot_id,
-                turn_id: input.turn_id,
-                assignment_id: takeover.next_generation.assignment_id,
-                from_epoch: takeover.previous_generation.attempt_epoch,
-                to_epoch: takeover.next_generation.attempt_epoch,
-                from_run_id: takeover.previous_generation.run_id,
-                to_run_id: takeover.next_generation.run_id,
-                close_digest: evidenceDigest(takeover.close_cell),
-                cause: input.cause,
-            };
-            const next = {
-                ...loop,
-                version: loop.version + 1,
-                mutation_id: mutationId,
-                updated_at: now,
-            };
-            commitViaIntent({ loop_id: loop.id, base_version: loop.version, events: [event], thread_snapshot: next }, input.cwd);
-            return { loop: next, takeover, reservation };
-        },
-    });
-    const { takeover, reservation } = transaction;
+        }
+        catch { /* immutable close cell already fences the old assignment */ }
+    }
     const assignment = loadAssignment(takeover.next_generation.assignment_id, input.cwd);
     const previousRun = loadAgentRun(takeover.previous_generation.run_id, input.cwd);
     if (previousRun && !['completed', 'failed', 'cancelled', 'timed_out', 'interrupted'].includes(previousRun.status)) {
@@ -97,23 +188,29 @@ export function takeoverLoopAttempt(input) {
         }
         catch { /* immutable close cell already fences the old run */ }
     }
-    ensureAgentRunProjection({
-        id: takeover.next_generation.run_id,
-        short_label: takeover.next_generation.run_id,
-        assignment_id: takeover.next_generation.assignment_id,
-        claim_id: reservation.claim_id,
-        attempt_index: takeover.next_generation.attempt_epoch + 1,
-        agent: reservation.agent,
-        agent_id: reservation.agent_id,
-        transport: 'cli_spawn',
-        status: 'created',
-        scope: assignment?.scope ?? reservation.execution_contract?.workspace_policy.scope ?? reservation.cwd,
-        description: assignment?.description ?? `Attempt generation ${takeover.next_generation.attempt_epoch} for ${input.turn_id}`,
-        worktree_path: takeover.next_generation.workspace_path,
-        execution_contract_ref: takeover.execution_contract_ref,
-        capability_snapshot: reservation.capability_snapshot,
-        tags: ['turn-owned', 'loop', 'attempt-takeover', `attempt-generation:${takeover.next_generation.attempt_epoch}`],
-    }, input.cwd);
+    try {
+        ensureAgentRunProjection({
+            id: takeover.next_generation.run_id,
+            short_label: takeover.next_generation.run_id,
+            assignment_id: takeover.next_generation.assignment_id,
+            claim_id: executor.claim_id,
+            attempt_index: takeover.next_generation.attempt_epoch + 1,
+            agent: executor.agent,
+            agent_id: executor.agent_id,
+            transport: 'cli_spawn',
+            status: 'created',
+            scope: assignment?.scope ?? reservation.execution_contract?.workspace_policy.scope ?? reservation.cwd,
+            description: assignment?.description ?? `Attempt generation ${takeover.next_generation.attempt_epoch} for ${input.turn_id}`,
+            worktree_path: takeover.next_generation.workspace_path,
+            execution_contract_ref: takeover.execution_contract_ref,
+            capability_snapshot: executor.capability_snapshot,
+            tags: ['turn-owned', 'loop', 'attempt-takeover', `attempt-generation:${takeover.next_generation.attempt_epoch}`],
+        }, input.cwd);
+        input.on_stage?.('run_projected');
+    }
+    catch (error) {
+        throw new AttemptTakeoverCommittedError(takeover, error);
+    }
     try {
         createRuntimeEvent({
             agent: input.actor,