brainclaw 1.28.1 → 1.28.2

package/dist/core/loops/reconcile-turn.js

@@ -1,11 +1,11 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { getReservation, evidenceMatchesAttempt, currentNonce, launchGrant, resolveTurnId } from './attempt-reservation.js';
+import { getReservation, evidenceMatchesAttempt, currentNonce, findReservationByAssignmentId, findReservationByRunId, launchGrant, resolveTurnId } from './attempt-reservation.js';
 import { getLoop } from './store.js';
 import { completeTurnWithEvidence, addArtifactWithEvidence, complete_turn, advance } from './verbs.js';
 import { reducerForKind } from './result-reducers.js';
 import { loadAgentRun, recordExecutionContractAnomaly, transitionAgentRun } from '../agentruns.js';
-import { loadAssignment, transitionAssignment } from '../assignments.js';
+import { convergeAssignmentToTerminal, loadAssignment, transitionAssignment } from '../assignments.js';
 import { loadClaim, releaseClaim, releaseClaimIfActive } from '../claims.js';
 import { createRuntimeEvent } from '../events.js';
 import { readCompletionSignals, readContractAck } from '../runtime-signals.js';
@@ -17,6 +17,143 @@ import { executionContractForGeneration, settleActiveAttemptGenerationV2 } from
 import { fenceForGeneration, resolveTurnGenerationChain } from './attempt-generations.js';
 import { readLocalAuthorityHome } from './attempt-rollout.js';
 import { LaneResultSchema } from '../schema.js';
