brainclaw 1.28.0 → 1.28.2

package/dist/cli/register-coordination.js

@@ -466,6 +466,18 @@ export function registerCoordinationCommands(program) {
         const { runLoopCommand } = await import('../commands/loop.js');
         await runLoopCommand('add-artifact', { loop_id }, options, globalOpts.cwd);
     });
+    loopCmd
+        .command('continue <loop_id>')
+        .description('Evaluate and apply a persisted cross-loop continuation')
+        .option('--action-index <n>', 'Zero-based next_action index', '0')
+        .option('--autonomy-mode <mode>', 'autonomous, require_approval, or deny', 'autonomous')
+        .option('--risk <risk>', 'normal or protected', 'normal')
+        .option('--json', 'Machine-readable output')
+        .action(async (loop_id, options) => {
+        const globalOpts = program.opts();
+        const { runLoopCommand } = await import('../commands/loop.js');
+        await runLoopCommand('continue', { loop_id }, options, globalOpts.cwd);
+    });
     // --- attempt-authority (two-release writer guard; P4) ---
     const attemptAuthorityCmd = program
         .command('attempt-authority')

package/dist/commands/code-map.js

@@ -108,6 +108,8 @@ function printStatus(status, options) {
     }
     console.log('Code Map status');
     console.log(`  Store:    ${status.store_exists ? 'present' : 'absent'}`);
