brainclaw 1.28.0 → 1.28.2

package/dist/commands/mcp-write-coordination.js

@@ -12,6 +12,7 @@
  * @module
  */
 import crypto from 'node:crypto';
+import { spawnSync } from 'node:child_process';
 import { buildClaimEnvPrefix } from '../core/execution-profile.js';
 import { resolveProjectCwd } from '../core/cross-project.js';
 import { attachAssignmentMessageToClaim, createCoordinatorClaim, linkClaimToAssignment, listClaims, releaseClaimIfActive, saveClaim, } from '../core/claims.js';
@@ -20,6 +21,8 @@ import { appendAuditEntry } from '../core/audit.js';
 import { nowISO } from '../core/ids.js';
 import { validateMcpField } from '../core/input-validation.js';
 import { generateCandidateIdWithLabel, saveCandidate } from '../core/candidates.js';
+import { DEFAULT_PROTOCOLS } from '../core/loops/types.js';
+import { capLoopArtifactBody } from '../core/loops/result-reducers.js';
 import { validateLoopProjectResolution } from '../core/loops/project-resolution.js';
 import { coordinateNextActions, dispatchNextActions } from '../core/next-actions.js';
 import { agentValidationFailedWarning, consultAutoExecuteNoOpWarning, planAlreadyAssignedWarning, pushStructuredWarning, scopeAlreadyClaimedWarning, } from '../core/warnings.js';
@@ -32,8 +35,14 @@ import { attemptExecution } from '../core/execution.js';
 import { createAgentRun, transitionAgentRun } from '../core/agentruns.js';
 import { prepareTurnOwnedReviewDispatch, turnOwnedReviewEnabled } from '../core/review-loop-turn-dispatch.js';
 import { prepareTurnExecution } from '../core/loops/turn-execution.js';
+import { findReservationByAssignmentId } from '../core/loops/attempt-reservation.js';
+import { resolveTurnGenerationChain } from '../core/loops/attempt-generations.js';
+import { readLocalAuthorityHome } from '../core/loops/attempt-rollout.js';
+import { AttemptTakeoverCommittedError, takeoverLoopAttempt } from '../core/loops/attempt-takeover.js';
+import { getLoop as getLoopThread } from '../core/loops/store.js';
 import { removeWorktree } from '../core/worktree.js';
-import { createAssignment, generateAssignmentId, patchAssignmentMessageId, transitionAssignment, } from '../core/assignments.js';
+import { resolveCapabilitySnapshot } from '../core/execution-contract.js';
+import { createAssignment, generateAssignmentId, listAssignments, patchAssignmentMessageId, transitionAssignment, } from '../core/assignments.js';
 import { createToolErrorResponse, toolResponse, } from './mcp-contract.js';
 import { handleMcpReadToolCall } from './mcp-read-handlers.js';
 import { ensureTrust } from './mcp-write-support.js';
@@ -383,6 +392,88 @@ export async function handleBclawCoordinate(args, ctx) {
         warnings.push(`cross-project dispatch (project='${req.project}') — auto-spawn disabled; the target agent picks up the brief async via its own bclaw_work.`);
     }
     const effectiveAutoExecute = isCrossProject ? false : req.autoExecute;