+/** Prefer the current run-scoped runtime channel, with assignment-scoped files
+ * retained only as a compatibility fallback for pre-run-keyed dispatches. */
+function readAttemptCompletionSignals(root, assignmentId, runId) {
+    const scoped = readCompletionSignals(root, assignmentId, runId);
+    const legacy = readCompletionSignals(root, assignmentId);
+    return {
+        completed: scoped.completed ?? legacy.completed,
+        failed: scoped.failed ?? legacy.failed,
+    };
+}
+function readAttemptContractAck(root, assignmentId, runId) {
+    return readContractAck(root, assignmentId, runId) ?? readContractAck(root, assignmentId);
+}
+/**
+ * Resolve the authoritative generation coordinates for a worker result.
+ *
+ * A file-fallback LANE-RESULT may omit the mechanical fence fields because the
+ * wrapper already wrote them to its completion signal. The worker-controlled
+ * fields always win when present, so stale/mismatched evidence is still rejected
+ * by reconcileTurn. Missing fields are filled only from the reservation's active
+ * generation and its run-keyed completion signal.
+ */
+export function turnOwnedLaneEvidence(lane, cwd, reservationOverride) {
+    const reservation = reservationOverride ?? findReservationByAssignmentId(lane.assignment_id, cwd);
+    if (!reservation)
+        return undefined;
+    const chain = resolveTurnGenerationChain(cwd, reservation.turn_id);
+    const generation = chain?.latest_generation;
+    const runId = generation?.run_id ?? reservation.child_ids.run_id;
+    const completion = readAttemptCompletionSignals(cwd, generation?.assignment_id ?? reservation.child_ids.assignment_id, runId).completed;
+    const bootstrapAck = readAttemptContractAck(cwd, generation?.assignment_id ?? reservation.child_ids.assignment_id, runId);
+    // The pre-exec bootstrap ACK is the first durable, coordinator-authored proof
+    // that this exact launch generation crossed into the worker. Real file-fallback
+    // workers commonly write LANE-RESULT before the wrapper can emit its terminal
+    // sentinel, and they do not echo the mechanical turn/run/nonce tuple. In that
+    // window, enrich only from an ACCEPTED run-keyed ACK; reconcileTurn still checks
+    // every coordinate against the active generation, so a rejected/foreign/stale
+    // ACK cannot authorize convergence and an explicit lane value always wins.
+    const acceptedAck = bootstrapAck?.status === 'accepted' ? bootstrapAck : undefined;
+    const nonce = lane.nonce ?? completion?.nonce ?? acceptedAck?.nonce;
+    if (!nonce && !reservation.execution_contract_ref)
+        return undefined;
+    return {
+        reservation,
+        nonce,
+        run_id: runId,
+        attempt_epoch: lane.attempt_epoch ?? completion?.attempt_epoch ?? acceptedAck?.attempt_epoch ?? generation?.attempt_epoch,
+        workspace_digest: lane.workspace_digest ?? completion?.workspace_digest ?? acceptedAck?.workspace_digest ?? generation?.workspace_digest,
+        contract_hash: lane.execution_contract_hash
+            ?? completion?.contract_hash
+            ?? acceptedAck?.contract_hash
+            ?? generation?.contract_hash
+            ?? reservation.execution_contract_ref?.hash,
+        capability_snapshot_hash: lane.capability_snapshot_hash
+            ?? completion?.capability_snapshot_hash
+            ?? acceptedAck?.capability_snapshot_hash
+            ?? reservation.execution_contract_ref?.snapshot_hash,
+    };
+}
+/** Reconcile one parsed worker result through the single AttemptAuthority path. */
+export function reconcileTurnOwnedLane(lane, cwd, evidence, actor) {
+    const ev = evidence ?? turnOwnedLaneEvidence(lane, cwd);
+    if (!ev)
+        return undefined;
+    const { reservation } = ev;
+    const enrichedLane = {
+        ...lane,
+        turn_id: lane.turn_id ?? reservation.turn_id,
+        run_id: lane.run_id ?? ev.run_id,
+        nonce: lane.nonce ?? ev.nonce,
+        attempt_epoch: lane.attempt_epoch ?? ev.attempt_epoch,
+        workspace_digest: lane.workspace_digest ?? ev.workspace_digest,
+        execution_contract_hash: lane.execution_contract_hash ?? ev.contract_hash,
+        capability_snapshot_hash: lane.capability_snapshot_hash ?? ev.capability_snapshot_hash,
+    };
+    const loop = getLoop(reservation.loop_id, cwd);
+    const critiques = loop?.kind === 'ideation'
+        && reservation.phase === 'critique'
+        && lane.artifact_type === 'critique'
+        && (lane.body ?? '').trim().length > 0
+        ? [{ body: lane.body.trim() }]
+        : undefined;
+    const result = reconcileTurn({ turn_id: reservation.turn_id, lane: enrichedLane, cwd, critiques, actor });
+    return { reservation, result };
+}
+/**
+ * Lazy read-path bridge: consume the exact LANE-RESULT owned by one AgentRun.
+ * Invalid JSON, foreign assignment ids, stale generation workspaces, or missing
+ * turn fences are reported without mutating slot/assignment/run/claim state.
+ */
+export function reconcileLaneResultForRun(run, cwd, actor = 'reconciler') {
+    if (!run.worktree_path)
+        return { found: false, valid: false, reason: 'run has no worktree_path' };
+    const resultPath = path.join(run.worktree_path, 'LANE-RESULT.json');
+    if (!fs.existsSync(resultPath))
+        return { found: false, valid: false, reason: 'LANE-RESULT.json not found' };
+    let lane;
+    try {
+        lane = LaneResultSchema.parse(JSON.parse(fs.readFileSync(resultPath, 'utf8')));
+    }
+    catch (err) {
+        return { found: true, valid: false, reason: `invalid LANE-RESULT.json: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    if (lane.assignment_id !== run.assignment_id) {
+        return { found: true, valid: false, lane, reason: `foreign assignment_id ${lane.assignment_id}; expected ${run.assignment_id}` };
+    }
+    const reservation = findReservationByRunId(run.id, cwd);
+    if (!reservation)
+        return { found: true, valid: false, lane, reason: `run ${run.id} has no owning turn reservation` };
+    const chain = resolveTurnGenerationChain(cwd, reservation.turn_id);
+    const generation = chain?.latest_generation;
+    if (generation && generation.run_id !== run.id) {
+        return { found: true, valid: false, lane, reservation, reason: `run ${run.id} is not the active generation ${generation.run_id}` };
+    }
+    if (generation) {
+        const actualWorkspace = normalizedWorkspace(run.worktree_path);
+        const expectedWorkspace = normalizedWorkspace(generation.workspace_path);
+        if (!actualWorkspace || !expectedWorkspace || actualWorkspace !== expectedWorkspace) {
+            return { found: true, valid: false, lane, reservation, reason: 'run worktree does not match the active attempt generation workspace' };
+        }
+    }
+    const evidence = turnOwnedLaneEvidence(lane, cwd, reservation);
+    if (!evidence) {
+        return { found: true, valid: false, lane, reservation, reason: 'LANE-RESULT lacks a run-keyed launch fence and no completion signal supplies one' };
+    }
+    const reconciled = reconcileTurnOwnedLane(lane, cwd, evidence, actor);
+    if (!reconciled)
+        return { found: true, valid: false, lane, reservation, reason: 'turn-owned reconciliation unavailable' };
+    return {
+        found: true,
+        valid: reconciled.result.reconciled,
+        lane,
+        reservation,
+        result: reconciled.result,
+        reason: reconciled.result.reason,
+    };
+}
 // The terminal loop statuses (LOOP_STATUSES = open|paused|completed|blocked|cancelled).
 // 'blocked' is LOAD-BEARING (pln#630 PR3b): the iteration cap closes a fix cycle to
 // `blocked`, and a blocked loop must be treated as terminal both by the idempotent
@@ -49,12 +186,22 @@ function settleRunCompleted(runId, actor, cwd) {
 function settleAssignment(assignmentId, actor, cwd) {
     try {
         const asg = loadAssignment(assignmentId, cwd);
-        if (asg && asg.status !== 'completed' && asg.status !== 'cancelled') {
+        if (!asg || asg.status === 'completed' || asg.status === 'cancelled')
+            return;
+        if (asg.status === 'expired') {
             try {
                 transitionAssignment(assignmentId, 'completed', { actor }, cwd);
             }
-            catch { /* transition may be illegal from current state — best-effort */ }
+            catch { /* concurrent terminal transition */ }
+            return;
+        }
+        if (asg.status === 'created') {
+            try {
+                transitionAssignment(assignmentId, 'offered', { actor }, cwd);
+            }
+            catch { /* concurrent transition */ }
         }
+        convergeAssignmentToTerminal(assignmentId, 'completed', 'reconcileTurn: turn-keyed worker result accepted', cwd);
     }
     catch { /* best-effort */ }
 }
@@ -100,6 +247,7 @@ export function reconcileTurn(input) {
         ? resolvedGeneration.latest_generation
         : undefined;
     const activeRunId = activeGeneration?.run_id ?? reservation.child_ids.run_id;
+    const activeAssignmentId = activeGeneration?.assignment_id ?? reservation.child_ids.assignment_id;
     const activeContractRef = activeGeneration
         ? executionContractForGeneration(reservation, activeGeneration).ref
         : reservation.execution_contract_ref;
@@ -133,8 +281,8 @@ export function reconcileTurn(input) {
         };
     }
     if (activeContractRef) {
-        const completion = readCompletionSignals(cwd ?? process.cwd(), reservation.child_ids.assignment_id, activeGeneration?.run_id).completed;
-        const bootstrapAck = readContractAck(cwd ?? process.cwd(), reservation.child_ids.assignment_id, activeGeneration?.run_id);
+        const completion = readAttemptCompletionSignals(cwd ?? process.cwd(), activeAssignmentId, activeRunId).completed;
+        const bootstrapAck = readAttemptContractAck(cwd ?? process.cwd(), activeAssignmentId, activeRunId);
         const accepted = {
             contract_hash: lane.execution_contract_hash ?? completion?.contract_hash ?? '',
             capability_snapshot_hash: lane.capability_snapshot_hash ?? completion?.capability_snapshot_hash ?? '',
@@ -177,7 +325,7 @@ export function reconcileTurn(input) {
                     event_type: 'run_blocked',
                     text: `reconcileTurn: post-crossing execution-contract acceptance anomaly for ${turn_id}; convergence WITHHELD and respawn=false`,
                     tags: ['loops', 'reconcile', 'contract-anomaly', 'turn-attempt'],
-                    assignment_id: reservation.child_ids.assignment_id,
+                    assignment_id: activeAssignmentId,
                     run_id: activeRunId,
                     status_reason: 'execution_contract_acceptance_mismatch',
                 }, cwd);
@@ -198,13 +346,13 @@ export function reconcileTurn(input) {
     // LANE-RESULT then exited non-zero (turn-keyed failed sentinel) is a conflict,
     // not a clean close. ──
     try {
-        const bodies = readCompletionSignals(cwd ?? process.cwd(), reservation.child_ids.assignment_id, activeGeneration?.run_id);
+        const bodies = readAttemptCompletionSignals(cwd ?? process.cwd(), activeAssignmentId, activeRunId);
         const matchedCompleted = bodies.completed?.status === 'completed' && evidenceMatchesAttempt(reservation, {
-            assignment_id: reservation.child_ids.assignment_id,
+            assignment_id: activeAssignmentId,
             ...bodies.completed,
         });
         const matchedFailed = bodies.failed?.status === 'failed' && evidenceMatchesAttempt(reservation, {
-            assignment_id: reservation.child_ids.assignment_id,
+            assignment_id: activeAssignmentId,
             ...bodies.failed,
         });
         if (matchedFailed && (matchedCompleted || lane.status === 'completed')) {
@@ -214,7 +362,7 @@ export function reconcileTurn(input) {
                     event_type: 'run_blocked',
                     text: `reconcileTurn: turn ${turn_id} has a completed(lane/sentinel)+failed(sentinel) contradiction — auto-stop WITHHELD (§13 R4), escalating to human`,
                     tags: ['loops', 'reconcile', 'conflict', 'turn-attempt'],
-                    assignment_id: reservation.child_ids.assignment_id,
+                    assignment_id: activeAssignmentId,
                     run_id: activeRunId,
                     status_reason: 'turn_evidence_contradiction',
                 }, cwd);
@@ -307,6 +455,13 @@ function convergeLockedTurn(reservation, input, actor, cwd) {
     }
     const acceptedGeneration = generationState?.latest_generation;
     const acceptedRunId = acceptedGeneration?.run_id ?? reservation.child_ids.run_id;
+    const acceptedAssignmentId = acceptedGeneration?.assignment_id ?? reservation.child_ids.assignment_id;
+    const acceptedExecutor = acceptedGeneration?.executor ?? {
+        agent: reservation.agent,
+        agent_id: reservation.agent_id,
+        claim_id: reservation.claim_id,
+        capability_snapshot: reservation.capability_snapshot,
+    };
     const acceptedNonce = acceptedGeneration?.launch_nonce ?? reservation.launch?.token;
     const acceptedEpoch = acceptedGeneration?.attempt_epoch ?? reservation.epoch;
     const acceptedContractHash = acceptedGeneration?.contract_hash
@@ -330,7 +485,7 @@ function convergeLockedTurn(reservation, input, actor, cwd) {
     // transition but BEFORE its own deferred release would otherwise leak the retained claim
     // until the staleness sweep — releaseCoordinatorClaim is idempotent (no-op if not active).
     if (LOOP_TERMINAL.has(loop.status)) {
-        releaseCoordinatorClaim(loadAssignment(reservation.child_ids.assignment_id, cwd)?.claim_id ?? reservation.claim_id, cwd);
+        releaseCoordinatorClaim(loadAssignment(acceptedAssignmentId, cwd)?.claim_id ?? acceptedExecutor.claim_id, cwd);
         return { reconciled: true, reason: `loop already ${loop.status} (idempotent no-op)`, artifacts_added: 0, loop_status: loop.status };
     }
     // ── Idempotency (review Findings 1+2): a TERMINAL slot durably means this turn's
@@ -366,13 +521,13 @@ function convergeLockedTurn(reservation, input, actor, cwd) {
                         evidence_context: {
                             channel: 'reconcile_turn',
                             producer_kind: 'slot',
-                            producer_id: reservation.agent,
-                            agent_id: reservation.agent_id,
+                            producer_id: acceptedExecutor.agent,
+                            agent_id: acceptedExecutor.agent_id,
                             slot_id: slot.slot_id,
                             slot_role: slot.role,
                             turn_id,
-                            assignment_id: reservation.child_ids.assignment_id,
-                            claim_id: reservation.claim_id,
+                            assignment_id: acceptedAssignmentId,
+                            claim_id: acceptedExecutor.claim_id,
                             run_id: acceptedRunId,
                             nonce: acceptedNonce,
                             attempt_epoch: acceptedEpoch,
@@ -398,13 +553,13 @@ function convergeLockedTurn(reservation, input, actor, cwd) {
                 evidence_context: {
                     channel: 'reconcile_turn',
                     producer_kind: 'slot',
-                    producer_id: reservation.agent,
-                    agent_id: reservation.agent_id,
+                    producer_id: acceptedExecutor.agent,
+                    agent_id: acceptedExecutor.agent_id,
                     slot_id: slot.slot_id,
                     slot_role: slot.role,
                     turn_id,
-                    assignment_id: reservation.child_ids.assignment_id,
-                    claim_id: reservation.claim_id,
+                    assignment_id: acceptedAssignmentId,
+                    claim_id: acceptedExecutor.claim_id,
                     run_id: acceptedRunId,
                     nonce: acceptedNonce,
                     attempt_epoch: acceptedEpoch,
@@ -435,7 +590,7 @@ function convergeLockedTurn(reservation, input, actor, cwd) {
                 event_type: 'loop_artifact_harvested',
                 text: `reconcileTurn: harvested turn ${turn_id} on slot ${slot.slot_id} → loop ${loop.id} (${slot_outcome}, ${artifacts_added} artifact(s), phase ${reservation.phase})`,
                 tags: ['loops', 'reconcile', 'harvest', 'turn-attempt'],
-                assignment_id: reservation.child_ids.assignment_id,
+                assignment_id: acceptedAssignmentId,
                 run_id: acceptedRunId,
                 attempt_epoch: acceptedGeneration?.attempt_epoch,
                 workspace_digest: acceptedGeneration?.workspace_digest,
@@ -452,7 +607,7 @@ function convergeLockedTurn(reservation, input, actor, cwd) {
     // (a crash that recorded the turn but not the settle still converges on replay; the
     // fix-cycle re-dispatch mints a fresh run/assignment, so completing the old is correct). ──
     settleRunCompleted(acceptedRunId, actor, cwd);
-    settleAssignment(reservation.child_ids.assignment_id, actor, cwd);
+    settleAssignment(acceptedAssignmentId, actor, cwd);
     // ── Advance / stop decision. On a `done` outcome we either drive a deterministic stop
     // (reviewer_green / gate → close), continue a symmetric fix cycle (bump the round + retain
     // the claim + emit next_turn), or leave the loop open (asymmetric / no successor). ──
@@ -530,7 +685,7 @@ function convergeLockedTurn(reservation, input, actor, cwd) {
                                 event_type: 'run_blocked',
                                 text: `reconcileTurn: fix-cycle round ${cur.iteration_count} of loop ${loop.id} was bumped but never dispatched (turn ${turn_id} strand) — re-emitting next_turn to self-heal`,
                                 tags: ['loops', 'reconcile', 'turn-owned', 'strand-recovery'],
-                                assignment_id: reservation.child_ids.assignment_id,
+                                assignment_id: acceptedAssignmentId,
                                 run_id: acceptedRunId,
                                 status_reason: 'fix_cycle_strand_reemit',
                             }, cwd);
@@ -560,7 +715,7 @@ function convergeLockedTurn(reservation, input, actor, cwd) {
     // Release the coordinator claim now — UNLESS a fix-cycle round retained it. Target the
     // authoritative claim the assignment is bound to, not reservation.claim_id (dec#149 #3).
     if (!retainClaim) {
-        const authoritativeClaimId = loadAssignment(reservation.child_ids.assignment_id, cwd)?.claim_id ?? reservation.claim_id;
+        const authoritativeClaimId = loadAssignment(acceptedAssignmentId, cwd)?.claim_id ?? acceptedExecutor.claim_id;
         releaseCoordinatorClaim(authoritativeClaimId, cwd);
     }
     const loop_status = getLoop(loop.id, cwd)?.status ?? loop.status;
@@ -661,7 +816,7 @@ function convergeFailedLockedTurn(reservation, run, transportReason, actor, cwd)
                 event_type: 'run_failed',
                 text: `Released claim ${claimId} as the BUSINESS convergence of failed turn ${reservation.turn_id}: ${why}`,
                 tags: ['loops', 'reconcile', 'claim-release', 'effects-boundary'],
-                assignment_id: reservation.child_ids.assignment_id,
+                assignment_id: run.assignment_id,
                 run_id: run.id,
                 claim_id: claimId,
                 status_reason: 'turn_failure_business_release',
@@ -676,7 +831,7 @@ function convergeFailedLockedTurn(reservation, run, transportReason, actor, cwd)
         // A genuinely deleted loop leaves the claim to the staleness sweep.
         return { converged: false, claim_released: false, reason: `loop ${reservation.loop_id} not found — claim retained for the staleness sweep` };
     }
-    const authoritativeClaimId = loadAssignment(reservation.child_ids.assignment_id, cwd)?.claim_id ?? reservation.claim_id;
+    const authoritativeClaimId = loadAssignment(run.assignment_id, cwd)?.claim_id ?? run.claim_id ?? reservation.claim_id;
     // Terminal loop: the business story is already over — releasing is pure
     // idempotent cleanup, mirroring reconcileTurn's terminal early-return.
     if (LOOP_TERMINAL.has(loop.status)) {
@@ -711,6 +866,49 @@ function convergeFailedLockedTurn(reservation, run, transportReason, actor, cwd)
             return { converged: false, claim_released: false, reason: `complete_turn failed: ${err instanceof Error ? err.message : String(err)} — claim retained, next pass retries` };
         }
     }
+    // Assignment is a business projection of the same failed turn. Leaving it
+    // offered/started while the run, slot, and claim are terminal recreates the
+    // orphaned-state ambiguity this convergence path exists to remove.
+    let assignment = loadAssignment(run.assignment_id, cwd);
+    if (assignment && !['completed', 'failed', 'blocked', 'timed_out', 'cancelled', 'expired', 'rerouted'].includes(assignment.status)) {
+        const assignmentId = assignment.id;
+        try {
+            // A running AgentRun is stronger execution evidence than a lagging
+            // Assignment projection. Legacy/file workers can leave that projection
+            // at created or accepted; walk the legal FSM edges before recording the
+            // terminal failure instead of declining forever on created -> failed or
+            // accepted -> failed. Each edge is durable, so a crash resumes from the
+            // last projection on the next lazy pass.
+            if (assignment.status === 'created' || assignment.status === 'retrying') {
+                transitionAssignment(assignmentId, 'offered', {
+                    actor,
+                    syncAgentRun: false,
+                    status_reason: `turn ${reservation.turn_id} failure projection catch-up`,
+                }, cwd);
+                assignment = loadAssignment(assignmentId, cwd);
+            }
+            if (assignment?.status === 'accepted') {
+                transitionAssignment(assignmentId, 'started', {
+                    actor,
+                    syncAgentRun: false,
+                    status_reason: `turn ${reservation.turn_id} failure projection catch-up`,
+                }, cwd);
+                assignment = loadAssignment(assignmentId, cwd);
+            }
+            transitionAssignment(assignmentId, 'failed', {
+                actor,
+                syncAgentRun: false,
+                status_reason: `turn ${reservation.turn_id} failed: ${transportReason}`,
+            }, cwd);
+        }
+        catch (err) {
+            return {
+                converged: false,
+                claim_released: false,
+                reason: `assignment failure projection failed: ${err instanceof Error ? err.message : String(err)} — claim retained, next pass retries`,
+            };
+        }
+    }
     const released = releaseAudited(authoritativeClaimId, transportReason);
     return {
         converged: true,

package/dist/core/loops/result-reducers.js

@@ -6,7 +6,7 @@ import { LOOP_ARTIFACT_BODY_MAX_BYTES } from './types.js';
  * would make complete_turn throw and crash reconcileTurn. Byte-aware, drops any
  * partial trailing multibyte char.
  */
-function capBody(s) {
+export function capLoopArtifactBody(s) {
     if (Buffer.byteLength(s, 'utf8') <= LOOP_ARTIFACT_BODY_MAX_BYTES)
         return s;
     const marker = '…[truncated]';
@@ -35,7 +35,7 @@ export const reviewReducer = (input, attempt) => {
             return { artifacts: [], slot_outcome: 'failed', failure_reason: 'review author_response produced no body' };
         }
         return {
-            artifacts: [{ phase, type: 'author_response', body: capBody(response), produced_by: attempt.agent }],
+            artifacts: [{ phase, type: 'author_response', body: capLoopArtifactBody(response), produced_by: attempt.agent }],
             slot_outcome: 'done',
         };
     }
@@ -46,7 +46,7 @@ export const reviewReducer = (input, attempt) => {
         return { artifacts: [], slot_outcome: 'failed', failure_reason: 'review lane completed without a review_verdict — cannot converge the loop' };
     }
     const summary = (lane.review_summary ?? '').trim();
-    const body = capBody(lane.review_verdict === 'approve'
+    const body = capLoopArtifactBody(lane.review_verdict === 'approve'
         ? `accepted${summary ? `: ${summary}` : ''}`
         : `changes-requested${summary ? `: ${summary}` : ''}`);
     return {
@@ -96,7 +96,7 @@ export const ideationReducer = (input, attempt) => {
                 artifacts: [{
                         phase,
                         type: artifactType,
-                        body: capBody(body),
+                        body: capLoopArtifactBody(body),
                         produced_by: attempt.agent,
                         addresses_critique: uniqueAddresses,
                         implementation_verify: lane.implementation_verify,
@@ -104,7 +104,7 @@ export const ideationReducer = (input, attempt) => {
                 slot_outcome: 'done',
             };
         }
-        return { artifacts: [{ phase, type: artifactType, body: capBody(body), produced_by: attempt.agent }], slot_outcome: 'done' };
+        return { artifacts: [{ phase, type: artifactType, body: capLoopArtifactBody(body), produced_by: attempt.agent }], slot_outcome: 'done' };
     }
     if (lane.artifact_type !== 'critique') {
         return { artifacts: [], slot_outcome: 'failed', failure_reason: "ideation critique requires artifact_type 'critique'" };
@@ -114,7 +114,7 @@ export const ideationReducer = (input, attempt) => {
     }
     return {
         artifacts: critiques.map((c) => ({
-            phase, type: 'critique', body: capBody(c.body), produced_by: attempt.agent,
+            phase, type: 'critique', body: capLoopArtifactBody(c.body), produced_by: attempt.agent,
             ...(c.addresses_critique ? { addresses_critique: c.addresses_critique } : {}),
         })),
         slot_outcome: 'done',
@@ -131,7 +131,7 @@ export const defaultReducer = (input, attempt) => {
         return { artifacts: [], slot_outcome: 'failed', failure_reason: `lane status is ${lane.status}, not completed` };
     }
     return {
-        artifacts: [{ phase, type: 'lane_result', body: capBody(lane.summary), produced_by: attempt.agent }],
+        artifacts: [{ phase, type: 'lane_result', body: capLoopArtifactBody(lane.summary), produced_by: attempt.agent }],
         slot_outcome: 'done',
     };
 };
@@ -159,7 +159,7 @@ function typedPhaseReducer(kind, artifactByPhase) {
             return { artifacts: [], slot_outcome: 'failed', failure_reason: `${kind} phase '${phase}' produced no artifact body` };
         }
         return {
-            artifacts: [{ phase, type: expectedType, body: capBody(body), produced_by: attempt.agent }],
+            artifacts: [{ phase, type: expectedType, body: capLoopArtifactBody(body), produced_by: attempt.agent }],
             slot_outcome: 'done',
         };
     };

package/dist/core/loops/turn-execution.js

@@ -13,22 +13,23 @@ import { getLoop } from './store.js';
 import { phasePolicy } from './kind-policies.js';
 /** Idempotently materialize every child projection required before launch. */
 export function ensureTurnExecutionProjections(reservation, input, cwd) {
-    if (reservation.claim_id === '')
+    const claimId = input.claim_id ?? reservation.claim_id;
+    if (claimId === '')
         throw new Error('attempt reservation has no claim');
     ensureAssignmentProjection({
         id: input.assignment_id,
         short_label: input.assignment_id,
-        claim_id: reservation.claim_id,
+        claim_id: claimId,
         agent: input.agent,
         agent_id: input.agent_id,
         dispatcher_agent: input.dispatcher_agent,
         dispatcher_session_id: input.dispatcher_session_id,
         scope: input.scope,
         description: input.description,
-        // Assignment is the stable logical attempt. Its contract projection stays
-        // generation-zero; each physical AgentRun below carries its own contract.
-        execution_contract_ref: reservation.execution_contract_ref,
-        capability_snapshot: reservation.capability_snapshot,
+        // Assignment is generation-scoped. Generation zero preserves the historic
+        // deterministic id; every takeover projects a fresh assignment and contract.
+        execution_contract_ref: input.execution_contract_ref ?? reservation.execution_contract_ref,
+        capability_snapshot: input.capability_snapshot ?? reservation.capability_snapshot,
         tags: input.assignment_tags ?? ['coordinate', 'loop', 'turn-owned'],
     }, cwd);
     input.on_projection?.('assignment');
@@ -36,7 +37,7 @@ export function ensureTurnExecutionProjections(reservation, input, cwd) {
         id: input.run_id,
         short_label: input.run_id,
         assignment_id: input.assignment_id,
-        claim_id: reservation.claim_id,
+        claim_id: claimId,
         attempt_index: input.attempt_index ?? 1,
         agent: input.agent,
         agent_id: input.agent_id,
@@ -50,7 +51,7 @@ export function ensureTurnExecutionProjections(reservation, input, cwd) {
         tags: input.run_tags ?? ['turn-owned', 'loop'],
     }, cwd);
     input.on_projection?.('run');
-    ensureClaimAssignmentBinding(reservation.claim_id, input.assignment_id, cwd, {
+    ensureClaimAssignmentBinding(claimId, input.assignment_id, cwd, {
         worktreePath: input.worktree_path,
     });
     input.on_projection?.('claim_binding');
@@ -61,7 +62,7 @@ export function ensureTurnExecutionProjections(reservation, input, cwd) {
         input: input.task,
         turn_id: input.turn_id,
         assignment_id: input.assignment_id,
-        claim_id: reservation.claim_id,
+        claim_id: claimId,
     }, cwd);
     input.on_projection?.('slot_binding');
     input.on_projection?.('before_crossing');
@@ -71,7 +72,11 @@ function preconditionDenied(reason) {
 }
 function authorityDenied(input, turnId, reason) {
     const reservation = getReservation(turnId, input.cwd);
-    const ownsAuthority = reservation?.claim_id === input.claim_id;
+    const chain = resolveTurnGenerationChain(input.cwd, turnId);
+    const authorityClaimId = chain?.status === 'active'
+        ? chain.latest_generation.executor?.claim_id ?? reservation?.claim_id
+        : reservation?.claim_id;
+    const ownsAuthority = authorityClaimId === input.claim_id;
     const crossed = reservation?.launch?.status === 'crossed';
     return {
         kind: 'denied',
@@ -129,13 +134,19 @@ export function prepareTurnExecution(input) {
     }, input.cwd);
     const childIds = deriveChildIds(turnId);
     const existingReservation = getReservation(turnId, input.cwd);
+    const v2 = resolveTurnGenerationChain(input.cwd, turnId);
+    const activeExecutor = v2?.status === 'active' && v2.latest_generation.attempt_epoch > 0
+        ? v2.latest_generation.executor
+        : undefined;
     if (slot.agent !== undefined && slot.agent !== input.agent) {
         return preconditionDenied(`slot ${input.slot_id} belongs to agent '${slot.agent}', not '${input.agent}'`);
     }
     if (slot.agent_id !== undefined && slot.agent_id !== input.agent_id) {
         return preconditionDenied(`slot ${input.slot_id} belongs to agent_id '${slot.agent_id}', not '${input.agent_id ?? 'none'}'`);
     }
-    if (slot.claim_id !== undefined && slot.claim_id !== input.claim_id) {
+    if (slot.claim_id !== undefined
+        && slot.claim_id !== input.claim_id
+        && ['assigned', 'working', 'waiting_input'].includes(slot.status)) {
         return preconditionDenied(`slot ${input.slot_id} is bound to claim ${slot.claim_id}, not ${input.claim_id}`);
     }
     if (slot.current_turn_id !== undefined
@@ -202,13 +213,15 @@ export function prepareTurnExecution(input) {
     catch (error) {
         return preconditionDenied(error instanceof Error ? error.message : String(error));
     }
-    const frozenHarnessBinding = existingReservation?.capability_snapshot?.resolved.harness;
+    const frozenHarnessBinding = activeExecutor?.capability_snapshot.resolved.harness
+        ?? existingReservation?.capability_snapshot?.resolved.harness;
     if (frozenHarnessBinding && JSON.stringify(frozenHarnessBinding) !== JSON.stringify(requestedHarnessBinding)) {
         return preconditionDenied(`harness binding differs from immutable capability snapshot: frozen `
             + `${frozenHarnessBinding.adapter_id}@${frozenHarnessBinding.adapter_version}, requested `
             + `${requestedHarnessBinding.adapter_id}@${requestedHarnessBinding.adapter_version}`);
     }
-    const capabilitySnapshot = existingReservation?.capability_snapshot
+    const capabilitySnapshot = activeExecutor?.capability_snapshot
+        ?? existingReservation?.capability_snapshot
         ?? resolveCapabilitySnapshot(input.agent, capabilityRequirement, input.agent_id, requestedHarnessBinding);
     if (!capabilitySnapshot.accepted) {
         const reasons = capabilitySnapshot.reasons.map((reason) => reason.code).join(', ');
@@ -256,7 +269,6 @@ export function prepareTurnExecution(input) {
     const contractRef = contract
         ? (existingReservation?.execution_contract_ref ?? executionContractRef(contract, capabilitySnapshot))
         : undefined;
-    const v2 = resolveTurnGenerationChain(input.cwd, turnId);
     const activeRollout = resolveActiveAttemptRollout(input.cwd);
     const localHome = readLocalAuthorityHome(input.cwd);
     if (activeRollout && (!localHome || !contractRef)) {
@@ -339,10 +351,16 @@ export function prepareTurnExecution(input) {
         try {
             const generation = v2.latest_generation;
             const generationContract = executionContractForGeneration(reservation, generation);
+            const executor = generation.executor ?? {
+                agent: reservation.agent,
+                agent_id: reservation.agent_id,
+                claim_id: reservation.claim_id,
+                capability_snapshot: reservation.capability_snapshot,
+            };
             let accepted;
             try {
                 accepted = input.accepted_execution_contract
-                    ?? attestHarnessContractAcceptance(generationContract.ref, reservation.capability_snapshot, requestedHarnessBinding);
+                    ?? attestHarnessContractAcceptance(generationContract.ref, executor.capability_snapshot, requestedHarnessBinding);
             }
             catch (error) {
                 return preconditionDenied(`worker contract acceptance unavailable before crossing: ${error instanceof Error ? error.message : String(error)}`);
@@ -357,8 +375,9 @@ export function prepareTurnExecution(input) {
                 turn_id: turnId,
                 assignment_id: generation.assignment_id,
                 run_id: generation.run_id,
-                agent: input.agent,
-                agent_id: input.agent_id,
+                claim_id: executor.claim_id,
+                agent: executor.agent,
+                agent_id: executor.agent_id,
                 dispatcher_agent: input.dispatcher_agent,
                 dispatcher_agent_id: input.dispatcher_agent_id,
                 dispatcher_session_id: input.dispatcher_session_id,
@@ -370,7 +389,7 @@ export function prepareTurnExecution(input) {
                 run_tags: [...(input.run_tags ?? ['turn-owned', 'loop']), `attempt-generation:${generation.attempt_epoch}`],
                 attempt_index: generation.attempt_epoch + 1,
                 execution_contract_ref: generationContract.ref,
-                capability_snapshot: reservation.capability_snapshot,
+                capability_snapshot: executor.capability_snapshot,
                 on_projection: input.on_projection,
             }, input.cwd);
             const crossing = crossActiveAttemptGenerationV2(turnId, generation.attempt_epoch, localHome, input.dispatcher_agent_id ?? input.dispatcher_agent, input.dispatcher_agent_id ?? input.dispatcher_agent, input.cwd);
@@ -387,7 +406,7 @@ export function prepareTurnExecution(input) {
                 workspace_path: generation.workspace_path,
                 contract_status: 'contracted',
                 execution_contract_ref: generationContract.ref,
-                capability_snapshot: reservation.capability_snapshot,
+                capability_snapshot: executor.capability_snapshot,
             };
         }
         catch (error) {

package/dist/core/loops/types.js

@@ -734,6 +734,9 @@ export const LoopEventSchema = z.discriminatedUnion('kind', [
         slot_id: z.string().min(1),
         turn_id: z.string().min(1),
         assignment_id: z.string().min(1),
+        claim_id: z.string().min(1).optional(),
+        agent: z.string().min(1).optional(),
+        agent_id: z.string().min(1).optional(),
         from_epoch: z.number().int().nonnegative(),
         to_epoch: z.number().int().positive(),
         from_run_id: z.string().min(1),

package/dist/core/loops/verbs.js

@@ -586,7 +586,7 @@ function authorizeCompleteTurnAttempt(input, slot, cwd) {
         slot_role: slot.role,
         turn_id: generation.turn_id,
         assignment_id: generation.assignment_id,
-        claim_id: reservation.claim_id ?? slot.claim_id,
+        claim_id: generation.executor?.claim_id ?? slot.claim_id ?? reservation.claim_id,
         run_id: generation.run_id,
         nonce: generation.launch_nonce,
         attempt_epoch: generation.attempt_epoch,