brainclaw 1.28.0 → 1.28.1

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/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, } 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,24 +62,81 @@ 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 [];
@@ -235,6 +294,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 +704,98 @@ 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) {
+                    return errorResponse('continue', 'continuation_unavailable', `no executable continuation action ${req.action_index} for ${source.id}`, Date.now() - startMs);
+                }
+                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 } : {}),
                 },
             },
         };

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/loops/continuation.js

@@ -0,0 +1,337 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { z } from 'zod';
+import { NextActionSchema } from '../facade-schema.js';
+import { memoryDir, writeFileAtomic } from '../io.js';
+import { nowISO } from '../ids.js';
+import { mutate } from '../mutation-pipeline.js';
+import { appendAuditEntry } from '../audit.js';
+import { createRuntimeEvent } from '../events.js';
+import { artifactEvidenceDigest, validateArtifactEvidence } from './evidence.js';
+import { getLoop, listLoops } from './store.js';
+export const CONTINUATION_POLICY_VERSION = 'continuation-policy-v1';
+export const ContinuationDecisionSchema = z.enum(['auto', 'require_approval', 'deny']);
+export const ContinuationStateSchema = z.enum([
+    'proposed',
+    'approval_required',
+    'denied',
+    'applying',
+    'applied',
+    'failed_recoverable',
+]);
+const ContinuationOwnerSchema = z.object({
+    token: z.string().min(1),
+    pid: z.number().int().positive(),
+    host_id: z.string().min(1),
+    started_at: z.string(),
+});
+export const ContinuationRecordSchema = z.object({
+    schema_version: z.literal(1),
+    id: z.string().regex(/^ctn_[a-f0-9]{24}$/),
+    continuation_key: z.string().regex(/^[a-f0-9]{64}$/),
+    policy_version: z.literal(CONTINUATION_POLICY_VERSION),
+    source_loop_id: z.string().regex(/^lop_[0-9a-z]+$/),
+    source_iteration: z.number().int().nonnegative(),
+    source_artifact_id: z.string().regex(/^art_[0-9a-z]+$/),
+    source_artifact_digest: z.string().regex(/^[a-f0-9]{64}$/),
+    action_index: z.number().int().nonnegative(),
+    action_hash: z.string().regex(/^[a-f0-9]{64}$/),
+    action: NextActionSchema,
+    autonomy_mode: z.enum(['autonomous', 'require_approval', 'deny']),
+    risk: z.enum(['normal', 'protected']),
+    decision: ContinuationDecisionSchema,
+    reason: z.array(z.string().min(1)).min(1),
+    state: ContinuationStateSchema,
+    downstream: z.object({ kind: z.literal('loop'), id: z.string().regex(/^lop_[0-9a-z]+$/) }).optional(),
+    action_required_id: z.string().regex(/^act_[0-9a-z]+$/).optional(),
+    owner: ContinuationOwnerSchema.optional(),
+    last_error: z.string().optional(),
+    created_at: z.string(),
+    updated_at: z.string(),
+});
+function continuationsDir(cwd) {
+    return path.join(memoryDir(cwd ?? process.cwd()), 'loops', 'continuations');
+}
+function continuationPath(key, cwd) {
+    return path.join(continuationsDir(cwd), `${key}.json`);
+}
+function canonicalize(value) {
+    if (Array.isArray(value))
+        return value.map(canonicalize);
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value)
+            .filter(([, child]) => child !== undefined)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, child]) => [key, canonicalize(child)]));
+    }
+    return value;
+}
+function digest(value) {
+    return crypto.createHash('sha256').update(JSON.stringify(canonicalize(value))).digest('hex');
+}
+function writeRecord(record, cwd) {
+    const parsed = ContinuationRecordSchema.parse(record);
+    fs.mkdirSync(continuationsDir(cwd), { recursive: true });
+    writeFileAtomic(continuationPath(parsed.continuation_key, cwd), `${JSON.stringify(parsed, null, 2)}\n`);
+}
+export function loadContinuation(idOrKey, cwd) {
+    const dir = continuationsDir(cwd);
+    if (!fs.existsSync(dir))
+        return undefined;
+    if (/^[a-f0-9]{64}$/.test(idOrKey)) {
+        const file = continuationPath(idOrKey, cwd);
+        if (!fs.existsSync(file))
+            return undefined;
+        return ContinuationRecordSchema.parse(JSON.parse(fs.readFileSync(file, 'utf8')));
+    }
+    for (const name of fs.readdirSync(dir).filter((entry) => entry.endsWith('.json'))) {
+        const record = ContinuationRecordSchema.parse(JSON.parse(fs.readFileSync(path.join(dir, name), 'utf8')));
+        if (record.id === idOrKey)
+            return record;
+    }
+    return undefined;
+}
+export function listContinuations(cwd) {
+    const dir = continuationsDir(cwd);
+    if (!fs.existsSync(dir))
+        return [];
+    return fs.readdirSync(dir).filter((entry) => entry.endsWith('.json')).map((entry) => ContinuationRecordSchema.parse(JSON.parse(fs.readFileSync(path.join(dir, entry), 'utf8')))).sort((a, b) => a.created_at.localeCompare(b.created_at));
+}
+function findDownstream(key, cwd) {
+    const matches = listLoops({}, cwd).filter((loop) => loop.linked?.continuation_key === key);
+    if (matches.length > 1) {
+        throw new Error(`continuation_ambiguity: ${key} is linked to ${matches.length} downstream loops`);
+    }
+    return matches[0];
+}
+function containsPlaceholder(value) {
+    if (typeof value === 'string')
+        return /<[^>]+>/.test(value);
+    if (Array.isArray(value))
+        return value.some(containsPlaceholder);
+    return Boolean(value && typeof value === 'object' && Object.values(value).some(containsPlaceholder));
+}
+export function evaluateContinuation(input) {
+    const evidence = validateArtifactEvidence(input.source_loop, input.source_artifact);
+    if (!evidence.valid)
+        throw new Error(`continuation_source_unattested: ${evidence.reasons.join(',')}`);
+    if (containsPlaceholder(input.action))
+        throw new Error('continuation_action_placeholder: action is not executable');
+    const args = input.action.args ?? {};
+    const ideationToImplementation = input.source_loop.kind === 'ideation'
+        && input.source_artifact.type === 'plan_draft'
+        && Boolean(input.source_artifact.implementation_verify)
+        && input.action.tool === 'bclaw_loop'
+        && args.intent === 'open'
+        && args.kind === 'implementation';
+    const targets = Array.isArray(args.targetAgents) ? args.targetAgents : [];
+    const implementationToReview = input.source_loop.kind === 'implementation'
+        && input.source_artifact.type === 'handoff'
+        && Boolean(input.source_artifact.ref)
+        && input.action.tool === 'bclaw_coordinate'
+        && args.intent === 'review'
+        && args.open_loop === true
+        && targets.length === 1;
+    if (!ideationToImplementation && !implementationToReview) {
+        throw new Error('continuation_action_unsupported: expected Ideation→Implementation or Implementation→Review');
+    }
+    const sourceDigest = artifactEvidenceDigest(input.source_artifact);
+    const actionHash = digest(input.action);
+    const continuationKey = digest({
+        source_loop_id: input.source_loop.id,
+        source_iteration: input.source_artifact.iteration ?? input.source_loop.iteration_count,
+        source_artifact_digest: sourceDigest,
+        canonical_action_hash: actionHash,
+        policy_version: CONTINUATION_POLICY_VERSION,
+    });
+    const decision = input.autonomy_mode === 'deny'
+        ? 'deny'
+        : input.autonomy_mode === 'require_approval' || input.risk === 'protected'
+            ? 'require_approval'
+            : 'auto';
+    const evidenceReason = ideationToImplementation ? 'attested ideation plan_draft' : 'attested implementation handoff';
+    const actionReason = ideationToImplementation ? 'concrete implementation action' : 'concrete independent review action';
+    const reason = decision === 'auto'
+        ? [evidenceReason, actionReason, 'normal risk under autonomous mode']
+        : decision === 'require_approval'
+            ? [input.risk === 'protected' ? 'protected risk requires operator approval' : 'project autonomy mode requires approval']
+            : ['project autonomy mode denies continuation'];
+    return { continuation_key: continuationKey, source_artifact_digest: sourceDigest, action_hash: actionHash, decision, reason };
+}
+function ownerAlive(owner) {
+    if (owner.host_id !== os.hostname())
+        return true;
+    try {
+        process.kill(owner.pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+}
+function audit(record, before, actor, actorId, cwd) {
+    appendAuditEntry({
+        actor, actor_id: actorId, action: before ? 'update' : 'create', item_id: record.id,
+        item_type: 'state', before: before ? { state: before } : undefined,
+        after: { state: record.state, decision: record.decision, continuation_key: record.continuation_key, downstream: record.downstream },
+    }, cwd);
+    createRuntimeEvent({
+        agent: actor, agent_id: actorId, event_type: 'observation',
+        text: `Continuation ${record.decision}: ${record.source_loop_id} → ${record.downstream?.id ?? record.state}`,
+        tags: ['loop-engine', 'continuation', `decision:${record.decision}`, `state:${record.state}`],
+        metadata: { protocol: CONTINUATION_POLICY_VERSION, continuation_id: record.id, continuation_key: record.continuation_key },
+    }, cwd);
+}
+export async function ensureContinuation(input, cwd) {
+    const proposal = evaluateContinuation(input);
+    const prepared = mutate({ cwd }, () => {
+        const existing = loadContinuation(proposal.continuation_key, cwd);
+        if (existing && existing.action_hash !== proposal.action_hash) {
+            throw new Error(`continuation_key_conflict: stored=${existing.action_hash} submitted=${proposal.action_hash}`);
+        }
+        const downstream = findDownstream(proposal.continuation_key, cwd);
+        if (downstream) {
+            const next = existing
+                ? { ...existing, state: 'applied', downstream: { kind: 'loop', id: downstream.id }, owner: undefined, updated_at: nowISO() }
+                : undefined;
+            if (!next)
+                throw new Error('continuation_projection_missing: downstream exists without a continuation record');
+            writeRecord(next, cwd);
+            return { record: next, shouldExecute: false, reused: true };
+        }
+        if (existing?.state === 'applied' && existing.downstream)
+            return { record: existing, shouldExecute: false, reused: true };
+        if (existing?.state === 'denied' || existing?.state === 'approval_required') {
+            return { record: existing, shouldExecute: false, reused: true };
+        }
+        if (existing?.state === 'applying' && existing.owner && ownerAlive(existing.owner)) {
+            return { record: existing, shouldExecute: false, reused: true, executingElsewhere: true };
+        }
+        const now = nowISO();
+        const owner = { token: crypto.randomUUID(), pid: process.pid, host_id: os.hostname(), started_at: now };
+        const base = existing ?? {
+            schema_version: 1,
+            id: `ctn_${proposal.continuation_key.slice(0, 24)}`,
+            continuation_key: proposal.continuation_key,
+            policy_version: CONTINUATION_POLICY_VERSION,
+            source_loop_id: input.source_loop.id,
+            source_iteration: input.source_artifact.iteration ?? input.source_loop.iteration_count,
+            source_artifact_id: input.source_artifact.artifact_id,
+            source_artifact_digest: proposal.source_artifact_digest,
+            action_index: input.action_index,
+            action_hash: proposal.action_hash,
+            action: input.action,
+            autonomy_mode: input.autonomy_mode,
+            risk: input.risk,
+            decision: proposal.decision,
+            reason: proposal.reason,
+            state: 'proposed',
+            created_at: now,
+            updated_at: now,
+        };
+        const state = proposal.decision === 'deny' ? 'denied' : proposal.decision === 'require_approval' ? 'approval_required' : 'applying';
+        const record = {
+            ...base,
+            decision: proposal.decision,
+            reason: existing?.reason ?? proposal.reason,
+            state,
+            owner: state === 'applying' ? owner : undefined,
+            updated_at: now,
+        };
+        writeRecord(record, cwd);
+        audit(record, existing?.state, input.actor, input.actor_id, cwd);
+        return { record, shouldExecute: state === 'applying', reused: Boolean(existing) };
+    });
+    if (!prepared.shouldExecute) {
+        return { record: prepared.record, reused: prepared.reused, executing_elsewhere: prepared.executingElsewhere };
+    }
+    try {
+        const downstream = await input.execute(prepared.record);
+        const committed = mutate({ cwd }, () => {
+            const current = loadContinuation(prepared.record.continuation_key, cwd);
+            if (!current)
+                throw new Error('continuation_record_disappeared');
+            if (current.owner?.token !== prepared.record.owner?.token)
+                throw new Error('continuation_owner_fenced');
+            const record = { ...current, state: 'applied', downstream, owner: undefined, updated_at: nowISO() };
+            writeRecord(record, cwd);
+            audit(record, current.state, input.actor, input.actor_id, cwd);
+            return record;
+        });
+        return { record: committed, reused: prepared.reused };
+    }
+    catch (error) {
+        mutate({ cwd }, () => {
+            const current = loadContinuation(prepared.record.continuation_key, cwd);
+            if (!current || current.owner?.token !== prepared.record.owner?.token)
+                return;
+            const record = { ...current, state: 'failed_recoverable', owner: undefined, last_error: error instanceof Error ? error.message : String(error), updated_at: nowISO() };
+            writeRecord(record, cwd);
+            audit(record, current.state, input.actor, input.actor_id, cwd);
+        });
+        throw error;
+    }
+}
+export function attachContinuationActionRequired(continuationId, actionId, actor, actorId, cwd) {
+    return mutate({ cwd }, () => {
+        const current = loadContinuation(continuationId, cwd);
+        if (!current)
+            throw new Error(`unknown continuation ${continuationId}`);
+        if (current.state !== 'approval_required')
+            throw new Error(`continuation ${continuationId} is ${current.state}, not approval_required`);
+        if (current.action_required_id && current.action_required_id !== actionId)
+            throw new Error('continuation_action_required_conflict');
+        const record = { ...current, action_required_id: actionId, updated_at: nowISO() };
+        writeRecord(record, cwd);
+        audit(record, current.state, actor, actorId, cwd);
+        return record;
+    });
+}
+export function denyContinuation(continuationId, reason, actor, actorId, cwd) {
+    return mutate({ cwd }, () => {
+        const current = loadContinuation(continuationId, cwd);
+        if (!current)
+            throw new Error(`unknown continuation ${continuationId}`);
+        if (current.state === 'applied')
+            throw new Error(`continuation ${continuationId} is already applied`);
+        if (current.state === 'denied')
+            return current;
+        const record = {
+            ...current,
+            decision: 'deny',
+            state: 'denied',
+            owner: undefined,
+            reason: [...current.reason, reason],
+            updated_at: nowISO(),
+        };
+        writeRecord(record, cwd);
+        audit(record, current.state, actor, actorId, cwd);
+        return record;
+    });
+}
+export async function resumeApprovedContinuation(continuationId, actionId, actor, actorId, execute, cwd) {
+    const record = loadContinuation(continuationId, cwd);
+    if (!record)
+        throw new Error(`unknown continuation ${continuationId}`);
+    if (record.action_required_id !== actionId)
+        throw new Error('continuation_approval_mismatch');
+    const source = getLoop(record.source_loop_id, cwd);
+    const artifact = source?.artifacts.find((item) => item.artifact_id === record.source_artifact_id);
+    if (!source || !artifact)
+        throw new Error('continuation_source_missing');
+    mutate({ cwd }, () => {
+        const fresh = loadContinuation(continuationId, cwd);
+        if (fresh.state === 'applied')
+            return;
+        if (fresh.state !== 'approval_required' && fresh.state !== 'failed_recoverable')
+            throw new Error(`continuation ${continuationId} is ${fresh.state}`);
+        writeRecord({ ...fresh, state: 'failed_recoverable', autonomy_mode: 'autonomous', decision: 'auto', reason: [...fresh.reason, `approved by ${actor}`], updated_at: nowISO() }, cwd);
+    });
+    return ensureContinuation({
+        source_loop: source, source_artifact: artifact, action: record.action, action_index: record.action_index,
+        autonomy_mode: 'autonomous', risk: 'normal', actor, actor_id: actorId, execute,
+    }, cwd);
+}
+//# sourceMappingURL=continuation.js.map

package/dist/core/loops/facade-schema.js

@@ -234,6 +234,19 @@ export const BclawLoopBindSchema = z.object({
     // No expected_version: bind is idempotent by loop phase (past `bind` → noop), not CAS.
     ...CallerEnvelopeFields,
 });
+/**
+ * Evaluate and apply one persisted cross-loop continuation. This is an
+ * orchestration intent: the downstream mutation still traverses the public
+ * `open` and `bind` handlers, never a private Loop-store shortcut.
+ */
+export const BclawLoopContinueSchema = z.object({
+    intent: z.literal('continue'),
+    loop_id: z.string().regex(/^lop_[0-9a-z]+$/),
+    action_index: z.number().int().nonnegative().default(0),
+    autonomy_mode: z.enum(['autonomous', 'require_approval', 'deny']).default('autonomous'),
+    risk: z.enum(['normal', 'protected']).default('normal'),
+    ...CallerEnvelopeFields,
+});
 /**
  * pln#508 step 2 — `bclaw_loop(intent='request_input')`.
  *
@@ -306,6 +319,7 @@ export const BclawLoopRequestSchema = z.discriminatedUnion('intent', [
     BclawLoopCloseSchema,
     BclawLoopVerifySchema,
     BclawLoopBindSchema,
+    BclawLoopContinueSchema,
     BclawLoopRequestInputSchema,
     BclawLoopProvideInputSchema,
 ]);
@@ -323,6 +337,7 @@ export const BCLAW_LOOP_INTENTS = [
     'close',
     'verify',
     'bind',
+    'continue',
     'request_input',
     'provide_input',
 ];

package/dist/core/loops/index.js

@@ -21,4 +21,5 @@ export { deriveWorkerReplyContract, renderWorkerReplyProse, workerReplyNextActio
 export { abortAttempt, inspectAttempt, matchEvidence, prepareAttempt, projectAndCross, revokeAttempt, } from './attempt-authority.js';
 export { LOOP_KIND_POLICIES, assertLoopKindPoliciesComplete, isWorkerPhase, phasePolicy, policyForKind, } from './kind-policies.js';
 export { ensureTurnExecutionProjections, prepareTurnExecution, } from './turn-execution.js';
+export { CONTINUATION_POLICY_VERSION, ContinuationDecisionSchema, ContinuationRecordSchema, ContinuationStateSchema, attachContinuationActionRequired, denyContinuation, ensureContinuation, evaluateContinuation, listContinuations, loadContinuation, resumeApprovedContinuation, } from './continuation.js';
 //# sourceMappingURL=index.js.map

package/dist/core/loops/types.js

@@ -25,6 +25,12 @@ export const LoopLinksSchema = z.object({
     sequence_ids: z.array(z.string().min(1)).optional(),
     /** Upstream loop in an ideation → implementation → review pipeline. */
     source_loop_id: z.string().regex(/^lop_[0-9a-z]+$/).optional(),
+    /** Exact upstream artifact that authorized this continuation. */
+    source_artifact_id: z.string().regex(/^art_[0-9a-z]+$/).optional(),
+    /** Sealed digest of source_artifact_id at continuation evaluation time. */
+    source_artifact_digest: z.string().regex(/^[a-f0-9]{64}$/).optional(),
+    /** Durable, deterministic identity of the policy decision that created this loop. */
+    continuation_key: z.string().regex(/^[a-f0-9]{64}$/).optional(),
 });
 /**
  * Memory categories a loop phase can request via `context_filter` (pln#492).

package/dist/core/reviewer-policy.js

@@ -0,0 +1,39 @@
+import { listAgentIdentities } from './agent-registry.js';
+import { resolveExecutionCandidate } from './execution-contract.js';
+export const REVIEWER_SELECTION_POLICY_VERSION = 'reviewer-selection-v1';
+/**
+ * Select a concrete review worker from project-registered identities.
+ *
+ * The shared execution-contract resolver supplies capability checks and stable
+ * ordering. The policy additionally enforces reviewer independence by
+ * excluding every identity frozen onto an implementation slot.
+ */
+export function selectImplementationReviewer(source, cwd) {
+    if (source.kind !== 'implementation') {
+        throw new Error(`reviewer_selection_source_invalid: loop ${source.id} is ${source.kind}`);
+    }
+    const excludedImplementers = source.slots
+        .filter((slot) => Boolean(slot.agent))
+        .map((slot) => ({ agent: slot.agent, ...(slot.agent_id ? { agent_id: slot.agent_id } : {}) }));
+    const excludedNames = new Set(excludedImplementers.map((identity) => identity.agent.normalize('NFC')));
+    const excludedIds = new Set(excludedImplementers.flatMap((identity) => identity.agent_id ? [identity.agent_id.normalize('NFC')] : []));
+    const identities = listAgentIdentities(cwd)
+        .filter((identity) => identity.kind !== 'human')
+        .filter((identity) => !excludedNames.has(identity.agent_name.normalize('NFC')) && !excludedIds.has(identity.agent_id.normalize('NFC')))
+        .map((identity) => ({ agent: identity.agent_name, agent_id: identity.agent_id }));
+    const resolution = resolveExecutionCandidate(identities, { roles: ['review'], required_surfaces: ['cli_spawn'], execution_surfaces: [], required_tools: [] });
+    if (resolution.kind !== 'selected') {
+        const reasons = resolution.evaluated
+            .map((candidate) => `${candidate.agent}:${candidate.snapshot.reasons.map((reason) => reason.code).join('+') || 'excluded'}`)
+            .join(', ');
+        throw new Error(`continuation_reviewer_unavailable: no independent spawnable reviewer${reasons ? ` (${reasons})` : ''}`);
+    }
+    return {
+        policy_version: REVIEWER_SELECTION_POLICY_VERSION,
+        agent: resolution.selected.agent,
+        agent_id: resolution.selected.agent_id,
+        evaluated: resolution.evaluated,
+        excluded_implementers: excludedImplementers,
+    };
+}
+//# sourceMappingURL=reviewer-policy.js.map

