brainclaw 1.28.0 → 1.28.2

package/dist/commands/mcp.js

@@ -39,7 +39,7 @@ import { ensureTrust, resolveMutationIdentity, explicitSessionIdFromEnv, project
 // point: it imports the extracted modules for its own use and re-exports the
 // full historical surface below so external importers are unaffected.
 // ---------------------------------------------------------------------------
-import { SCHEMA_VERSION, MCP_PROTOCOL_VERSIONS, MCP_SERVER_NOT_INITIALIZED, toolResponse, createToolErrorResponse, } from './mcp-contract.js';
+import { MCP_PROTOCOL_VERSIONS, MCP_SERVER_NOT_INITIALIZED, toolResponse, createToolErrorResponse, } from './mcp-contract.js';
 import { MCP_READ_TOOLS, PUBLISHED_TOOLS, DEFAULT_PUBLISHED_TOOLS, UNINITIALIZED_TOOL_NAMES, UNINITIALIZED_PUBLISHED_TOOLS, buildUninitializedStateMessage, LEGACY_READ_TOOL_HANDLERS, } from './mcp-catalog.js';
 // Claim/assignment write handlers extracted in pln#622 PR3b. The shared write
 // helpers (ensureTrust, resolveExecutionWriteTarget, …) stay here and are
@@ -227,7 +227,10 @@ export function createInitializeResult(protocolVersion, options) {
     const uninitialized = options?.uninitialized === true;
     return {
         protocolVersion,
-        serverInfo: { name: 'brainclaw', version: SCHEMA_VERSION },
+        // MCP serverInfo.version is the running PRODUCT version. SCHEMA_VERSION
+        // belongs to tool envelopes and made stale processes impossible to
+        // distinguish during the DGX 1.28.0→1.28.1 dogfood.
+        serverInfo: { name: 'brainclaw', version: getInstalledBrainclawVersion() },
         // listChanged is only advertised in setup mode, where the catalog flips
         // to the full set once the project memory is initialized.
         capabilities: { tools: { listChanged: uninitialized } },
@@ -1095,10 +1098,21 @@ async function _executeMcpToolCallInner(payload) {
             const be = new JsonlBackend();
             if (name === 'bclaw_code_status') {
                 const status = await be.status({ cwd, cascade: args.cascade === true });
+                const diskVersion = readDiskBrainclawVersion();
                 return {
                     response: toolResponse({
                         content: [{ type: 'text', text: `Code Map: ${status.store_exists ? 'store present' : 'no store'} — freshness=${status.freshness_badge.freshness}` }],
-                        structuredContent: { ...status, freshness_badge: status.freshness_badge },
+                        structuredContent: {
+                            ...status,
+                            freshness_badge: status.freshness_badge,
+                            mcp_resolution: {
+                                active_source: scopeInfo.active_source,
+                                resolved_project: scopeInfo.resolved_project,
+                                server_version: getInstalledBrainclawVersion(),
+                                disk_version: diskVersion,
+                                restart_required: diskVersion !== '0.0.0' && diskVersion !== getInstalledBrainclawVersion(),
+                            },
+                        },
                     }),
                 };
             }
@@ -1457,10 +1471,24 @@ async function _executeMcpToolCallInner(payload) {
                             const full = candidateIds
                                 .map((id) => loadAssignment(id, targetCwd))
                                 .filter((a) => a !== undefined);
-                            sweepAssignmentsAtReadPath(full, targetCwd, {
+                            const sweep = sweepAssignmentsAtReadPath(full, targetCwd, {
                                 actor: 'bclaw_work-readpath',
                                 policy,
                             });
+                            // The context snapshot was built before the lazy sweep. Reflect
+                            // the same-pass mutations so bclaw_work never serves a fossil as
+                            // active once it has just expired/timed it out on disk.
+                            const parked = new Set([
+                                ...sweep.expired.map((item) => item.assignment_id),
+                                ...sweep.timed_out.map((item) => item.assignment_id),
+                            ]);
+                            const advanced = new Map(sweep.implicitly_advanced.map((item) => [item.assignment_id, item.to]));
+                            contextResult.open_work.active_assignments = openAssignments
+                                .filter((assignment) => !parked.has(assignment.id))
+                                .map((assignment) => {
+                                const status = advanced.get(assignment.id);
+                                return status ? { ...assignment, status } : assignment;
+                            });
                         }
                         const registry = loadServeRegistry(targetCwd);
                         const aged = ageStaleWarnings(contextResult.stale_warnings ?? [], targetCwd, { policy, registry });

package/dist/core/actions.js

@@ -11,6 +11,7 @@ import { emitRegistryPostImage, registryFaultPoint } from './events/registry-pos
 import { createRuntimeEvent } from './events.js';
 import { loadAssignment, transitionAssignment } from './assignments.js';
 import { loadAgentRun, transitionAgentRun } from './agentruns.js';
+import { denyContinuation } from './loops/continuation.js';
 function actionsDir(cwd, mode = 'read') {
     return resolveEntityDir('actions', cwd ?? process.cwd(), mode);
 }
@@ -90,7 +91,7 @@ function expireStaleActions(actions, cwd) {
             }
             catch { /* best-effort */ }
             try {
-                const assignment = loadAssignment(action.assignment_id, cwd);
+                const assignment = action.assignment_id ? loadAssignment(action.assignment_id, cwd) : undefined;
                 if (assignment && assignment.status === 'blocked') {
                     transitionAssignment(assignment.id, 'failed', {
                         actor: action.agent,
@@ -102,6 +103,12 @@ function expireStaleActions(actions, cwd) {
                 }
             }
             catch { /* best-effort */ }
+            try {
+                if (action.target?.kind === 'continuation') {
+                    denyContinuation(action.target.continuation_id, `approval ${action.id} expired`, action.agent, action.agent_id, cwd);
+                }
+            }
+            catch { /* best-effort */ }
             try {
                 appendAuditEntry({
                     actor: action.agent,
@@ -184,11 +191,15 @@ function saveActionRequired(action, cwd) {
 export function createActionRequired(options, cwd) {
     const generated = generateIdWithLabel('actions', cwd);
     const now = nowISO();
+    const target = options.target ?? (options.assignment_id
+        ? { kind: 'assignment', assignment_id: options.assignment_id }
+        : undefined);
     const action = ActionRequiredSchema.parse({
         schema_version: 1,
         id: generated.id,
         short_label: generated.short_label,
         assignment_id: options.assignment_id,
+        target,
         run_id: options.run_id,
         claim_id: options.claim_id,
         message_id: options.message_id,
@@ -216,7 +227,7 @@ export function createActionRequired(options, cwd) {
         action: 'create',
         item_id: action.id,
         item_type: 'state',
-        after: { kind: action.kind, assignment_id: action.assignment_id, run_id: action.run_id },
+        after: { kind: action.kind, target: action.target, assignment_id: action.assignment_id, run_id: action.run_id },
         scope: action.scope,
         session_id: action.session_id,
     }, cwd);
@@ -268,6 +279,9 @@ export function resolveActionRequired(id, options, cwd) {
             responded_at: now,
         };
         saveActionRequired(action, cwd);
+        if (action.target?.kind === 'continuation' && options.outcome !== 'resolved') {
+            denyContinuation(action.target.continuation_id, `approval ${action.id} ${options.outcome}`, options.responded_by, options.responded_by_id, cwd);
+        }
         appendAuditEntry({
             actor: options.responded_by,
             actor_id: options.responded_by_id,
@@ -301,7 +315,7 @@ export function resolveActionRequired(id, options, cwd) {
                 }
             }
         }
-        const assignment = loadAssignment(action.assignment_id, cwd);
+        const assignment = action.assignment_id ? loadAssignment(action.assignment_id, cwd) : undefined;
         if (assignment) {
             if (options.outcome === 'resolved' && assignment.status === 'blocked') {
                 transitionAssignment(assignment.id, 'started', {

package/dist/core/agentrun-reconciler.js

@@ -36,7 +36,7 @@ import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import { loadAgentRun, recordExecutionContractAnomaly, transitionAgentRun, listAgentRuns } from './agentruns.js';
 import { loadClaim, releaseClaim } from './claims.js';
-import { loadAssignment } from './assignments.js';
+import { convergeAssignmentToTerminal, loadAssignment, transitionAssignment } from './assignments.js';
 import { createRuntimeEvent } from './events.js';
 import { nowISO } from './ids.js';
 import { readContractAck, readHeartbeat, readLogTail, signalExists, latestActivityMs, readCompletionSignals } from './runtime-signals.js';
@@ -44,7 +44,7 @@ import { validateWorkerContractAcceptance } from './execution-contract.js';
 import { findReservationByRunId, evidenceMatchesAttempt, launchGrant, revokeLaunchGrant } from './loops/attempt-reservation.js';
 import { executionContractForGeneration } from './loops/attempt-authority.js';
 import { readLaunchDecision, resolveTurnGenerationChain } from './loops/attempt-generations.js';
-import { reconcileFailedTurn } from './loops/reconcile-turn.js';
+import { reconcileFailedTurn, reconcileLaneResultForRun } from './loops/reconcile-turn.js';
 // ── Constants ──────────────────────────────────────────────────────────────
 /**
  * Minimum age before a run is eligible for reconciliation. Below this, the
@@ -76,6 +76,47 @@ export const DEFAULT_HEARTBEAT_STALE_MS = 10 * 60_000;
 const TERMINAL_STATUSES = new Set([
     'completed', 'failed', 'cancelled', 'timed_out', 'interrupted',
 ]);
+/** Shared business-result bridge for every lazy AgentRun read path. */
+function reconcileOwnedLaneResultAtRead(run, evidence, cwd, actor) {
+    if (!evidence.turn_owned)
+        return undefined;
+    const lane = reconcileLaneResultForRun(run, cwd ?? process.cwd(), actor);
+    if (!lane.found)
+        return undefined;
+    if (!lane.valid || !lane.result?.reconciled) {
+        return { withheld_reason: `lane_result_withheld: ${lane.reason}` };
+    }
+    const after = loadAgentRun(run.id, cwd) ?? run;
+    return { result: {
+            run_id: run.id,
+            action: 'reconciled_turn',
+            reason: `lane_result_reconciled: ${lane.reason}`,
+            evidence,
+            previous_status: run.status,
+            current_status: after.status,
+        },
+    };
+}
+/** A malformed/foreign business result withholds success, but it must not mask
+ * independent, conclusive failure evidence forever. */
+function settleWithheldLaneFailure(run, evidence, actor, cwd, reason) {
+    try {
+        transitionAgentRun(run.id, 'failed', { actor, status_reason: reason }, cwd);
+        convergeAssignmentFromRun(run, 'failed', evidence, actor, cwd);
+        cascadeReleaseOnFailure(run, actor, cwd, 'failed', reason);
+        return { run_id: run.id, action: 'inferred_failed', reason, evidence, previous_status: run.status, current_status: 'failed' };
+    }
+    catch (err) {
+        return {
+            run_id: run.id,
+            action: 'no_op',
+            reason: `failure transition rejected: ${err instanceof Error ? err.message : String(err)}`,
+            evidence,
+            previous_status: run.status,
+            current_status: run.status,
+        };
+    }
+}
 // ── Process liveness ───────────────────────────────────────────────────────
 /**
  * Cross-platform "is this PID alive" check. `process.kill(pid, 0)` does NOT
@@ -309,6 +350,32 @@ export function collectEvidence(run, cwd, options) {
 function fsActiveWithin(evidence, windowMs) {
     return evidence.fs_activity_age_ms !== undefined && evidence.fs_activity_age_ms < windowMs;
 }
+/** Align a non-turn-owned Assignment with conclusive runtime evidence. */
+function convergeAssignmentFromRun(run, outcome, evidence, actor, cwd) {
+    if (findReservationByRunId(run.id, cwd))
+        return false;
+    const assignment = loadAssignment(run.assignment_id, cwd);
+    if (!assignment || ['completed', 'failed', 'blocked', 'timed_out', 'cancelled', 'expired', 'rerouted'].includes(assignment.status)) {
+        return false;
+    }
+    if (outcome === 'completed') {
+        // A released claim alone is not business proof of successful work.
+        if (!evidence.completed_signal && !evidence.has_post_start_commit && !evidence.assignment_completed)
+            return false;
+        return convergeAssignmentToTerminal(assignment.id, 'completed', `agent_run ${run.id} completed from authoritative runtime evidence`, cwd);
+    }
+    try {
+        transitionAssignment(assignment.id, 'failed', {
+            actor,
+            syncAgentRun: false,
+            status_reason: `agent_run ${run.id} failed from liveness reconciliation`,
+        }, cwd);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * trp#433 — when a run is reconciled to `failed` (silent_death / stalled), release
  * its linked claim so dead runs stop leaving active claims (and their worktrees)
@@ -542,6 +609,15 @@ export function reconcileAgentRun(runId, cwd, options = {}) {
     }
     const previous_status = run.status;
     const evidence = collectEvidence(run, cwd, { nowMs: options.nowMs });
+    const actor = options.actor ?? 'reconciler';
+    // pln#692 P0 — LANE-RESULT is the worker's business outcome, not merely a
+    // process-liveness hint. Reconcile it before the terminal-run short circuit
+    // and before generic sentinel completion so a replay heals every projection
+    // (slot, assignment, run, claim) and malformed/foreign results cannot leave
+    // only the run marked completed.
+    const laneResult = reconcileOwnedLaneResultAtRead(run, evidence, cwd, actor);
+    if (laneResult?.result)
+        return laneResult.result;
     // Never touch terminal runs — they already converged.
     if (TERMINAL_STATUSES.has(run.status)) {
         return {
@@ -549,6 +625,33 @@ export function reconcileAgentRun(runId, cwd, options = {}) {
             evidence, previous_status, current_status: run.status,
         };
     }
+    if (laneResult?.withheld_reason) {
+        const stale = options.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;
+        const heartbeatStale = options.heartbeatStaleMs ?? DEFAULT_HEARTBEAT_STALE_MS;
+        const conclusiveFailure = evidence.failed_signal
+            ? 'wrapper reported non-zero exit'
+            : evidence.heartbeat_exists
+                && evidence.heartbeat_age_ms !== undefined
+                && evidence.heartbeat_age_ms >= heartbeatStale
+                && !fsActiveWithin(evidence, heartbeatStale)
+                ? `heartbeat stalled for ${Math.round(evidence.heartbeat_age_ms / 1000)}s`
+                : evidence.process_alive === false
+                    && evidence.age_ms >= stale
+                    && !fsActiveWithin(evidence, heartbeatStale)
+                    ? 'silent termination past stale window'
+                    : undefined;
+        if (conclusiveFailure) {
+            return settleWithheldLaneFailure(run, evidence, actor, cwd, `invalid_lane_result_with_conclusive_failure: ${conclusiveFailure}; ${laneResult.withheld_reason}`);
+        }
+        return {
+            run_id: run.id,
+            action: 'health_check_unverified',
+            reason: laneResult.withheld_reason,
+            evidence,
+            previous_status: run.status,
+            current_status: run.status,
+        };
+    }
     if (evidence.contract_acceptance_anomaly) {
         try {
             recordExecutionContractAnomaly(runId, {
@@ -580,7 +683,6 @@ export function reconcileAgentRun(runId, cwd, options = {}) {
     }
     const grace = options.healthCheckGraceMs ?? DEFAULT_HEALTH_CHECK_GRACE_MS;
     const stale = options.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;
-    const actor = options.actor ?? 'reconciler';
     // Below grace window: too early to draw any conclusion. Caller should
     // re-poll later.
     if (evidence.age_ms < grace) {
@@ -596,6 +698,7 @@ export function reconcileAgentRun(runId, cwd, options = {}) {
                 actor,
                 status_reason: `inferred=true; evidence: ${describeEvidence(evidence)}`,
             }, cwd);
+            convergeAssignmentFromRun(run, 'completed', evidence, actor, cwd);
             return {
                 run_id: runId, action: 'inferred_completed',
                 reason: `inferred=true; ${describeEvidence(evidence)}`,
@@ -617,6 +720,7 @@ export function reconcileAgentRun(runId, cwd, options = {}) {
     const failHere = (reason) => {
         try {
             transitionAgentRun(runId, 'failed', { actor, status_reason: reason }, cwd);
+            convergeAssignmentFromRun(run, 'failed', evidence, actor, cwd);
             cascadeReleaseOnFailure(run, actor, cwd, 'failed', reason);
             return { run_id: runId, action: 'inferred_failed', reason, evidence, previous_status, current_status: 'failed' };
         }
@@ -814,18 +918,47 @@ export function reconcileDeadPidRunningAgentRunAtRead(runId, cwd, options = {})
         };
     }
     const evidence = collectEvidence(run, cwd, { nowMs: options.nowMs });
+    const actor = options.actor ?? 'reconciler';
+    const laneResult = reconcileOwnedLaneResultAtRead(run, evidence, cwd, actor);
+    if (laneResult?.result)
+        return laneResult.result;
     if (run.status !== 'running') {
         return {
             run_id: run.id, action: 'no_op', reason: `run status is ${run.status}, not running`,
             evidence, previous_status: run.status, current_status: run.status,
         };
     }
-    const actor = options.actor ?? 'reconciler';
     const stale = options.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;
     const heartbeatStale = options.heartbeatStaleMs ?? DEFAULT_HEARTBEAT_STALE_MS;
+    if (laneResult?.withheld_reason) {
+        const conclusiveFailure = evidence.failed_signal
+            ? 'wrapper reported non-zero exit'
+            : evidence.heartbeat_exists
+                && evidence.heartbeat_age_ms !== undefined
+                && evidence.heartbeat_age_ms >= heartbeatStale
+                && !fsActiveWithin(evidence, heartbeatStale)
+                ? `heartbeat stalled for ${Math.round(evidence.heartbeat_age_ms / 1000)}s`
+                : evidence.process_alive === false
+                    && evidence.age_ms >= stale
+                    && !fsActiveWithin(evidence, heartbeatStale)
+                    ? 'silent termination past stale window'
+                    : undefined;
+        if (conclusiveFailure) {
+            return settleWithheldLaneFailure(run, evidence, actor, cwd, `invalid_lane_result_with_conclusive_failure: ${conclusiveFailure}; ${laneResult.withheld_reason}`);
+        }
+        return {
+            run_id: run.id,
+            action: 'health_check_unverified',
+            reason: laneResult.withheld_reason,
+            evidence,
+            previous_status: run.status,
+            current_status: run.status,
+        };
+    }
     const failRun = (reason) => {
         try {
             transitionAgentRun(run.id, 'failed', { actor, status_reason: reason }, cwd);
+            convergeAssignmentFromRun(run, 'failed', evidence, actor, cwd);
             cascadeReleaseOnFailure(run, actor, cwd, 'failed', reason);
             return { run_id: run.id, action: 'inferred_failed', reason, evidence, previous_status: run.status, current_status: 'failed' };
         }
@@ -846,6 +979,7 @@ export function reconcileDeadPidRunningAgentRunAtRead(runId, cwd, options = {})
                 actor,
                 status_reason: `inferred=true; evidence: ${describeEvidence(evidence)}`,
             }, cwd);
+            convergeAssignmentFromRun(run, 'completed', evidence, actor, cwd);
             return {
                 run_id: run.id, action: 'inferred_completed',
                 reason: `inferred=true; ${describeEvidence(evidence)}`,

package/dist/core/claims.js

@@ -963,7 +963,10 @@ export function createCoordinatorClaim(options) {
     // `.github/workflows` previously produced `feat/.github-…` (leading dot),
     // which git rejects and the whole spawn failed.
     const branchSlug = sanitizeBranchComponent(options.scope);
-    const worktreeBranch = `feat/${branchSlug}`;
+    const branchSuffix = options.worktreeBranchSuffix
+        ? `-${sanitizeBranchComponent(options.worktreeBranchSuffix)}`
+        : '';
+    const worktreeBranch = `feat/${branchSlug}${branchSuffix}`;
     try {
         worktreePath = createWorktree(options.cwd, worktreeBranch, {
             sessionId: options.sessionId,

package/dist/core/code-map/backend.js

@@ -21,6 +21,7 @@ import { resolveTraversal, aggregateFind, aggregateBrief } from './aggregate.js'
 import { defaultMemoryReader } from './memory-reader.js';
 import { listNestedProjects, refreshWorkspaceCascade } from './cascade.js';
 import { loadConfig } from '../config.js';
+import { codeMapDir } from './paths.js';
 /** spec §9 caps the brief reading list at 12 files. */
 export const BRIEF_FILE_CAP = 12;
 /**
@@ -140,10 +141,16 @@ export class JsonlBackend {
         this.gitHeadReader = opts.gitHeadReader ?? readCurrentGitHead;
     }
     async status(input) {
+        const projectRoot = path.resolve(input.cwd ?? process.cwd());
+        const resolution = {
+            project_root: projectRoot,
+            store_path: codeMapDir(projectRoot, input.preferredDirName),
+        };
         const manifest = readManifest(input.cwd, input.preferredDirName);
         const result = manifest
             ? {
                 store_exists: true,
+                resolution,
                 freshness_badge: this.withHeadDrift(badge(manifest.freshness.status, {
                     stale_file_count: manifest.freshness.stale_file_count,
                     partial_reason: manifest.freshness.partial_reason,
@@ -156,6 +163,7 @@ export class JsonlBackend {
             }
             : {
                 store_exists: storeExists(input.cwd, input.preferredDirName),
+                resolution,
                 freshness_badge: badge('missing_index'),
                 stats: null,
             };

package/dist/core/execution-adapters.js

@@ -197,13 +197,21 @@ export function withCodexWorkspaceRoot(invoke, agent, worktreePath, isWin32 = pr
     args.splice(insertAt, 0, '--cd', worktreePath);
     const quote = (value) => isWin32
         ? `"${value.replace(/"/g, '""')}"`
-        : `'${value.replace(/'/g, `'\\''`)}'`;
-    const flags = `--cd ${quote(worktreePath)}`;
-    const prefix = invoke.executable;
-    const suffix = invoke.bashCommand.startsWith(`${prefix} `)
-        ? invoke.bashCommand.slice(prefix.length + 1)
-        : invoke.bashCommand;
-    return { ...invoke, args, bashCommand: `${prefix} ${flags} ${suffix}` };
+        : `"${value.replace(/\\/g, '\\\\').replace(/\$/g, '\\$').replace(/`/g, '\\`').replace(/"/g, '\\"')}"`;
+    // Re-render from structured argv. bashCommand also contains the model-authored
+    // prompt, so searching it for "| codex" can mistake prompt data for the real
+    // executable boundary and splice --cd inside quoted content.
+    const command = [invoke.executable, ...args.map(quote)].join(' ');
+    const prompt = invoke.promptText ?? '';
+    const escapedPrompt = prompt.replace(/'/g, "'\\''");
+    let bashCommand = command;
+    if (!isWin32 && invoke.promptDelivery === 'stdin_pipe') {
+        bashCommand = `printf '%s' '${escapedPrompt}' | ${command}`;
+    }
+    else if (!isWin32 && invoke.promptDelivery === 'temp_file' && invoke.tempFilePath) {
+        bashCommand = `printf '%s' '${escapedPrompt}' > ${quote(invoke.tempFilePath)} && ${command}`;
+    }
+    return { ...invoke, args, bashCommand };
 }
 export class CliExecutionAdapter {
     id = 'cli';

package/dist/core/hygiene-policy.js

@@ -25,7 +25,8 @@ import { logger } from './logger.js';
 const DAY_MS = 24 * 60 * 60 * 1000;
 export const DEFAULT_HYGIENE_POLICY = {
     disabled: false,
-    assignment_offered_ttl_ms: 3 * DAY_MS,
+    // A never-accepted dispatch should not survive into the next day's dogfood.
+    assignment_offered_ttl_ms: 1 * DAY_MS,
     assignment_accepted_ttl_ms: 1 * DAY_MS,
     assignment_started_ttl_ms: 1 * DAY_MS,
     handoff_closed_ttl_ms: 30 * DAY_MS,

package/dist/core/loop-turn-dispatch.js

@@ -10,7 +10,7 @@ import { resolveModel } from './agent-capability.js';
 import { listAgentIdentities } from './agent-registry.js';
 import { transitionAgentRun } from './agentruns.js';
 import { loadAssignment, patchAssignmentMessageId, transitionAssignment } from './assignments.js';
-import { attachAssignmentMessageToClaim, createCoordinatorClaim, ensureClaimAssignmentBinding, } from './claims.js';
+import { attachAssignmentMessageToClaim, createCoordinatorClaim, ensureClaimAssignmentBinding, releaseClaimIfActive, } from './claims.js';
 import { generateDispatchBrief } from './dispatcher.js';
 import { search } from './search.js';
 import { attemptExecution } from './execution.js';
@@ -21,6 +21,7 @@ import { buildIdeationBrief } from './loops/brief-assembly.js';
 import { getLoop } from './loops/store.js';
 import { prepareTurnExecution } from './loops/turn-execution.js';
 import { sendMessage } from './messaging.js';
+import { removeWorktree } from './worktree.js';
 export async function dispatchLoopTurn(input) {
     const loop = getLoop(input.loop_id, input.cwd);
     if (!loop)
@@ -131,6 +132,22 @@ export async function dispatchLoopTurn(input) {
         if (prepared.kind !== 'won') {
             result.execution_status = 'inbox_only';
             result.error = prepared.reason;
+            if (prepared.claim_disposition === 'release' && !claim.reusedExisting) {
+                try {
+                    const released = releaseClaimIfActive(claim.claimId, input.cwd);
+                    if (released.released && claim.worktreePath) {
+                        try {
+                            removeWorktree(input.cwd, claim.worktreePath, { force: true });
+                        }
+                        catch (cleanupError) {
+                            result.error += `; denied-claim worktree cleanup failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`;
+                        }
+                    }
+                }
+                catch (cleanupError) {
+                    result.error += `; denied-claim cleanup failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`;
+                }
+            }
             return result;
         }
         result.assignment_id = prepared.assignment_id;

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

@@ -219,6 +219,7 @@ export function executionContractForGeneration(reservation, generation) {
         }
         return { contract, ref };
     }
+    const snapshot = generation.executor?.capability_snapshot ?? reservation.capability_snapshot;
     const contract = ExecutionContractSchema.parse({
         ...reservation.execution_contract,
         identity: {
@@ -234,7 +235,7 @@ export function executionContractForGeneration(reservation, generation) {
             isolation: 'worktree',
         },
     });
-    const ref = executionContractRef(contract, reservation.capability_snapshot);
+    const ref = executionContractRef(contract, snapshot);
     if (ref.hash !== generation.contract_hash) {
         throw new AttemptGenerationError('fenced', `generation ${generation.attempt_epoch} contract hash ${generation.contract_hash} does not match derived ${ref.hash}`);
     }
@@ -269,6 +270,12 @@ export function bootstrapAttemptAuthorityV2(input) {
         workspace_path: workspacePath,
         workspace_digest: attemptWorkspaceDigest(workspacePath, reservation.turn_id, 0),
         launch_nonce: grant.token,
+        executor: {
+            agent: reservation.agent,
+            agent_id: reservation.agent_id,
+            claim_id: reservation.claim_id,
+            capability_snapshot: reservation.capability_snapshot,
+        },
     });
     if (initial.assignment_id !== reservation.child_ids.assignment_id
         || initial.run_id !== reservation.child_ids.run_id
@@ -331,7 +338,8 @@ export function prepareAttemptTakeoverV2(input) {
             && close.decision === expectedMode
             && close.cause === requestedCause
             && canonicalWorkspacePath(close.next_generation.workspace_path) === canonicalWorkspacePath(input.next_workspace_path)
-            && JSON.stringify(close.next_generation.authority_home) === JSON.stringify(input.authority_home)) {
+            && JSON.stringify(close.next_generation.authority_home) === JSON.stringify(input.authority_home)
+            && (!input.next_executor || JSON.stringify(close.next_generation.executor) === JSON.stringify(input.next_executor))) {
             const generationContract = executionContractForGeneration(reservation, close.next_generation);
             return {
                 won: false,
@@ -376,9 +384,10 @@ export function prepareAttemptTakeoverV2(input) {
         contract_hash: '0'.repeat(64),
         workspace_path: nextWorkspacePath,
         workspace_digest: attemptWorkspaceDigest(nextWorkspacePath, input.turn_id, nextEpoch),
+        executor: input.next_executor,
     });
     const baseContract = reservation.execution_contract;
-    const snapshot = reservation.capability_snapshot;
+    const snapshot = input.next_executor?.capability_snapshot ?? reservation.capability_snapshot;
     if (!baseContract || !snapshot) {
         throw new AttemptGenerationError('invalid_transition', `turn ${input.turn_id} lacks a contracted capability snapshot`);
     }
@@ -402,6 +411,7 @@ export function prepareAttemptTakeoverV2(input) {
         contract_hash: nextRef.hash,
         workspace_path: nextWorkspacePath,
         workspace_digest: attemptWorkspaceDigest(nextWorkspacePath, input.turn_id, nextEpoch),
+        executor: input.next_executor,
         launch_nonce: provisional.launch_nonce,
         created_at: provisional.created_at,
     });
@@ -419,7 +429,15 @@ export function prepareAttemptTakeoverV2(input) {
     if (generationDigest(incumbent.next_generation) !== generationDigest(next)) {
         throw new AttemptGenerationError('fenced', `a different successor already won generation ${current.attempt_epoch}`);
     }
-    rebuildAttemptGenerationHead(input.cwd, current);
+    // The close cell above is the immutable authority boundary. `head.json` is
+    // only a rebuildable read cache, so a projection failure after a winning
+    // close must never escape as a pre-commit takeover failure: callers could
+    // otherwise roll back claims while the successor generation already owns
+    // the turn. Readers repair the cache from immutable cells on replay.
+    try {
+        rebuildAttemptGenerationHead(input.cwd, current);
+    }
+    catch { /* immutable close(epoch) remains authoritative */ }
     return {
         won: published.won,
         rollout,

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',