brainclaw 1.28.1 → 1.28.3

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

@@ -2,6 +2,7 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { z } from 'zod';
+import { CapabilitySnapshotSchema } from '../execution-contract.js';
 import { memoryDir, writeFileAtomic } from '../io.js';
 import { nowISO } from '../ids.js';
 /**
@@ -31,9 +32,17 @@ export const GenerationFenceSchema = z.object({
     workspace_digest: z.string().min(1),
     authority_home: AuthorityHomeSchema,
 }).strict();
+export const GenerationExecutorSchema = z.object({
+    agent: z.string().min(1),
+    agent_id: z.string().min(1).optional(),
+    claim_id: z.string().min(1),
+    capability_snapshot: CapabilitySnapshotSchema,
+}).strict();
 export const AttemptGenerationSchema = GenerationFenceSchema.extend({
     schema_version: z.literal(ATTEMPT_AUTHORITY_VERSION),
     generation_kind: z.literal('attempt_generation'),
+    /** Executor ownership is generation-scoped so a reroute never inherits stale provenance. */
+    executor: GenerationExecutorSchema.optional(),
     created_at: z.string().min(1),
 }).strict();
 export const LaunchDecisionCellSchema = z.object({
@@ -145,8 +154,9 @@ function stableId(prefix, material) {
     return `${prefix}_${digest}`;
 }
 /** Compatible with the existing logical Assignment derivation. */
-export function deriveGenerationAssignmentId(turnId) {
-    return stableId('asgn', `${turnId}:assignment`);
+export function deriveGenerationAssignmentId(turnId, attemptEpoch = 0) {
+    const salt = attemptEpoch === 0 ? 'assignment' : `assignment:${attemptEpoch}`;
+    return stableId('asgn', `${turnId}:${salt}`);
 }
 /** Epoch zero preserves the existing run id; every later epoch is fresh. */
 export function deriveGenerationRunId(turnId, attemptEpoch) {
@@ -161,7 +171,7 @@ export function prepareInitialGeneration(input) {
         schema_version: ATTEMPT_AUTHORITY_VERSION,
         generation_kind: 'attempt_generation',
         turn_id: input.turn_id,
-        assignment_id: deriveGenerationAssignmentId(input.turn_id),
+        assignment_id: deriveGenerationAssignmentId(input.turn_id, 0),
         attempt_epoch: 0,
         run_id: deriveGenerationRunId(input.turn_id, 0),
         launch_nonce: input.launch_nonce ?? crypto.randomUUID(),
@@ -170,6 +180,7 @@ export function prepareInitialGeneration(input) {
         workspace_path: input.workspace_path,
         workspace_digest: input.workspace_digest,
         authority_home: AuthorityHomeSchema.parse(input.authority_home),
+        executor: input.executor,
         created_at: input.created_at ?? nowISO(),
     });
 }
@@ -178,6 +189,7 @@ export function prepareNextGeneration(current, input) {
     const attemptEpoch = parsed.attempt_epoch + 1;
     return AttemptGenerationSchema.parse({
         ...parsed,
+        assignment_id: deriveGenerationAssignmentId(parsed.turn_id, attemptEpoch),
         attempt_epoch: attemptEpoch,
         run_id: deriveGenerationRunId(parsed.turn_id, attemptEpoch),
         launch_nonce: input.launch_nonce ?? crypto.randomUUID(),
@@ -185,6 +197,7 @@ export function prepareNextGeneration(current, input) {
         workspace_id: deriveGenerationWorkspaceId(parsed.turn_id, attemptEpoch),
         workspace_path: input.workspace_path,
         workspace_digest: input.workspace_digest,
+        executor: input.executor ?? parsed.executor,
         created_at: input.created_at ?? nowISO(),
     });
 }
@@ -231,7 +244,7 @@ function assertValidSuccessor(current, next) {
     }
     const invalid = [
         current.turn_id !== next.turn_id && 'turn_id',
-        current.assignment_id !== next.assignment_id && 'assignment_id',
+        next.assignment_id === current.assignment_id && 'assignment_id',
         next.attempt_epoch !== current.attempt_epoch + 1 && 'attempt_epoch',
         next.run_id === current.run_id && 'run_id',
         next.launch_nonce === current.launch_nonce && 'launch_nonce',

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

@@ -446,7 +446,20 @@ export function findReservationByAssignmentId(assignmentId, cwd) {
     // coexists with a real LANE-RESULT (dispatch commits before spawn). Filtering here makes
     // the turn-owned discriminator explicit — a `prepared`/`aborted` reservation must never
     // route a lane to reconcileTurn (it has no live launch generation to accept evidence for).
-    return listReservations({ decision: 'committed' }, cwd).find((r) => r.child_ids.assignment_id === assignmentId);
+    return listReservations({ decision: 'committed' }, cwd).find((reservation) => {
+        if (reservation.child_ids.assignment_id === assignmentId)
+            return true;
+        try {
+            const root = cwd ?? reservation.store_root;
+            const initial = readInitialGeneration(root, reservation.turn_id);
+            return initial
+                ? listAttemptGenerations(root, initial).some((generation) => generation.assignment_id === assignmentId)
+                : false;
+        }
+        catch {
+            return false;
+        }
+    });
 }
 /** Run-scoping key for runtime evidence; undefined preserves legacy assignment-scoped paths. */
 export function currentAttemptRunIdForAssignment(assignmentId, cwd) {

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,