package/dist/core/schema.js

@@ -923,11 +923,18 @@ export const ActionRequiredResponseSchema = z.object({
     responded_by_id: z.string().optional(),
     responded_at: z.string(),
 });
+export const ActionRequiredTargetSchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('assignment'), assignment_id: z.string() }),
+    z.object({ kind: z.literal('continuation'), continuation_id: z.string().regex(/^ctn_[a-f0-9]{24}$/) }),
+]);
 export const ActionRequiredSchema = z.object({
     schema_version: z.number().int().positive().optional(),
     id: z.string(),
     short_label: z.string().optional(),
-    assignment_id: z.string(),
+    /** Legacy top-level assignment link; retained for v1 records. */
+    assignment_id: z.string().optional(),
+    /** Discriminated approval target. New records always persist this field. */
+    target: ActionRequiredTargetSchema.optional(),
     run_id: z.string().optional(),
     claim_id: z.string().optional(),
     message_id: z.string().optional(),
@@ -949,6 +956,14 @@ export const ActionRequiredSchema = z.object({
     resolved_at: z.string().optional(),
     response: ActionRequiredResponseSchema.optional(),
     tags: TagsWithDefaultSchema,
+}).superRefine((action, ctx) => {
+    const target = action.target ?? (action.assignment_id ? { kind: 'assignment', assignment_id: action.assignment_id } : undefined);
+    if (!target) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['target'], message: 'ActionRequired requires an assignment or continuation target' });
+    }
+    if (target?.kind === 'assignment' && action.assignment_id && target.assignment_id !== action.assignment_id) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['target'], message: 'assignment target must match assignment_id' });
+    }
 });
 // --- Runtime notes schemas ---
 export const RuntimeNoteTypeSchema = z.enum(['observation', 'session_start', 'session_end']);