+    // pln#692 P0 — an explicit checkout ref is part of admission, not worktree
+    // creation. Validate it before releasing a reroute predecessor (and before
+    // every other worktree-producing mutation). A claim id is not a Git ref.
+    const refCreatesWorktree = ['assign', 'review', 'reroute'].includes(req.intent)
+        || (req.intent === 'ideate' && Array.isArray(req.targetAgents) && req.targetAgents.length > 0 && req.preset !== 'bootstrap');
+    if (req.ref && refCreatesWorktree && !isCrossProject) {
+        const refCheck = spawnSync('git', ['rev-parse', '--verify', '--quiet', `${req.ref}^{commit}`], {
+            cwd: dispatchCwd, encoding: 'utf8', windowsHide: true,
+        });
+        if (refCheck.status !== 0) {
+            return {
+                response: createToolErrorResponse('invalid_dispatch_ref', `dispatch admission refused before mutation: ref "${req.ref}" does not resolve to a commit`, {
+                    ref: req.ref,
+                    blocker: 'worktree base must be a valid commit, branch, or tag',
+                    next_actions: [{
+                            tool: 'bclaw_coordinate',
+                            args: { intent: req.intent, task: req.task, scope: req.scope, targetAgents: req.targetAgents },
+                            when: 'retry without ref to use HEAD, or supply a Git ref that resolves to a commit',
+                        }],
+                }),
+            };
+        }
+    }
+    // pln#692 P0 — admission must prove that a multi-agent ideation request can
+    // satisfy the first worker-produced phase gate BEFORE openLoop (or any
+    // identity/claim/assignment mutation). The default critique phase requires
+    // three distinct critique artifacts, so accepting one executable critic
+    // creates a loop that cannot converge without manual artifact injection.
+    if (req.intent === 'ideate'
+        && req.preset !== 'bootstrap'
+        && Array.isArray(req.targetAgents)
+        && req.targetAgents.length > 0) {
+        const critiquePhase = DEFAULT_PROTOCOLS.ideation.phases.find((phase) => phase.name === 'critique');
+        const gate = critiquePhase?.advance_gate;
+        const requiredCritics = gate?.kind === 'min_artifacts_by_type' ? gate.n : 0;
+        const uniqueTargets = [...new Set(req.targetAgents)];
+        const checks = uniqueTargets.map((agent) => ({
+            agent,
+            check: validateAgentForDispatch(agent, { requireSpawnable: true }),
+        }));
+        const executableTargets = checks.filter(({ check }) => check.valid).map(({ agent }) => agent);
+        const invalidTargets = checks.filter(({ check }) => !check.valid).map(({ agent, check }) => ({
+            agent,
+            code: check.code,
+            reason: check.reason,
+        }));
+        if (requiredCritics > 0 && executableTargets.length < requiredCritics) {
+            const availableTargets = getSpawnableAgents()
+                .map((profile) => profile.name)
+                .filter((agent, index, all) => agent !== senderAgent && all.indexOf(agent) === index)
+                .filter((agent) => validateAgentForDispatch(agent, { requireSpawnable: true }).valid);
+            const recoveryTargets = availableTargets.slice(0, requiredCritics);
+            const nextActions = recoveryTargets.length >= requiredCritics
+                ? [{
+                        tool: 'bclaw_coordinate',
+                        args: {
+                            intent: 'ideate', task: req.task, scope: req.scope,
+                            targetAgents: recoveryTargets, autoExecute: effectiveAutoExecute !== false,
+                        },
+                        when: `retry with at least ${requiredCritics} distinct executable critics`,
+                    }]
+                : [{
+                        tool: 'bclaw_context',
+                        args: { kind: 'execution', includeAgentTooling: true },
+                        when: `configure at least ${requiredCritics} spawnable critic identities before retrying`,
+                    }];
+            return {
+                response: createToolErrorResponse('ideate_gate_capacity_unavailable', `ideation admission refused before mutation: critique gate requires ${requiredCritics} distinct executable critic(s), observed ${executableTargets.length}`, {
+                    gate: { phase: 'critique', kind: gate?.kind, expected: requiredCritics, observed: executableTargets.length },
+                    requested_targets: req.targetAgents,
+                    executable_targets: executableTargets,
+                    invalid_targets: invalidTargets,
+                    blockers: [
+                        ...(uniqueTargets.length < req.targetAgents.length ? ['duplicate target identities do not add executable capacity'] : []),
+                        ...(invalidTargets.length > 0 ? ['one or more requested targets are not spawnable'] : []),
+                        `missing executable critic capacity: ${requiredCritics - executableTargets.length}`,
+                    ],
+                    next_actions: nextActions,
+                }),
+            };
+        }
+    }
     // pln#521 P1 — project resolution gate. A review loop written into the wrong
     // store is worse than one that never opened: candidate, claim, assignment and
     // loop all persist where nobody is watching, and the reviewer spawns against
@@ -1279,166 +1370,351 @@ export async function handleBclawCoordinate(args, ctx) {
             ...(reviewExecStatus ? { execution_status: reviewExecStatus } : {}),
         };
     }