+    console.log(`  Root:     ${status.resolution.project_root}`);
+    console.log(`  Path:     ${status.resolution.store_path}`);
     console.log(`  ${badgeLine(status.freshness_badge)}`);
     if (status.stats) {
         console.log(`  Files:    ${status.stats.files_indexed}`);

package/dist/commands/doctor.js

@@ -518,6 +518,7 @@ export function runDispatchHealthCheck(options = {}) {
         };
         switch (result.action) {
             case 'inferred_completed':
+            case 'reconciled_turn':
                 inferred_completed.push(summary);
                 break;
             case 'health_check_unverified':

package/dist/commands/harvest.js

@@ -25,54 +25,43 @@ import { commitWorktreeOnBehalf, worktreesBaseDir, resolveGitToplevel } from '..
 import { closeReviewLoopFromLaneResult } from '../core/review-loop-close.js';
 import { closeIdeationLoopFromLaneResult } from '../core/ideation-loop-close.js';
 import { dispatchReviewLoopTurn, turnOwnedLoopEnabled } from '../core/review-loop-turn-dispatch.js';
-import { reconcileTurn } from '../core/loops/reconcile-turn.js';
-import { findReservationByAssignmentId } from '../core/loops/attempt-reservation.js';
-import { resolveTurnGenerationChain } from '../core/loops/attempt-generations.js';
+import { reconcileTurnOwnedLane, turnOwnedLaneEvidence } from '../core/loops/reconcile-turn.js';
 import { getLoop } from '../core/loops/store.js';
 import { phasePolicy } from '../core/loops/kind-policies.js';
-import { readCompletionSignals } from '../core/runtime-signals.js';
 import { reconcileClaimConformity } from '../core/claim-conformity.js';
 import { toWarningDetail } from '../core/warnings.js';
 import { harvestHarnessObservation } from '../core/harness-adapters/index.js';
-function turnOwnedLaneEvidence(lane, cwd) {
-    const reservation = findReservationByAssignmentId(lane.assignment_id, cwd);
-    if (!reservation)
-        return undefined; // legacy lane (no reservation)
-    const chain = resolveTurnGenerationChain(cwd, reservation.turn_id);
-    const completion = readCompletionSignals(cwd, reservation.child_ids.assignment_id, chain?.latest_generation.run_id).completed;
-    const nonce = lane.nonce ?? completion?.nonce;
-    if (!nonce && !reservation.execution_contract_ref)
-        return undefined;
-    return {
-        reservation,
-        nonce,
-        contract_hash: lane.execution_contract_hash ?? completion?.contract_hash,
-        capability_snapshot_hash: lane.capability_snapshot_hash ?? completion?.capability_snapshot_hash,
-    };
-}
-function reconcileTurnOwnedLane(lane, cwd, evidence) {
-    const ev = evidence ?? turnOwnedLaneEvidence(lane, cwd);
-    if (!ev)
-        return undefined; // legacy lane OR no turn-keyed evidence — caller runs the legacy path
-    const { reservation, nonce } = ev;
-    const enrichedLane = {
-        ...lane,
-        turn_id: lane.turn_id ?? reservation.turn_id,
-        run_id: lane.run_id ?? reservation.child_ids.run_id,
-        nonce,
-        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 });
-    return { reservation, result };
-}
+/**
+ * pln#630 PR3a — finalize a TURN-OWNED review lane via the exactly-once `reconcileTurn`
+ * instead of the legacy `closeReviewLoopFromLaneResult`. Returns `undefined` for a legacy
+ * (non-reserved) lane so the caller runs the unchanged legacy path — this is the
+ * exactly-one-finalizer discriminator: a lane is turn-owned iff a reservation OWNS its
+ * assignment_id (only the turn-owned dispatch writes a reservation file).
+ *
+ * Evidence sourcing (the load-bearing subtlety): a real reviewer's LANE-RESULT.json is
+ * KEYLESS — the review brief never asks the worker to echo turn_id/run_id/nonce — so
+ * read-strict `reconcileTurn` (which matches lane.{turn_id,run_id,nonce} against the
+ * attempt) would REJECT it. We source the keys authoritatively: turn_id + run_id are
+ * deterministic from the reservation, and the NONCE — the non-derivable proof that THIS
+ * launch generation actually ran — comes from the coordinator's completion SENTINEL
+ * (written mechanically by the ack-wrapper with the launch-grant token). A caller/test
+ * that already supplies keyed lanes is honored (lane.* wins); a stale generation's
+ * sentinel carries the old token → still rejected, preserving the anti-stale guarantee.
+ */
+/**
+ * The turn-owned FINALIZATION discriminator (pln#630, review Finding 1). A lane finalizes via
+ * the exactly-once reconcileTurn ONLY if a committed reservation OWNS it AND turn-keyed evidence
+ * (the nonce) is available — from the lane or the coordinator's completion SENTINEL. Without the
+ * nonce, reconcileTurn's read-strict gate can NEVER converge: this is reachable in production
+ * when a turn-owned dispatch WON the fence but did not ack-wrap-spawn (inbox_only / IDE-only
+ * reviewer, command_ready_manual, capacity cap, BRAINCLAW_NO_SPAWN, worktree-creation failure) —
+ * it minted a reservation but no sentinel will ever be written. Returning undefined there routes
+ * the lane to the LEGACY presence-based closer so the loop still converges instead of stalling
+ * forever. This is SAFE: the exactly-once SPAWN guarantee is enforced at DISPATCH by the launch
+ * fence (already run), so using legacy FINALIZATION for a sentinel-less lane reintroduces no
+ * double-spawn; and a sentinel that lands after a legacy close makes a later reconcile a
+ * terminal-loop idempotent no-op.
+ */
 /**
  * Map a `reconcileTurn` result onto the `ReviewLoopCloseResult` shape harvest records for
  * observability (entry.review_loop / CLI). No keep_claim / next_turn: the request_changes

package/dist/commands/loop.js

@@ -154,6 +154,18 @@ function buildRequest(subcommand, loopId, opts) {
                     ref: parseOptionalRef(opts.ref, opts),
                 },
             };
+        case 'continue': {
+            const actionIndex = opts.actionIndex === undefined ? 0 : Number(opts.actionIndex);
+            if (!Number.isInteger(actionIndex) || actionIndex < 0)
+                fail('--action-index must be a non-negative integer', 1, opts);
+            return {
+                intent: 'continue',
+                loop_id: loopId,
+                action_index: actionIndex,
+                autonomy_mode: opts.autonomyMode ?? 'autonomous',
+                risk: opts.risk ?? 'normal',
+            };
+        }
     }
 }
 export async function runLoopCommand(subcommand, args, options = {}, cwd) {

package/dist/commands/loops-handlers.js

@@ -5,7 +5,11 @@ import { dispatchLoopTurn } from '../core/loop-turn-dispatch.js';
 import { findReservationByRunId } from '../core/loops/attempt-reservation.js';
 import { runVerify } from '../core/loops/verify-command.js';
 import { runImplBind } from '../core/loops/impl-bind.js';
-import { add_artifact, advance, AwaitingFileApplyApprovalError, closeLoop, complete_turn, computeNextExpected, getLoop, IdempotencyKeyReusedError, IdempotencyOwnerMismatchError, listLoopEvents, listLoops, LockLostError, LockTimeoutError, openLoop, pause, provideInput, requestInput, resume, sweepPauseTimeouts, takeoverLoopAttempt, readLocalAuthorityHome, turn, VersionConflictError, withLoopLock, } from '../core/loops/index.js';
+import { loadSequence } from '../core/sequence.js';
+import { createActionRequired, loadActionRequired } from '../core/actions.js';
+import { selectImplementationReviewer } from '../core/reviewer-policy.js';
+import { handleBclawCoordinate } from './mcp-write-coordination.js';
+import { add_artifact, advance, AwaitingFileApplyApprovalError, closeLoop, complete_turn, computeNextExpected, getLoop, IdempotencyKeyReusedError, IdempotencyOwnerMismatchError, listLoopEvents, listLoops, LockLostError, LockTimeoutError, openLoop, pause, provideInput, requestInput, resume, sweepPauseTimeouts, takeoverLoopAttempt, readLocalAuthorityHome, turn, VersionConflictError, withLoopLock, artifactEvidenceDigest, attachContinuationActionRequired, ensureContinuation, deriveWorkerReplyContract, evaluatePhaseAdvanceGate, } from '../core/loops/index.js';
 import { BclawLoopRequestSchema, BCLAW_LOOP_INTENTS, } from '../core/loops/facade-schema.js';
 // NextExpectedHint type now lives in src/core/loops/next-expected.ts
 // (hoisted per can_e57c7782 follow-up so MCP facade + CLI share the
@@ -46,12 +50,10 @@ function pipelineNextActions(loop) {
             return [{
                     tool: 'bclaw_loop',
                     args: {
-                        intent: 'open', kind: 'implementation', title: `Implement ${loop.title}`,
-                        goal: loop.goal, linked: { plan_ids: planIds, sequence_ids: sequenceIds, source_loop_id: loop.id },
-                        verify: draft.implementation_verify,
-                        slots: [{ role: 'implementer' }], allow_orphan: true,
+                        intent: 'continue', loop_id: loop.id, action_index: 0,
+                        autonomy_mode: 'autonomous', risk: 'normal',
                     },
-                    when: 'start implementation from the accepted synthesis',
+                    when: 'evaluate and apply the accepted synthesis through persisted continuation policy',
                 }];
         }
         return [{
@@ -60,29 +62,86 @@ function pipelineNextActions(loop) {
                 when: 'materialize the synthesis before opening its implementation loop',
             }];
     }
+    if (loop.kind === 'implementation' && loop.current_phase === 'execute' && loop.status === 'open') {
+        return loop.slots
+            .filter((slot) => slot.status === 'open')
+            .map((slot) => ({
+            tool: 'bclaw_loop',
+            args: {
+                intent: 'turn', loop_id: loop.id, slot_id: slot.slot_id,
+                input: loop.goal ?? loop.title, dispatch: true,
+            },
+            when: `dispatch implementation lane ${slot.lane ?? slot.role} through AttemptAuthority`,
+        }));
+    }
+    if (loop.kind === 'implementation' && (loop.current_phase === 'handoff_ready' || loop.status === 'completed')) {
+        return [{
+                tool: 'bclaw_loop',
+                args: {
+                    intent: 'continue', loop_id: loop.id, action_index: 0,
+                    autonomy_mode: 'autonomous', risk: 'normal',
+                },
+                when: 'evaluate and apply the attested handoff through persisted continuation policy',
+            }];
+    }
+    return [];
+}
+/** Concrete action evaluated by continuation policy; never exposed as an ungoverned hint. */
+function proposedPipelineActions(loop, cwd) {
+    if (loop.kind === 'ideation') {
+        const draft = [...loop.artifacts].reverse().find((artifact) => artifact.type === 'plan_draft');
+        const planIds = loop.linked?.plan_ids ?? [];
+        const sequenceIds = loop.linked?.sequence_ids ?? [];
+        if (!draft || planIds.length === 0 || sequenceIds.length !== 1)
+            return [];
+        const sequence = loadSequence(sequenceIds[0], cwd);
+        const lanes = [...new Set(sequence.items.map((item) => item.lane?.trim() || 'default'))].sort();
+        const sourceDigest = artifactEvidenceDigest(draft);
+        return [{
+                tool: 'bclaw_loop',
+                args: {
+                    intent: 'open', kind: 'implementation', title: `Implement ${loop.title}`,
+                    goal: loop.goal ?? loop.title,
+                    linked: {
+                        plan_ids: planIds, sequence_ids: sequenceIds, source_loop_id: loop.id,
+                        source_artifact_id: draft.artifact_id, source_artifact_digest: sourceDigest,
+                    },
+                    verify: draft.implementation_verify,
+                    slots: lanes.map((lane) => ({ role: 'implementer', lane })),
+                    allow_orphan: true,
+                },
+                when: 'start implementation from the accepted synthesis',
+            }];
+    }
     if (loop.kind === 'implementation' && (loop.current_phase === 'handoff_ready' || loop.status === 'completed')) {
         const handoff = [...loop.artifacts].reverse().find((artifact) => artifact.type === 'handoff');
+        if (!handoff?.ref)
+            return [];
+        const reviewer = selectImplementationReviewer(loop, cwd);
         const reviewScope = [...new Set(loop.slots.map((slot) => slot.scope_hint?.trim()).filter((scope) => Boolean(scope)))].join(',');
+        const sourceDigest = artifactEvidenceDigest(handoff);
         return [{
                 tool: 'bclaw_coordinate',
                 args: {
-                    intent: 'review', open_loop: true,
-                    task: handoff?.ref
-                        ? `Review implementation loop ${loop.id}; handoff ${handoff.ref.kind}:${handoff.ref.id}`
-                        : `Review implementation loop ${loop.id} (${loop.title})`,
-                    targetAgents: ['<reviewer>'],
+                    intent: 'review', open_loop: true, review_mode: 'asymmetric',
+                    task: `Review implementation loop ${loop.id}; handoff ${handoff.ref.kind}:${handoff.ref.id}`,
+                    targetAgents: [reviewer.agent],
                     ...(reviewScope ? { scope: reviewScope } : {}),
-                    ...(handoff?.ref && (handoff.ref.kind === 'commit' || handoff.ref.kind === 'branch')
-                        ? { ref: handoff.ref.id }
-                        : {}),
-                    linked: { source_loop_id: loop.id, plan_ids: loop.linked?.plan_ids, sequence_ids: loop.linked?.sequence_ids },
+                    ...((handoff.ref.kind === 'commit' || handoff.ref.kind === 'branch') ? { ref: handoff.ref.id } : {}),
+                    linked: {
+                        source_loop_id: loop.id,
+                        source_artifact_id: handoff.artifact_id,
+                        source_artifact_digest: sourceDigest,
+                        plan_ids: loop.linked?.plan_ids,
+                        sequence_ids: loop.linked?.sequence_ids,
+                    },
                 },
-                when: 'implementation evidence is handoff-ready',
+                when: `reviewer ${reviewer.agent} selected by ${reviewer.policy_version}`,
             }];
     }
     return [];
 }
-function errorResponse(intent, code, message, durationMs, result = null) {
+function errorResponse(intent, code, message, durationMs, result = null, nextActions = []) {
     return {
         response: {
             status: 'error',
@@ -93,10 +152,72 @@ function errorResponse(intent, code, message, durationMs, result = null) {
             warnings: [],
             error: `${code}: ${message}`,
             duration_ms: durationMs,
+            ...(nextActions.length > 0 ? { next_actions: nextActions } : {}),
         },
         summary: `✘ bclaw_loop[${intent}] ${code}: ${message}`,
     };
 }
+function continuationUnavailableDiagnostic(loop, cwd) {
+    const phase = loop.phases.find((candidate) => candidate.name === loop.current_phase);
+    const gate = phase?.advance_gate;
+    const gateOutcome = evaluatePhaseAdvanceGate(loop, gate, cwd);
+    const contract = deriveWorkerReplyContract(loop);
+    const blockers = [];
+    const probableCauses = [];
+    const nextActions = [];
+    if (!gateOutcome.advance && gateOutcome.gate_reason)
+        blockers.push(gateOutcome.gate_reason);
+    const assigned = loop.slots.filter((slot) => slot.status === 'assigned' && slot.assignment_id);
+    const open = loop.slots.filter((slot) => slot.status === 'open'
+        && !(loop.kind === 'ideation' && loop.current_phase === 'critique' && slot.role === 'champion'));
+    if (assigned.length > 0) {
+        probableCauses.push('one or more dispatched worker results have not converged into gate evidence');
+        for (const slot of assigned) {
+            nextActions.push({
+                tool: 'bclaw_find',
+                args: { entity: 'agent_run', filter: { assignment_id: slot.assignment_id, limit: 10 } },
+                when: `reconcile and inspect the AgentRun projection for slot ${slot.slot_id}`,
+            });
+        }
+    }
+    for (const slot of open) {
+        probableCauses.push(`slot ${slot.slot_id} has not been dispatched`);
+        nextActions.push({
+            tool: 'bclaw_loop',
+            args: { intent: 'turn', loop_id: loop.id, slot_id: slot.slot_id, input: loop.goal ?? loop.title, dispatch: true },
+            when: `dispatch open slot ${slot.slot_id}`,
+        });
+    }
+    if (loop.kind === 'ideation') {
+        const draft = [...loop.artifacts].reverse().find((artifact) => artifact.type === 'plan_draft');
+        if (!draft)
+            blockers.push('no attested plan_draft artifact is available for continuation');
+        if ((loop.linked?.plan_ids?.length ?? 0) === 0)
+            blockers.push('the source loop is not linked to a plan');
+        if ((loop.linked?.sequence_ids?.length ?? 0) !== 1)
+            blockers.push('the source loop must link exactly one implementation sequence');
+    }
+    else if (loop.kind === 'implementation') {
+        const handoff = [...loop.artifacts].reverse().find((artifact) => artifact.type === 'handoff' && artifact.ref);
+        if (!handoff)
+            blockers.push('no attested handoff with a reviewable ref is available');
+    }
+    return {
+        result: {
+            loop_id: loop.id,
+            phase: loop.current_phase,
+            gate: {
+                expected: contract?.requirements ?? (gate ? [gate] : []),
+                observed: gateOutcome.gate_reason ?? 'gate satisfied or no phase gate',
+                passed: gateOutcome.advance,
+            },
+            blockers: [...new Set(blockers)],
+            probable_causes: [...new Set(probableCauses)],
+            next_actions: nextActions,
+        },
+        next_actions: nextActions,
+    };
+}
 function inferIntent(args) {
     if (!args || typeof args !== 'object')
         return 'unknown';
@@ -235,6 +356,59 @@ function trySweepLoopTimeouts(loop_id, cwd) {
     }
     catch { /* best-effort: never block facade on sweep errors */ }
 }
+/** Execute a persisted continuation through the same public handler used by MCP/CLI callers. */
+export async function executeContinuationPublicAction(record, options) {
+    const args = record.action.args ?? {};
+    const linked = (args.linked && typeof args.linked === 'object' ? args.linked : {});
+    const publicArgs = {
+        ...args,
+        linked: { ...linked, continuation_key: record.continuation_key },
+        client_request_id: `ctn_${record.continuation_key}`,
+        agent: options.actor,
+        agentId: options.agentId,
+    };
+    let downstreamId;
+    if (record.action.tool === 'bclaw_loop') {
+        const opened = await handleBclawLoop({
+            args: publicArgs, cwd: options.cwd, defaultActor: options.actor, sessionId: options.sessionId,
+        });
+        if (opened.response.status !== 'ok')
+            throw new Error(opened.response.error ?? opened.summary);
+        downstreamId = opened.response.result.loop?.id;
+    }
+    else if (record.action.tool === 'bclaw_coordinate') {
+        const coordinateCwd = options.cwd ?? process.cwd();
+        const coordinated = await handleBclawCoordinate(publicArgs, {
+            cwd: coordinateCwd,
+            connectionSessionId: options.sessionId,
+            // The persisted source loop is an explicit store selector. Preserve that
+            // provenance so a multi-project workspace cannot reinterpret this as a
+            // bare-cwd review and reject or misroute the downstream loop.
+            effectiveScope: {
+                cwd: coordinateCwd,
+                active_source: 'explicit',
+                resolved_project: { path: coordinateCwd },
+            },
+        });
+        if (coordinated.response.isError) {
+            const details = coordinated.response.structuredContent;
+            throw new Error(details?.error ?? details?.message ?? 'continuation_coordinate_failed');
+        }
+        const facade = coordinated.response.structuredContent;
+        if (facade?.status === 'error')
+            throw new Error(facade.error ?? 'continuation_coordinate_failed');
+        downstreamId = facade?.result?.loop_id;
+    }
+    else {
+        throw new Error(`continuation_action_unsupported: ${record.action.tool}`);
+    }
+    if (!downstreamId)
+        throw new Error('continuation_open_missing_loop');
+    if (process.env.BRAINCLAW_TEST_FAULT_CONTINUATION_AFTER_OPEN === '1') {
+        throw new Error('fault_injection: continuation_after_open');
+    }
+    return { kind: 'loop', id: downstreamId };
+}
 export async function handleBclawLoop(options) {
     const startMs = Date.now();
     const defaultActor = options.defaultActor ?? 'bclaw_loop';
@@ -592,6 +766,99 @@ export async function handleBclawLoop(options) {
                     next_expected: computeNextExpected(result.thread),
                 }, [loopArtifactEntry(result.thread.id), ...loopEventArtifacts(newEvents)], [sideEffectUpdate('loop', result.thread.id), ...loopEventSideEffects(newEvents)], [], Date.now() - startMs, summary);
             }
+            case 'continue': {
+                const source = getLoop(req.loop_id, options.cwd);
+                if (!source) {
+                    return errorResponse('continue', 'not_found', `unknown loop_id ${req.loop_id}`, Date.now() - startMs);
+                }
+                const actions = proposedPipelineActions(source, options.cwd);
+                const action = actions[req.action_index];
+                if (!action) {
+                    const diagnostic = continuationUnavailableDiagnostic(source, options.cwd);
+                    return errorResponse('continue', 'continuation_unavailable', `no executable continuation action ${req.action_index} for ${source.id}; inspect gate/blockers and execute the supplied recovery actions`, Date.now() - startMs, diagnostic.result, diagnostic.next_actions);
+                }
+                const sourceArtifactId = action.args?.linked?.source_artifact_id;
+                const sourceArtifact = source.artifacts.find((artifact) => artifact.artifact_id === sourceArtifactId);
+                if (!sourceArtifact) {
+                    return errorResponse('continue', 'continuation_source_missing', 'source continuation artifact disappeared', Date.now() - startMs);
+                }
+                const ensured = await ensureContinuation({
+                    source_loop: source,
+                    source_artifact: sourceArtifact,
+                    action,
+                    action_index: req.action_index,
+                    autonomy_mode: req.autonomy_mode,
+                    risk: req.risk,
+                    actor,
+                    actor_id: agentId,
+                    execute: (record) => executeContinuationPublicAction(record, {
+                        cwd: options.cwd, actor, agentId, sessionId: options.sessionId,
+                    }),
+                }, options.cwd);
+                let continuation = ensured.record;
+                if (continuation.state === 'approval_required') {
+                    let approval = continuation.action_required_id
+                        ? loadActionRequired(continuation.action_required_id, options.cwd)
+                        : undefined;
+                    if (!approval) {
+                        approval = createActionRequired({
+                            target: { kind: 'continuation', continuation_id: continuation.id },
+                            plan_id: source.linked?.plan_ids?.[0],
+                            sequence_id: source.linked?.sequence_ids?.[0],
+                            agent: actor,
+                            agent_id: agentId,
+                            session_id: options.sessionId,
+                            kind: 'plan_approval',
+                            scope: source.goal,
+                            title: `Approve continuation from ${source.id}`,
+                            prompt: continuation.reason.join('; '),
+                            tags: ['loop-engine', 'continuation', 'approval-required'],
+                        }, options.cwd);
+                        continuation = attachContinuationActionRequired(continuation.id, approval.id, actor, agentId, options.cwd);
+                    }
+                    const handled = successResponse('continue', { continuation, action_required: approval }, [{ type: 'continuation', id: continuation.id }, { type: 'action', id: approval.id }], [{ action: 'create', entity: 'action', id: approval.id }], [], Date.now() - startMs, `continuation ${continuation.id} requires approval ${approval.id}`);
+                    handled.response.next_actions = [{
+                            tool: 'bclaw_assignment_action',
+                            args: { action_id: approval.id, outcome: 'resolved' },
+                            when: 'a different trusted supervisor approves this continuation',
+                        }];
+                    return handled;
+                }
+                if (continuation.state === 'denied') {
+                    return successResponse('continue', { continuation }, [{ type: 'continuation', id: continuation.id }], [], [], Date.now() - startMs, `continuation ${continuation.id} denied: ${continuation.reason.join('; ')}`);
+                }
+                if (ensured.executing_elsewhere) {
+                    const handled = successResponse('continue', { continuation, executing_elsewhere: true }, [{ type: 'continuation', id: continuation.id }], [], [], Date.now() - startMs, `continuation ${continuation.id} is applying in another live process`);
+                    handled.response.next_actions = [{
+                            tool: 'bclaw_loop',
+                            args: { intent: 'continue', loop_id: source.id, action_index: req.action_index },
+                            when: 'retry after the current continuation owner settles',
+                        }];
+                    return handled;
+                }
+                const downstreamId = continuation.downstream?.id;
+                if (!downstreamId)
+                    throw new Error('continuation_applied_without_downstream');
+                let loop = getLoop(downstreamId, options.cwd);
+                if (!loop)
+                    throw new Error('continuation_downstream_disappeared');
+                let bind;
+                if (loop.kind === 'implementation') {
+                    const bound = await handleBclawLoop({
+                        args: { intent: 'bind', loop_id: downstreamId, agent: actor, agentId },
+                        cwd: options.cwd,
+                        defaultActor: actor,
+                        sessionId: options.sessionId,
+                    });
+                    if (bound.response.status !== 'ok')
+                        throw new Error(bound.response.error ?? bound.summary);
+                    bind = bound.response.result;
+                    loop = getLoop(downstreamId, options.cwd);
+                    if (!loop)
+                        throw new Error('continuation_downstream_disappeared');
+                }
+                return successResponse('continue', { loop, continuation, ...(bind ? { bind } : {}), reused: ensured.reused, next_expected: computeNextExpected(loop) }, [{ type: 'continuation', id: continuation.id }, loopArtifactEntry(loop.id)], [{ action: 'update', entity: 'continuation', id: continuation.id }, sideEffectUpdate('loop', loop.id)], [], Date.now() - startMs, `continuation ${continuation.id} applied to ${loop.id} phase=${loop.current_phase}`);
+            }
             case 'bind': {
                 // Implementation bind is engine-only: validate the linked sequence and
                 // advance bind -> execute. Worker launch belongs exclusively to

package/dist/commands/mcp-catalog.js

@@ -882,7 +882,7 @@ const MCP_WRITE_TOOLS = [
     },
     {
         name: 'bclaw_loop',
-        description: 'Loop engine facade: open/turn/complete_turn/takeover/advance/add_artifact/pause/resume/close/verify/request_input/provide_input/get/list multi-turn work loops (review, ideation, implementation, research, debug). Direct open requires allow_orphan=true because the caller owns subsequent dispatch. `takeover` fences one physical run and arms a fresh generation; it never changes protocol gates.',
+        description: 'Loop engine facade: open/turn/complete_turn/takeover/advance/add_artifact/pause/resume/close/verify/bind/continue/request_input/provide_input/get/list multi-turn work loops (review, ideation, implementation, research, debug). `continue` evaluates and persists a cross-loop continuation, then invokes the same public open or coordinate-review path; implementation downstreams additionally bind. Direct open requires allow_orphan=true because the caller owns subsequent dispatch.',
         // schemaSource is informational for now — grep target so future migrators
         // can locate zod-derived tools quickly. The parity test in
         // tests/unit/mcp-zod-parity.test.ts hard-codes its (tool, zod-schema)
@@ -900,8 +900,8 @@ const MCP_WRITE_TOOLS = [
             properties: {
                 intent: {
                     type: 'string',
-                    enum: ['open', 'get', 'list', 'turn', 'complete_turn', 'takeover', 'advance', 'add_artifact', 'pause', 'resume', 'close', 'verify', 'bind', 'request_input', 'provide_input'],
-                    description: 'Loop lifecycle intent. Review/ideation normally start via bclaw_coordinate; implementation/research/debug may use open with allow_orphan=true and then explicitly bind/turn/dispatch. `verify` runs the configured verification; request_input/provide_input are cross-kind clarification primitives.',
+                    enum: ['open', 'get', 'list', 'turn', 'complete_turn', 'takeover', 'advance', 'add_artifact', 'pause', 'resume', 'close', 'verify', 'bind', 'continue', 'request_input', 'provide_input'],
+                    description: 'Loop lifecycle intent. `continue` evaluates one next_action through persisted continuation policy and applies it through public open/bind semantics. Review/ideation normally start via bclaw_coordinate; implementation/research/debug may use open with allow_orphan=true and then explicitly bind/turn/dispatch.',
                 },
                 loop_id: { type: 'string', description: 'Target loop id (lop_…). Required for every intent except open and list.' },
                 kind: { type: 'string', enum: ['review', 'ideation', 'implementation', 'research', 'debug'], description: 'Loop kind for open / list filter.' },
@@ -944,6 +944,9 @@ const MCP_WRITE_TOOLS = [
                 model: { type: 'string', description: 'turn dispatch: model override. Deprecated and ignored for engine-only bind.' },
                 target_agents: { type: 'array', items: { type: 'string' }, description: 'turn dispatch: deterministic capability candidate pool used when the slot has no frozen agent.' },
                 max_assignments: { type: 'number', description: 'Deprecated bind launch option retained for compatibility and ignored.' },
+                action_index: { type: 'number', description: 'continue: zero-based proposed next_action index (default 0).' },
+                autonomy_mode: { type: 'string', enum: ['autonomous', 'require_approval', 'deny'], description: 'continue: policy mode. require_approval creates ActionRequired; deny persists a terminal denial.' },
+                risk: { type: 'string', enum: ['normal', 'protected'], description: 'continue: protected risk always requires approval.' },
                 to_phase: { type: 'string', description: 'advance: explicit target phase (otherwise the next phase).' },
                 force: { type: 'boolean', description: 'advance: allow going backwards (increments iteration_count).' },
                 reason: { type: 'string', description: 'advance / pause / close: optional reason string.' },

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

@@ -951,24 +951,71 @@ export async function handleBclawAssignmentAction(payload, ctx) {
         if (pendingAction && pendingAction.agent === resolved.identity.agent_name) {
             return { response: createToolErrorResponse('trust_error', `Agent '${resolved.identity.agent_name}' cannot resolve its own action. A supervisor or different agent must respond.`) };
         }
-        const action = resolveActionRequired(actionId, {
-            outcome: outcome,
-            text: typeof args.text === 'string' ? args.text : undefined,
-            payload: args.payload && typeof args.payload === 'object' ? args.payload : undefined,
-            responded_by: resolved.identity.agent_name,
-            responded_by_id: resolved.identity.agent_id,
-            session_id: connectionSessionId ?? 'unknown',
-        }, cwd);
+        const typedOutcome = outcome;
+        // Continuation approvals are safe to replay. This matters when the first
+        // response is lost after the downstream loop was created: the supervisor
+        // can submit the same decision again and observe the same continuation.
+        const continuationReplay = pendingAction?.target?.kind === 'continuation'
+            && pendingAction.status === typedOutcome;
+        const action = continuationReplay
+            ? pendingAction
+            : resolveActionRequired(actionId, {
+                outcome: typedOutcome,
+                text: typeof args.text === 'string' ? args.text : undefined,
+                payload: args.payload && typeof args.payload === 'object' ? args.payload : undefined,
+                responded_by: resolved.identity.agent_name,
+                responded_by_id: resolved.identity.agent_id,
+                session_id: connectionSessionId ?? 'unknown',
+            }, cwd);
+        let continuationResult;
+        if (action.target?.kind === 'continuation') {
+            const { denyContinuation, resumeApprovedContinuation } = await import('../core/loops/continuation.js');
+            if (outcome === 'resolved') {
+                const { executeContinuationPublicAction, handleBclawLoop } = await import('./loops-handlers.js');
+                const resumed = await resumeApprovedContinuation(action.target.continuation_id, action.id, resolved.identity.agent_name, resolved.identity.agent_id, (record) => executeContinuationPublicAction(record, {
+                    cwd,
+                    actor: resolved.identity.agent_name,
+                    agentId: resolved.identity.agent_id,
+                    sessionId: connectionSessionId,
+                }), cwd);
+                const downstreamId = resumed.record.downstream?.id;
+                let bind;
+                if (downstreamId) {
+                    const { getLoop } = await import('../core/loops/store.js');
+                    if (getLoop(downstreamId, cwd)?.kind === 'implementation') {
+                        const handled = await handleBclawLoop({
+                            args: {
+                                intent: 'bind', loop_id: downstreamId,
+                                agent: resolved.identity.agent_name, agentId: resolved.identity.agent_id,
+                            },
+                            cwd,
+                            defaultActor: resolved.identity.agent_name,
+                            sessionId: connectionSessionId,
+                        });
+                        if (handled.response.status !== 'ok')
+                            throw new Error(handled.response.error ?? handled.summary);
+                        bind = handled.response.result;
+                    }
+                }
+                continuationResult = { continuation: resumed.record, bind };
+            }
+            else {
+                const denied = denyContinuation(action.target.continuation_id, `approval ${action.id} ${outcome}`, resolved.identity.agent_name, resolved.identity.agent_id, cwd);
+                continuationResult = { continuation: denied };
+            }
+        }
         return {
             response: {
                 content: [{ type: 'text', text: `Action ${actionId} ${action.status}` }],
                 structuredContent: {
                     action_id: action.id,
                     assignment_id: action.assignment_id,
+                    target: action.target,
                     run_id: action.run_id,
                     status: action.status,
                     resolved_at: action.resolved_at,
                     response: action.response,
+                    ...(continuationResult ? { continuation_result: continuationResult } : {}),
                 },
             },
         };