package/dist/facts.js

@@ -1,8 +1,8 @@
 // Generated by scripts/emit-site-facts.mjs at build time. Do not edit manually.
-// Source: brainclaw v1.28.0 on 2026-08-24T07:09:07.814Z
+// Source: brainclaw v1.28.1 on 2026-08-24T17:40:07.204Z
 export const FACTS = {
-  "version": "1.28.0",
-  "generated_at": "2026-08-24T07:09:07.814Z",
+  "version": "1.28.1",
+  "generated_at": "2026-08-24T17:40:07.204Z",
   "tools": {
     "count": 70,
     "published_count": 68,
@@ -478,7 +478,7 @@ export const FACTS = {
   },
   "bench": {
     "schema": "brainclaw.bench.v1",
-    "generated_at": "2026-08-24T07:09:05.728Z",
+    "generated_at": "2026-08-24T17:40:05.036Z",
     "node_version": "v24.19.0",
     "platform": "linux-x64",
     "repeats": 3,
@@ -487,7 +487,7 @@ export const FACTS = {
         "name": "cold_onboard",
         "volume": "empty",
         "description": "fresh machine → init → first useful context. Baseline for time-to-first-value.",
-        "duration_ms_median": 81,
+        "duration_ms_median": 85,
         "payload_chars_median": 1640,
         "payload_tokens_est_median": 410
       },
@@ -495,7 +495,7 @@ export const FACTS = {
         "name": "warm_work",
         "volume": "medium",
         "description": "bclaw_work consult over a real-shaped store (~200 plans / 500 handoffs / 450 claims).",
-        "duration_ms_median": 120,
+        "duration_ms_median": 128,
         "payload_chars_median": 2626,
         "payload_tokens_est_median": 657
       },
@@ -503,7 +503,7 @@ export const FACTS = {
         "name": "first_edit",
         "volume": "medium",
         "description": "code_find + code_brief on the fresh-agent path (missing index, first touch).",
-        "duration_ms_median": 13,
+        "duration_ms_median": 11,
         "payload_chars_median": 1305,
         "payload_tokens_est_median": 326
       }

package/dist/facts.json

@@ -1,6 +1,6 @@
 {
-  "version": "1.28.0",
-  "generated_at": "2026-08-24T07:09:07.814Z",
+  "version": "1.28.1",
+  "generated_at": "2026-08-24T17:40:07.204Z",
   "tools": {
     "count": 70,
     "published_count": 68,
@@ -476,7 +476,7 @@
   },
   "bench": {
     "schema": "brainclaw.bench.v1",
-    "generated_at": "2026-08-24T07:09:05.728Z",
+    "generated_at": "2026-08-24T17:40:05.036Z",
     "node_version": "v24.19.0",
     "platform": "linux-x64",
     "repeats": 3,
@@ -485,7 +485,7 @@
         "name": "cold_onboard",
         "volume": "empty",
         "description": "fresh machine → init → first useful context. Baseline for time-to-first-value.",
-        "duration_ms_median": 81,
+        "duration_ms_median": 85,
         "payload_chars_median": 1640,
         "payload_tokens_est_median": 410
       },
@@ -493,7 +493,7 @@
         "name": "warm_work",
         "volume": "medium",
         "description": "bclaw_work consult over a real-shaped store (~200 plans / 500 handoffs / 450 claims).",
-        "duration_ms_median": 120,
+        "duration_ms_median": 128,
         "payload_chars_median": 2626,
         "payload_tokens_est_median": 657
       },
@@ -501,7 +501,7 @@
         "name": "first_edit",
         "volume": "medium",
         "description": "code_find + code_brief on the fresh-agent path (missing index, first touch).",
-        "duration_ms_median": 13,
+        "duration_ms_median": 11,
         "payload_chars_median": 1305,
         "payload_tokens_est_median": 326
       }

package/docs/cli.md

@@ -1016,9 +1016,11 @@ research, and debug; they are not a review-only command group.
 | `takeover <loop_id>` | slot, turn, expected epoch, cause, liveness evidence, external-effect policy, next workspace and coordinator identity | Fence one physical generation and arm a successor without changing the logical Assignment. |
 | `advance <loop_id>` | — | Advance through the protocol; optional `--to-phase`, `--force`, `--reason`. |
 | `add-artifact <loop_id>` | `--phase --type --body` | Attach a typed artifact; optional producer and ref. |
+| `continue <loop_id>` | — | Evaluate an attested Ideation→Implementation or Implementation→Review action and persist/apply `AUTO`, `REQUIRE_APPROVAL`, or `DENY`; options: `--action-index`, `--autonomy-mode`, `--risk`. Review continuation selects an independent registered reviewer and fails closed if none is available. |
 
 ```bash
 brainclaw loop advance lop_abc --json
+brainclaw loop continue lop_abc --autonomy-mode autonomous --risk normal --json
 brainclaw loop takeover lop_abc \
   --slot lsl_abc --turn-id tat_abc --expected-epoch 0 \
   --cause "worker is no longer live" \
@@ -1028,7 +1030,7 @@ brainclaw loop takeover lop_abc \
 ```
 
 The full public lifecycle (`open`, `get`, `list`, `pause`, `resume`, `close`,
-`bind`, `verify`, `request_input`, `provide_input`, and the verbs above) is the
+`bind`, `verify`, `continue`, `request_input`, `provide_input`, and the verbs above) is the
 MCP `bclaw_loop(intent)` facade. Direct MCP `open` requires
 `allow_orphan=true`; review and ideation normally start through
 `bclaw_coordinate` so opening and dispatch stay one operation. See the
@@ -2032,7 +2034,7 @@ The default catalog is intentionally small and centred on the canonical grammar.
 |---|---|
 | `bclaw_coordinate(intent)` | Assign, consult, review, reroute, or summarize across agents. Pass `open_loop: true` on `intent="review"` to also dispatch the reviewer turn. |
 | `bclaw_dispatch(intent)` | Parallelize execute across a sequence's lanes (analysis / execute / review). |
-| `bclaw_loop(intent)` | Open, inspect, or drive a multi-turn loop. The public lifecycle is `open`, `get`, `list`, `turn`, `complete_turn`, `advance`, `add_artifact`, `pause`, `resume`, and `close`; implementation loops also add engine-only `bind` (validate the linked sequence and enter `execute`, never spawn) and `verify`, and any kind may use `request_input` / `provide_input`. Trusted `turn(dispatch=true)` is the common worker launch path. `bclaw_coordinate` / `bclaw_dispatch` remain ergonomic shortcuts. A direct `open` must include `allow_orphan: true` to acknowledge that the caller will dispatch or drive it. |
+| `bclaw_loop(intent)` | Open, inspect, or drive a multi-turn loop. `continue` persists and applies policy-governed cross-loop progression through the public mutation path. Implementation loops add engine-only `bind` and `verify`; any kind may use `request_input` / `provide_input`. Trusted `turn(dispatch=true)` remains the only worker launch path. A direct `open` must include `allow_orphan: true`. |
 
 **Sequences**:
 

package/docs/concepts/loop-engine.md

@@ -363,6 +363,7 @@ Additional shared and engine-owned actions complete the lifecycle:
 - **request_input** / **provide_input** — bounded, evidence-backed operator clarification usable by any protocol.
 - **bind** — implementation-loop engine action that validates the linked sequence and advances to `execute`; it never launches a worker.
 - **verify** — implementation/debug engine action that runs the opener-configured command outside the loop lock, then records a verification-attested report.
+- **continue** — orchestration action above the Loop engine. It evaluates an attested `next_action`, persists `AUTO | REQUIRE_APPROVAL | DENY`, and applies supported actions through the same public `open`/`bind` handlers.
 
 Artifact authority is sealed at these verb boundaries. `produced_by` is
 derived from the authenticated slot/engine/coordinator context. A narrative
@@ -396,6 +397,7 @@ type BclawLoopInput = BclawLoopCallerEnvelope & (
   | { intent: 'close';         loop_id: LoopId; status: 'completed' | 'cancelled' | 'blocked'; reason?: string; expected_version?: number }
   | { intent: 'verify';        loop_id: LoopId }
   | { intent: 'bind';          loop_id: LoopId; dry_run?: boolean; lanes?: string[]; auto_execute?: boolean; model?: string; max_assignments?: number }
+  | { intent: 'continue';      loop_id: LoopId; action_index?: number; autonomy_mode?: 'autonomous' | 'require_approval' | 'deny'; risk?: 'normal' | 'protected' }
   | { intent: 'request_input'; loop_id: LoopId; slot_id: SlotId; phase: string; question_text: string; evidence: string[]; suggested_default?: string; options?: OperatorQuestionOption[]; pause_scope: 'slot' | 'loop'; on_timeout: 'use_default' | 'cancel_loop' | 'continue_incomplete'; timeout_at?: string; expected_version?: number }
   | { intent: 'provide_input'; loop_id: LoopId; replies_to: string; resolved_via: 'answer' | 'choose' | 'skip' | 'timeout_default'; answer_text?: string; chosen_option_id?: string; by?: 'operator' | 'system'; expected_version?: number }
   | { intent: 'get';           loop_id: LoopId; include_events?: boolean }
@@ -470,6 +472,29 @@ The shared lifecycle verbs are `turn`, `complete_turn`, `advance`,
 use engine-only `bind` to validate their linked sequence and enter `execute`,
 then `turn(dispatch:true)` for worker slots; `verify` runs their declared command.
 
+### Persisted continuation authority
+
+An accepted ideation synthesis and an attested implementation handoff no
+longer expose ungoverned downstream mutations. Their `next_actions` point to
+`bclaw_loop(intent="continue")`. The
+continuation record binds the source loop, iteration, sealed artifact digest,
+canonical action hash and policy version into a deterministic key. It is
+written before the downstream mutation.
+
+For Ideation→Implementation, `AUTO` invokes the ordinary public `open` handler
+with that key in `linked.continuation_key`, then invokes engine-only `bind`.
+For Implementation→Review, it deterministically selects a project-registered,
+spawnable review-capable identity that did not occupy an implementation slot,
+then invokes the ordinary public `bclaw_coordinate(intent="review",
+open_loop=true)` path. If no independent reviewer exists, it fails closed.
+A retry first scans existing loops for the key, so a crash after either public
+mutation but before the response reuses the same loop. A live concurrent owner
+is observed rather than stolen.
+`REQUIRE_APPROVAL` creates an `ActionRequired` whose discriminated target is
+the continuation; approval resumes the same record, while rejection or expiry
+persists `DENY`. Unsupported actions, placeholders, missing evidence and
+ambiguous downstreams fail closed.
+
 ### Clarification is a cross-cutting primitive
 
 Clarification is deliberately not a sixth protocol. Any workflow can call

package/docs/mcp-schema-changelog.md

@@ -408,7 +408,12 @@ will still succeed. A follow-up PR will strip the dead handler code.
   changelog records the published MCP surface fingerprint. When a tool
   name, tier, category, or input schema changes, the test fails until
   this section is updated.
-- MCP public surface fingerprint: `sha256:681c47cba85b79c3`
+- MCP public surface fingerprint: `sha256:be86e5571fcd0226`
+  (updated 2026-08-24 for persisted continuation authority: additive
+  `bclaw_loop(intent="continue")` inputs `action_index`, `autonomy_mode`, and
+  `risk`; the intent evaluates an attested Ideation→Implementation action,
+  persists AUTO/REQUIRE_APPROVAL/DENY, and reuses the public open/bind path.)
+  Previous: `sha256:681c47cba85b79c3`
   (`LoopSlotInput` gains optional `lane`, `scope_hint`, `plan_ids`, and
   `step_ids` fields so implementation-loop lane scope and provenance survive
   through the public facade. Existing callers remain valid.)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brainclaw",
-  "version": "1.28.0",
+  "version": "1.28.1",
   "description": "Shared project memory for humans and coding agents.",
   "type": "module",
   "repository": {