-    else if (req.intent === 'reroute') {
-        const activeClaims = listClaims(dispatchCwd).filter((c) => c.status === 'active' && (req.scope ? c.scope === req.scope : true));
-        if (activeClaims.length === 0) {
-            return { response: createToolErrorResponse('not_found', `No active claim found for scope: ${req.scope ?? '(any)'}`) };
-        }
-        const oldClaim = activeClaims[0];
-        saveClaim({ ...oldClaim, status: 'released', released_at: nowISO() }, dispatchCwd);
-        appendAuditEntry({ actor: oldClaim.agent, action: 'release_claim', item_id: oldClaim.id, item_type: 'claim', scope: oldClaim.scope }, dispatchCwd);
-        side_effects.push({ action: 'release', entity: 'claim', id: oldClaim.id });
-        // trp#61: supersede assignments attached to the old claim so they
-        // don't linger in `created`/`offered`/etc. Prior behaviour only
-        // released the claim, leaving the assignment FSM stuck and confusing
-        // dispatch analysis / review.
-        const { listAssignments: listAsgn } = await import('../core/assignments.js');
-        const predecessors = listAsgn(dispatchCwd, { claim_id: oldClaim.id })
-            .filter((a) => a.status !== 'completed' && a.status !== 'cancelled' && a.status !== 'expired' && a.status !== 'rerouted');
-        for (const predecessor of predecessors) {
-            try {
-                transitionAssignment(predecessor.id, 'rerouted', {
-                    actor: senderAgent,
-                    status_reason: `reroute: claim ${oldClaim.id} reassigned`,
-                }, dispatchCwd);
-                side_effects.push({ action: 'update', entity: 'assignment', id: predecessor.id });
+    else if (req.intent === 'reroute')
+        reroute: {
+            const activeClaims = listClaims(dispatchCwd).filter((c) => c.status === 'active' && (req.scope ? c.scope === req.scope : true));
+            if (activeClaims.length === 0) {
+                return { response: createToolErrorResponse('not_found', `No active claim found for scope: ${req.scope ?? '(any)'}`) };
             }
-            catch (err) {
-                warnings.push(`Failed to close predecessor assignment ${predecessor.id}: ${err instanceof Error ? err.message : String(err)}`);
+            const oldClaim = activeClaims[0];
+            const newAgentName = resolvedAgents.find((a) => a !== oldClaim.agent) ?? resolvedAgents[0];
+            if (!newAgentName) {
+                return { response: createToolErrorResponse('reroute_target_unavailable', 'reroute requires a replacement target agent') };
             }
-        }
-        const newAgentName = resolvedAgents.find((a) => a !== oldClaim.agent) ?? resolvedAgents[0];
-        let newClaimId;
-        if (newAgentName) {
-            // trp#51: validate target agent before creating a new claim.
-            const check = validateAgentForDispatch(newAgentName, { requireSpawnable: true });
-            if (!check.valid) {
-                pushStructuredWarning(warnings, warningDetails, agentValidationFailedWarning({
-                    agent: newAgentName,
-                    code: check.code,
-                    reason: check.reason,
-                }));
+            // pln#692 P0 — validate the successor before releasing the predecessor.
+            // Previously an invalid target left the old claim released and the scope
+            // unowned, even though no replacement claim/assignment could be created.
+            const rerouteCheck = validateAgentForDispatch(newAgentName, { requireSpawnable: true });
+            if (!rerouteCheck.valid || !rerouteCheck.profile) {
+                return {
+                    response: createToolErrorResponse('reroute_target_unavailable', `reroute admission refused before mutation: ${newAgentName} is not executable (${rerouteCheck.code}: ${rerouteCheck.reason})`, {
+                        released_claim: null,
+                        active_claim: oldClaim.id,
+                        target: newAgentName,
+                        blocker: { code: rerouteCheck.code, reason: rerouteCheck.reason },
+                        next_actions: [{
+                                tool: 'bclaw_coordinate',
+                                args: { intent: 'reroute', task: req.task, scope: oldClaim.scope, targetAgents: getSpawnableAgents().map((agent) => agent.name) },
+                                when: 'retry with a validated spawnable target',
+                            }],
+                    }),
+                };
             }
-            const profile = check.profile;
-            if (check.valid && profile) {
-                ensureAgentRegisteredForDispatch(newAgentName, dispatchCwd);
-                const rerouteClaimResult = createCoordinatorClaim({
-                    agent: newAgentName,
-                    scope: oldClaim.scope,
-                    description: req.task,
-                    dispatcherAgent: senderAgent,
-                    sessionId: connectionSessionId,
-                    cwd: dispatchCwd,
-                    worktreeBaseRef: req.ref,
-                });
-                newClaimId = rerouteClaimResult.claimId;
-                if (rerouteClaimResult.worktreeWarning) {
-                    warnings.push(rerouteClaimResult.worktreeWarning);
+            {
+                const activePredecessors = listAssignments(dispatchCwd, { claim_id: oldClaim.id })
+                    .filter((a) => !['completed', 'cancelled', 'expired', 'rerouted'].includes(a.status));
+                const owned = activePredecessors
+                    .map((assignment) => ({ assignment, reservation: findReservationByAssignmentId(assignment.id, dispatchCwd) }))
+                    .find((candidate) => candidate.reservation !== undefined);
+                if (owned?.reservation) {
+                    const reservation = owned.reservation;
+                    const loop = getLoopThread(reservation.loop_id, dispatchCwd);
+                    const generation = resolveTurnGenerationChain(dispatchCwd, reservation.turn_id)?.latest_generation;
+                    const authorityHome = readLocalAuthorityHome(dispatchCwd);
+                    if (!loop || loop.status !== 'open' || !generation || !authorityHome || !reservation.execution_contract) {
+                        return { response: createToolErrorResponse('reroute_authority_unavailable', `loop-owned reroute cannot establish AttemptAuthority for ${owned.assignment.id}`, {
+                                loop_id: reservation.loop_id, turn_id: reservation.turn_id,
+                                has_loop: Boolean(loop), has_generation: Boolean(generation),
+                                has_authority_home: Boolean(authorityHome),
+                                has_execution_contract: Boolean(reservation.execution_contract),
+                                released_claim: null, active_claim: oldClaim.id,
+                            }) };
+                    }
+                    const newIdentity = ensureAgentRegisteredForDispatch(newAgentName, dispatchCwd);
+                    const rerouteHarness = resolveHarnessBinding(newAgentName, resolveModel(newAgentName, { override: req.model }));
+                    const successorSnapshot = resolveCapabilitySnapshot(newAgentName, reservation.execution_contract.capability_requirement, newIdentity?.agent_id, rerouteHarness);
+                    if (!successorSnapshot.accepted) {
+                        return { response: createToolErrorResponse('reroute_target_incompatible', `reroute target ${newAgentName} does not satisfy the immutable execution contract`, {
+                                reasons: successorSnapshot.reasons, released_claim: null,
+                                active_claim: oldClaim.id, assignment_id: owned.assignment.id,
+                            }) };
+                    }
+                    saveClaim({ ...oldClaim, status: 'released', released_at: nowISO() }, dispatchCwd);
+                    appendAuditEntry({ actor: oldClaim.agent, action: 'release_claim', item_id: oldClaim.id, item_type: 'claim', scope: oldClaim.scope }, dispatchCwd);
+                    let successorClaim;
+                    let takeoverCommitted = false;
+                    try {
+                        successorClaim = createCoordinatorClaim({
+                            agent: newAgentName, scope: oldClaim.scope, description: req.task,
+                            dispatcherAgent: senderAgent, sessionId: connectionSessionId,
+                            cwd: dispatchCwd, worktreeBaseRef: req.ref,
+                            worktreeBranchSuffix: `attempt-${generation.attempt_epoch + 1}`,
+                        });
+                        if (successorClaim.scopeConflict || !successorClaim.worktreePath) {
+                            throw new Error(successorClaim.scopeConflict
+                                ? `scope remained owned by ${successorClaim.conflictAgent ?? 'another agent'}`
+                                : successorClaim.worktreeWarning ?? 'successor worktree is unavailable');
+                        }
+                        const takeoverInput = {
+                            loop_id: reservation.loop_id, slot_id: reservation.slot_id, turn_id: reservation.turn_id,
+                            expected_epoch: generation.attempt_epoch, authority_home: authorityHome,
+                            actor: senderAgent, actor_id: senderAgentId, writer_id: senderAgentId ?? senderAgent,
+                            cause: `coordinate reroute from claim ${oldClaim.id} to ${successorClaim.claimId}`,
+                            liveness_evidence: `operator-requested reroute of assignment ${owned.assignment.id}`,
+                            external_effect_policy: 'none', next_workspace_path: successorClaim.worktreePath,
+                            predecessor_assignment_terminal: 'rerouted',
+                            next_executor: {
+                                agent: newAgentName, agent_id: newIdentity?.agent_id, claim_id: successorClaim.claimId,
+                                capability_snapshot: successorSnapshot,
+                            }, cwd: dispatchCwd,
+                        };
+                        let taken;
+                        try {
+                            taken = takeoverLoopAttempt(takeoverInput);
+                        }
+                        catch (error) {
+                            if (!(error instanceof AttemptTakeoverCommittedError))
+                                throw error;
+                            // The close(epoch) CAS already won. Never reactivate/release claims
+                            // from the predecessor generation; replay the identical transaction
+                            // once to repair the loop/run projections before continuing.
+                            takeoverCommitted = true;
+                            taken = takeoverLoopAttempt(takeoverInput);
+                        }
+                        takeoverCommitted = true;
+                        const prepared = prepareTurnExecution({
+                            kind: loop.kind, loop_id: loop.id, slot_id: reservation.slot_id, phase: reservation.phase,
+                            agent: newAgentName, agent_id: newIdentity?.agent_id, claim_id: successorClaim.claimId,
+                            dispatcher_agent: senderAgent, dispatcher_agent_id: senderAgentId,
+                            dispatcher_session_id: connectionSessionId, scope: oldClaim.scope,
+                            description: req.task, task: req.task, cwd: dispatchCwd,
+                            worktree_path: successorClaim.worktreePath,
+                            assignment_tags: ['coordinate', 'assign', 'reroute', 'turn-owned', 'loop'],
+                            run_tags: ['turn-owned', 'loop', 'reroute'],
+                            capability_requirement: reservation.execution_contract.capability_requirement,
+                            harness_binding: rerouteHarness,
+                        });
+                        if (prepared.kind !== 'won')
+                            throw new Error(`successor generation did not win launch: ${prepared.reason}`);
+                        if (prepared.assignment_id !== taken.assignment_id || prepared.run_id !== taken.run_id) {
+                            throw new Error('successor projections diverged from immutable takeover generation');
+                        }
+                        artifacts.push({ type: 'claim', id: successorClaim.claimId }, { type: 'assignment', id: prepared.assignment_id });
+                        side_effects.push({ action: 'release', entity: 'claim', id: oldClaim.id }, { action: 'create', entity: 'claim', id: successorClaim.claimId }, { action: 'create', entity: 'assignment', id: prepared.assignment_id });
+                        const fence = {
+                            turn_id: prepared.turn_id, run_id: prepared.run_id, nonce: prepared.nonce,
+                            attempt_epoch: prepared.attempt_epoch, workspace_digest: prepared.workspace_digest,
+                        };
+                        const queued = queueCoordinateMessage({
+                            agent: newAgentName,
+                            text: buildCoordinateBrief(newAgentName, req.task, {
+                                claimId: successorClaim.claimId, scope: oldClaim.scope,
+                                worktreePath: successorClaim.worktreePath, assignmentId: prepared.assignment_id,
+                                executionContractRef: prepared.execution_contract_ref, attemptFence: fence,
+                            }),
+                            messageType: 'assign', ref: oldClaim.scope, scope: oldClaim.scope, requiresAck: true,
+                            claimId: successorClaim.claimId, assignmentId: prepared.assignment_id,
+                            releasedClaimId: oldClaim.id, tags: ['coordinate', 'assign', 'reroute', 'turn-owned', 'loop'],
+                            payload: {
+                                intent: req.intent, scope: oldClaim.scope, claim_id: successorClaim.claimId,
+                                assignment_id: prepared.assignment_id, worktree_path: successorClaim.worktreePath,
+                                released_claim_id: oldClaim.id, previous_agent: oldClaim.agent,
+                                turn_id: prepared.turn_id, run_id: prepared.run_id, attempt_epoch: prepared.attempt_epoch,
+                            }, commandMode: 'worker', harnessBinding: rerouteHarness,
+                        });
+                        attachAssignmentMessageToClaim(successorClaim.claimId, queued.entry.message_id, dispatchCwd);
+                        linkClaimToAssignment(successorClaim.claimId, prepared.assignment_id, dispatchCwd);
+                        transitionAssignment(prepared.assignment_id, 'offered', { actor: senderAgent }, dispatchCwd);
+                        patchAssignmentMessageId(prepared.assignment_id, queued.entry.message_id, dispatchCwd);
+                        transitionAssignment(owned.assignment.id, 'rerouted', {
+                            actor: senderAgent, status_reason: `reroute: superseded by generation ${prepared.attempt_epoch}`,
+                        }, dispatchCwd);
+                        side_effects.push({ action: 'update', entity: 'assignment', id: owned.assignment.id });
+                        const turnEcho = {
+                            ...fence, contract_hash: prepared.execution_contract_ref.hash,
+                            capability_snapshot_hash: prepared.execution_contract_ref.snapshot_hash,
+                        };
+                        const delivery_plan = [queued.entry];
+                        const execution_status = await runCoordinateExecution([
+                            { entry: queued.entry, invoke: queued.invoke, worktreePath: successorClaim.worktreePath, turnEcho },
+                        ], { autoExecute: effectiveAutoExecute !== false, senderAgent, senderAgentId, cwd: dispatchCwd, warnings });
+                        result = {
+                            released_claim: oldClaim.id, old_agent: oldClaim.agent, new_agent: newAgentName,
+                            new_claim_id: successorClaim.claimId, loop_id: loop.id, turn_id: prepared.turn_id,
+                            assignment_id: prepared.assignment_id, run_id: prepared.run_id,
+                            attempt_epoch: prepared.attempt_epoch, selected_targets: resolvedAgents,
+                            delivery_plan, messages_sent: toMessageSummary(delivery_plan),
+                            commands: commandHints, execution_status,
+                        };
+                        break reroute;
+                    }
+                    catch (error) {
+                        if (!takeoverCommitted) {
+                            if (successorClaim && successorClaim.claimId !== oldClaim.id) {
+                                releaseClaimIfActive(successorClaim.claimId, dispatchCwd, {
+                                    agent: senderAgent, agent_id: senderAgentId, session_id: connectionSessionId, override: true,
+                                });
+                                if (successorClaim.worktreePath) {
+                                    try {
+                                        removeWorktree(dispatchCwd, successorClaim.worktreePath, { force: true });
+                                    }
+                                    catch (cleanupError) {
+                                        warnings.push(`reroute rollback worktree cleanup failed for ${successorClaim.claimId}: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+                                    }
+                                }
+                            }
+                            saveClaim({ ...oldClaim, status: 'active', released_at: undefined }, dispatchCwd);
+                            appendAuditEntry({
+                                actor: senderAgent,
+                                action: 'rollback',
+                                item_id: oldClaim.id,
+                                item_type: 'claim',
+                                scope: oldClaim.scope,
+                                reason: 'reroute aborted before immutable takeover commit; predecessor claim restored',
+                            }, dispatchCwd);
+                        }
+                        return { response: createToolErrorResponse(takeoverCommitted ? 'reroute_successor_incomplete' : 'reroute_transaction_rolled_back', error instanceof Error ? error.message : String(error), {
+                                takeover_committed: takeoverCommitted,
+                                active_claim: takeoverCommitted ? successorClaim?.claimId : oldClaim.id,
+                                previous_claim: oldClaim.id, loop_id: loop.id, turn_id: reservation.turn_id,
+                            }) };
+                    }
                 }
-                artifacts.push({ type: 'claim', id: newClaimId });
-                side_effects.push({
-                    action: rerouteClaimResult.reusedExisting ? 'reuse' : 'create',
-                    entity: 'claim',
-                    id: newClaimId,
-                });
-                let rerouteAssignmentId;
+            }
+            saveClaim({ ...oldClaim, status: 'released', released_at: nowISO() }, dispatchCwd);
+            appendAuditEntry({ actor: oldClaim.agent, action: 'release_claim', item_id: oldClaim.id, item_type: 'claim', scope: oldClaim.scope }, dispatchCwd);
+            side_effects.push({ action: 'release', entity: 'claim', id: oldClaim.id });
+            // trp#61: supersede assignments attached to the old claim so they
+            // don't linger in `created`/`offered`/etc. Prior behaviour only
+            // released the claim, leaving the assignment FSM stuck and confusing
+            // dispatch analysis / review.
+            const { listAssignments: listAsgn } = await import('../core/assignments.js');
+            const predecessors = listAsgn(dispatchCwd, { claim_id: oldClaim.id })
+                .filter((a) => a.status !== 'completed' && a.status !== 'cancelled' && a.status !== 'expired' && a.status !== 'rerouted');
+            for (const predecessor of predecessors) {
                 try {
-                    const preId = generateAssignmentId(dispatchCwd);
-                    const assignment = createAssignment({
-                        id: preId.id,
-                        short_label: preId.short_label,
-                        claim_id: newClaimId,
-                        agent: newAgentName,
-                        dispatcher_agent: senderAgent,
-                        dispatcher_session_id: connectionSessionId,
-                        scope: oldClaim.scope,
-                        description: req.task,
-                        tags: ['coordinate', 'assign', 'reroute'],
+                    transitionAssignment(predecessor.id, 'rerouted', {
+                        actor: senderAgent,
+                        status_reason: `reroute: claim ${oldClaim.id} reassigned`,
                     }, dispatchCwd);
-                    rerouteAssignmentId = assignment.id;
-                    artifacts.push({ type: 'assignment', id: assignment.id });
+                    side_effects.push({ action: 'update', entity: 'assignment', id: predecessor.id });
                 }
                 catch (err) {
-                    warnings.push(`Assignment creation failed for ${newAgentName}: ${err instanceof Error ? err.message : String(err)}`);
+                    warnings.push(`Failed to close predecessor assignment ${predecessor.id}: ${err instanceof Error ? err.message : String(err)}`);
                 }
-                const rerouteBrief = buildCoordinateBrief(newAgentName, req.task, {
-                    claimId: newClaimId,
-                    scope: oldClaim.scope,
-                    worktreePath: rerouteClaimResult.worktreePath,
-                    assignmentId: rerouteAssignmentId,
-                });
-                const delivery_plan = [];
-                const reroutePrepared = [];
-                const queued = queueCoordinateMessage({
-                    agent: newAgentName,
-                    text: rerouteBrief,
-                    messageType: 'assign',
-                    ref: oldClaim.scope,
-                    scope: oldClaim.scope,
-                    requiresAck: true,
-                    claimId: newClaimId,
-                    assignmentId: rerouteAssignmentId,
-                    releasedClaimId: oldClaim.id,
-                    tags: ['coordinate', 'assign', 'reroute'],
-                    payload: {
-                        intent: req.intent,
+            }
+            let newClaimId;
+            if (newAgentName) {
+                const profile = rerouteCheck.profile;
+                if (profile) {
+                    ensureAgentRegisteredForDispatch(newAgentName, dispatchCwd);
+                    const rerouteClaimResult = createCoordinatorClaim({
+                        agent: newAgentName,
                         scope: oldClaim.scope,
-                        claim_id: newClaimId,
-                        ...(rerouteAssignmentId ? { assignment_id: rerouteAssignmentId } : {}),
-                        worktree_path: rerouteClaimResult.worktreePath,
-                        released_claim_id: oldClaim.id,
-                        previous_agent: oldClaim.agent,
-                        constraints: req.constraints,
-                    },
-                    commandMode: 'worker',
-                });
-                if (rerouteAssignmentId) {
+                        description: req.task,
+                        dispatcherAgent: senderAgent,
+                        sessionId: connectionSessionId,
+                        cwd: dispatchCwd,
+                        worktreeBaseRef: req.ref,
+                    });
+                    newClaimId = rerouteClaimResult.claimId;
+                    if (rerouteClaimResult.worktreeWarning) {
+                        warnings.push(rerouteClaimResult.worktreeWarning);
+                    }
+                    artifacts.push({ type: 'claim', id: newClaimId });
+                    side_effects.push({
+                        action: rerouteClaimResult.reusedExisting ? 'reuse' : 'create',
+                        entity: 'claim',
+                        id: newClaimId,
+                    });
+                    let rerouteAssignmentId;
                     try {
-                        attachAssignmentMessageToClaim(newClaimId, queued.entry.message_id, dispatchCwd);
-                        linkClaimToAssignment(newClaimId, rerouteAssignmentId, dispatchCwd);
-                        transitionAssignment(rerouteAssignmentId, 'offered', { actor: senderAgent }, dispatchCwd);
-                        patchAssignmentMessageId(rerouteAssignmentId, queued.entry.message_id, dispatchCwd);
-                        queued.entry.assignment_id = rerouteAssignmentId;
+                        const preId = generateAssignmentId(dispatchCwd);
+                        const assignment = createAssignment({
+                            id: preId.id,
+                            short_label: preId.short_label,
+                            claim_id: newClaimId,
+                            agent: newAgentName,
+                            dispatcher_agent: senderAgent,
+                            dispatcher_session_id: connectionSessionId,
+                            scope: oldClaim.scope,
+                            description: req.task,
+                            tags: ['coordinate', 'assign', 'reroute'],
+                        }, dispatchCwd);
+                        rerouteAssignmentId = assignment.id;
+                        artifacts.push({ type: 'assignment', id: assignment.id });
                     }
                     catch (err) {
-                        warnings.push(`Assignment linkage failed for ${newAgentName}: ${err instanceof Error ? err.message : String(err)}`);
+                        warnings.push(`Assignment creation failed for ${newAgentName}: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                    const rerouteBrief = buildCoordinateBrief(newAgentName, req.task, {
+                        claimId: newClaimId,
+                        scope: oldClaim.scope,
+                        worktreePath: rerouteClaimResult.worktreePath,
+                        assignmentId: rerouteAssignmentId,
+                    });
+                    const delivery_plan = [];
+                    const reroutePrepared = [];
+                    const queued = queueCoordinateMessage({
+                        agent: newAgentName,
+                        text: rerouteBrief,
+                        messageType: 'assign',
+                        ref: oldClaim.scope,
+                        scope: oldClaim.scope,
+                        requiresAck: true,
+                        claimId: newClaimId,
+                        assignmentId: rerouteAssignmentId,
+                        releasedClaimId: oldClaim.id,
+                        tags: ['coordinate', 'assign', 'reroute'],
+                        payload: {
+                            intent: req.intent,
+                            scope: oldClaim.scope,
+                            claim_id: newClaimId,
+                            ...(rerouteAssignmentId ? { assignment_id: rerouteAssignmentId } : {}),
+                            worktree_path: rerouteClaimResult.worktreePath,
+                            released_claim_id: oldClaim.id,
+                            previous_agent: oldClaim.agent,
+                            constraints: req.constraints,
+                        },
+                        commandMode: 'worker',
+                    });
+                    if (rerouteAssignmentId) {
+                        try {
+                            attachAssignmentMessageToClaim(newClaimId, queued.entry.message_id, dispatchCwd);
+                            linkClaimToAssignment(newClaimId, rerouteAssignmentId, dispatchCwd);
+                            transitionAssignment(rerouteAssignmentId, 'offered', { actor: senderAgent }, dispatchCwd);
+                            patchAssignmentMessageId(rerouteAssignmentId, queued.entry.message_id, dispatchCwd);
+                            queued.entry.assignment_id = rerouteAssignmentId;
+                        }
+                        catch (err) {
+                            warnings.push(`Assignment linkage failed for ${newAgentName}: ${err instanceof Error ? err.message : String(err)}`);
+                        }
                     }
+                    delivery_plan.push(queued.entry);
+                    reroutePrepared.push({ entry: queued.entry, invoke: queued.invoke, worktreePath: rerouteClaimResult.worktreePath });
+                    const rerouteExecStatus = await runCoordinateExecution(reroutePrepared, {
+                        autoExecute: effectiveAutoExecute !== false,
+                        senderAgent, senderAgentId, cwd: dispatchCwd, warnings,
+                    });
+                    result = {
+                        released_claim: oldClaim.id,
+                        old_agent: oldClaim.agent,
+                        new_agent: newAgentName,
+                        new_claim_id: newClaimId,
+                        selected_targets: resolvedAgents,
+                        delivery_plan,
+                        messages_sent: toMessageSummary(delivery_plan),
+                        commands: commandHints,
+                        execution_status: rerouteExecStatus,
+                    };
                 }
-                delivery_plan.push(queued.entry);
-                reroutePrepared.push({ entry: queued.entry, invoke: queued.invoke, worktreePath: rerouteClaimResult.worktreePath });
-                const rerouteExecStatus = await runCoordinateExecution(reroutePrepared, {
-                    autoExecute: effectiveAutoExecute !== false,
-                    senderAgent, senderAgentId, cwd: dispatchCwd, warnings,
-                });
+                else {
+                    warnings.push(`Unknown agent profile: ${newAgentName}`);
+                }
+            }
+            if (!('released_claim' in result)) {
                 result = {
                     released_claim: oldClaim.id,
                     old_agent: oldClaim.agent,
                     new_agent: newAgentName,
                     new_claim_id: newClaimId,
                     selected_targets: resolvedAgents,
-                    delivery_plan,
-                    messages_sent: toMessageSummary(delivery_plan),
+                    delivery_plan: [],
+                    messages_sent: [],
                     commands: commandHints,
-                    execution_status: rerouteExecStatus,
                 };
             }
-            else {
-                warnings.push(`Unknown agent profile: ${newAgentName}`);
-            }
-        }
-        if (!('released_claim' in result)) {
-            result = {
-                released_claim: oldClaim.id,
-                old_agent: oldClaim.agent,
-                new_agent: newAgentName,
-                new_claim_id: newClaimId,
-                selected_targets: resolvedAgents,
-                delivery_plan: [],
-                messages_sent: [],
-                commands: commandHints,
-            };
         }
-    }
     else if (req.intent === 'summarize') {
         const threadId = req.threadId ?? req.scope;
         if (!threadId) {
@@ -1607,7 +1883,7 @@ export async function handleBclawCoordinate(args, ctx) {
                     // loop doesn't contain. The task text is already captured on
                     // the thread (title + goal).
                     if (!presetSelected) {
-                        const proposalBody = req.task.slice(0, 4000);
+                        const proposalBody = capLoopArtifactBody(req.task);
                         const updated = add_artifact({
                             id: loop.id,
                             actor: creatorActor,