brainclaw 1.27.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
@@ -16,6 +20,10 @@ function resolveActor(req, defaultActor) {
     return { actor, agentId };
 }
 function successResponse(intent, result, artifacts, side_effects, warnings, durationMs, summary) {
+    const resultLoop = result && typeof result === 'object' && 'loop' in result
+        ? result.loop
+        : undefined;
+    const nextActions = resultLoop ? pipelineNextActions(resultLoop) : [];
     return {
         response: {
             status: 'ok',
@@ -25,10 +33,114 @@ function successResponse(intent, result, artifacts, side_effects, warnings, dura
             side_effects,
             warnings,
             duration_ms: durationMs,
+            ...(nextActions.length > 0 ? { next_actions: nextActions } : {}),
         },
         summary,
     };
 }
+/** Cross-loop affordances: explicit next calls, never hidden orchestration. */
+function pipelineNextActions(loop) {
+    if (loop.kind === 'ideation') {
+        const draft = [...loop.artifacts].reverse().find((artifact) => artifact.type === 'plan_draft');
+        if (!draft || (loop.current_phase !== 'synthesis' && loop.status !== 'completed'))
+            return [];
+        const planIds = loop.linked?.plan_ids ?? [];
+        const sequenceIds = loop.linked?.sequence_ids ?? [];
+        if (planIds.length > 0 && sequenceIds.length > 0) {
+            return [{
+                    tool: 'bclaw_loop',
+                    args: {
+                        intent: 'continue', loop_id: loop.id, action_index: 0,
+                        autonomy_mode: 'autonomous', risk: 'normal',
+                    },
+                    when: 'evaluate and apply the accepted synthesis through persisted continuation policy',
+                }];
+        }
+        return [{
+                tool: 'bclaw_create',
+                args: { entity: 'plan', text: draft.body ?? '<materialize the plan_draft artifact>', status: 'todo' },
+                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, review_mode: 'asymmetric',
+                    task: `Review implementation loop ${loop.id}; handoff ${handoff.ref.kind}:${handoff.ref.id}`,
+                    targetAgents: [reviewer.agent],
+                    ...(reviewScope ? { scope: reviewScope } : {}),
+                    ...((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: `reviewer ${reviewer.agent} selected by ${reviewer.policy_version}`,
+            }];
+    }
+    return [];
+}
 function errorResponse(intent, code, message, durationMs, result = null) {
     return {
         response: {
@@ -182,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';
@@ -371,6 +536,7 @@ export async function handleBclawLoop(options) {
                                 body: req.artifact.body,
                                 ref: req.artifact.ref,
                                 addresses_critique: req.artifact.addresses_critique,
+                                implementation_verify: req.artifact.implementation_verify,
                             }
                             : undefined,
                         actor,
@@ -434,6 +600,7 @@ export async function handleBclawLoop(options) {
                             body: req.artifact.body,
                             ref: req.artifact.ref,
                             addresses_critique: req.artifact.addresses_critique,
+                            implementation_verify: req.artifact.implementation_verify,
                         },
                         actor,
                     }, options.cwd);
@@ -522,7 +689,7 @@ export async function handleBclawLoop(options) {
                     return errorResponse('verify', 'not_found', `unknown loop_id ${req.loop_id}`, Date.now() - startMs);
                 }
                 const beforeEvents = snapshotLoopEvents(req.loop_id, options.cwd);
-                const result = runVerify({ loop_id: req.loop_id, actor }, options.cwd);
+                const result = runVerify({ loop_id: req.loop_id, slot_id: req.slot_id, actor }, options.cwd);
                 const newEvents = findNewLoopEvents(result.thread.id, beforeEvents, options.cwd);
                 const summary = result.unconfigured
                     ? `verify: loop has no protocol.verify — falling back to an agent-narrated verify_report`
@@ -537,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

@@ -854,6 +854,16 @@ const MCP_WRITE_TOOLS = [
                 targetAgents: { type: 'array', items: { type: 'string' }, description: 'Agent names to target. If omitted, all spawnable agents are used.' },
                 constraints: { type: 'object', description: 'Optional structured constraints passed alongside the brief (e.g. deadline, reviewCriteria).' },
                 threadId: { type: 'string', description: 'Thread ID for summarize intent.' },
+                linked: {
+                    type: 'object',
+                    description: 'Optional pipeline provenance persisted on a review loop opened by this call.',
+                    properties: {
+                        plan_ids: { type: 'array', items: { type: 'string' } },
+                        sequence_ids: { type: 'array', items: { type: 'string' } },
+                        source_loop_id: { type: 'string', pattern: '^lop_[0-9a-z]+$' },
+                    },
+                    additionalProperties: false,
+                },
                 autoExecute: { type: 'boolean', description: 'Attempt to spawn target agents after delivery (default: true). Applies to the spawning intents assign/review/reroute AND to multi-agent ideate (with targetAgents, it spawns one worktree-isolated critic worker per target). consult is inbox-only and ignores autoExecute; summarize just reads a thread and ignores it. When false on a spawning intent, returns command_ready_manual with bash commands for the supervisor to run.' },
                 open_loop: { type: 'boolean', description: 'For intent=review only: also open a review Loop on top of the candidate (author + reviewer slots, advance to `findings`, dispatch turns). Default false — existing review callers are unaffected. See docs/concepts/loop-engine.md §Automation.' },
                 review_mode: { type: 'string', enum: ['asymmetric', 'symmetric'], description: 'Optional review Loop mode when open_loop=true. `asymmetric` (default) keeps the classical author→reviewer handoff; `symmetric` lets each reviewer turn also apply fixes directly, halving round-trips for spec/doc reviews. Ignored when open_loop is false.' },
@@ -872,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)
@@ -890,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.' },
@@ -934,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-schemas.generated.js

@@ -283,6 +283,26 @@ export const generatedSchemas = {
             "phase": {
                 "type": "string"
             },
+            "lane": {
+                "type": "string"
+            },
+            "scope_hint": {
+                "type": "string"
+            },
+            "plan_ids": {
+                "type": "array",
+                "items": {
+                    "type": "string",
+                    "minLength": 1
+                }
+            },
+            "step_ids": {
+                "type": "array",
+                "items": {
+                    "type": "string",
+                    "minLength": 1
+                }
+            },
             "status": {
                 "type": "string",
                 "enum": [

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/commands/mcp-write-coordination.js

@@ -1002,6 +1002,7 @@ export async function handleBclawCoordinate(args, ctx) {
                     created_by: creatorActor,
                     slots,
                     mode: req.review_mode ?? 'asymmetric',
+                    linked: req.linked,
                 }, dispatchCwd);
                 out.loopId = loop.id;
                 out.artifacts.push({ type: 'loop', id: loop.id });
@@ -1585,6 +1586,7 @@ export async function handleBclawCoordinate(args, ctx) {
                         goal: req.scope,
                         created_by: creatorActor,
                         slots,
+                        linked: req.linked,
                         ...(presetSelected
                             ? {
                                 phases: presetSelected.phases,
@@ -1677,6 +1679,7 @@ export async function handleBclawCoordinate(args, ctx) {
                                 category,
                                 text: r.text,
                                 score: r.score,
+                                relatedPaths: r.related_paths,
                             }));
                         },
                     };

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