brainclaw 1.27.0 → 1.28.0

package/dist/commands/loops-handlers.js

@@ -16,6 +16,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 +29,59 @@ 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: '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,
+                    },
+                    when: 'start implementation from the accepted synthesis',
+                }];
+        }
+        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 === 'handoff_ready' || loop.status === 'completed')) {
+        const handoff = [...loop.artifacts].reverse().find((artifact) => artifact.type === 'handoff');
+        const reviewScope = [...new Set(loop.slots.map((slot) => slot.scope_hint?.trim()).filter((scope) => Boolean(scope)))].join(',');
+        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>'],
+                    ...(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 },
+                },
+                when: 'implementation evidence is handoff-ready',
+            }];
+    }
+    return [];
+}
 function errorResponse(intent, code, message, durationMs, result = null) {
     return {
         response: {
@@ -371,6 +424,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 +488,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 +577,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`

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

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-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/execution-adapters.js

@@ -178,6 +178,33 @@ function buildManualEnvPrefix(claimId) {
     // wrapper for symmetry with the dispatcher's buildEnvPrefix.
     return buildClaimEnvPrefix(claimId);
 }
+/**
+ * Make the isolated worktree the explicit Codex workspace root. Relying only
+ * on child_process.cwd is insufficient for non-interactive Windows launches:
+ * the Codex sandbox can retain the coordinator workspace and apply_patch then
+ * refuses writes in ~/.brainclaw/worktrees even when NTFS grants access.
+ * `--cd` defines the primary root. Do not redundantly add the same path with
+ * `--add-dir`: the unelevated Windows sandbox cannot enforce split writable
+ * root sets and refuses to prepare its wrapper in that configuration.
+ */
+export function withCodexWorkspaceRoot(invoke, agent, worktreePath, isWin32 = process.platform === 'win32') {
+    const executableName = path.win32.basename(invoke.executable).replace(/\.(?:cmd|exe|bat|com)$/i, '').toLowerCase();
+    if (agent.trim().toLowerCase() !== 'codex' || executableName !== 'codex' || !worktreePath)
+        return invoke;
+    const args = [...invoke.args];
+    const subcommandIndex = args.indexOf('exec');
+    const insertAt = subcommandIndex >= 0 ? subcommandIndex : 0;
+    args.splice(insertAt, 0, '--cd', worktreePath);
+    const quote = (value) => isWin32
+        ? `"${value.replace(/"/g, '""')}"`
+        : `'${value.replace(/'/g, `'\\''`)}'`;
+    const flags = `--cd ${quote(worktreePath)}`;
+    const prefix = invoke.executable;
+    const suffix = invoke.bashCommand.startsWith(`${prefix} `)
+        ? invoke.bashCommand.slice(prefix.length + 1)
+        : invoke.bashCommand;
+    return { ...invoke, args, bashCommand: `${prefix} ${flags} ${suffix}` };
+}
 export class CliExecutionAdapter {
     id = 'cli';
     canSpawn(agentName) {
@@ -198,6 +225,7 @@ export class CliExecutionAdapter {
     }
     prepareManualCommand(invoke, options) {
         const isWin32 = process.platform === 'win32';
+        invoke = withCodexWorkspaceRoot(invoke, options.agent, options.worktreePath, isWin32);
         const shell = isWin32 ? 'cmd' : (invoke.shell ? 'bash' : 'sh');
         if (options.turnEcho?.contract_hash
             && options.turnEcho.capability_snapshot_hash
@@ -246,6 +274,7 @@ export class CliExecutionAdapter {
     }
     start(invoke, options) {
         const isWin32 = process.platform === 'win32';
+        invoke = withCodexWorkspaceRoot(invoke, options.agent, options.worktreePath, isWin32);
         // F7 (trp_0e5150d3): route worker env through buildWorkerIdentityEnv so the
         // worker is an independent agent — coordinator identity (BRAINCLAW_AGENT*,
         // SESSION_ID, PROJECT) is scrubbed LAST and cannot be reintroduced by

package/dist/core/facade-schema.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { LoopLinksSchema } from './loops/types.js';
 export const ExecutionStatusSchema = z.enum(['delivered_and_started', 'command_ready_manual', 'inbox_only']);
 export const WorkIntentSchema = z.enum(['execute', 'consult', 'resume', 'review']);
 // pln#626 — coordinate intents split into three honest contracts:
@@ -37,6 +38,8 @@ export const CoordinateRequestSchema = z.object({
     targetAgents: z.array(z.string()).optional(),
     constraints: z.record(z.string(), z.unknown()).optional(),
     threadId: z.string().optional(),
+    /** Optional pipeline provenance persisted when open_loop creates a loop. */
+    linked: LoopLinksSchema.optional(),
     autoExecute: z.boolean().optional(),
     /**
      * When intent=review and open_loop=true, a review Loop is opened on top of

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

@@ -12,10 +12,12 @@ import { transitionAgentRun } from './agentruns.js';
 import { loadAssignment, patchAssignmentMessageId, transitionAssignment } from './assignments.js';
 import { attachAssignmentMessageToClaim, createCoordinatorClaim, ensureClaimAssignmentBinding, } from './claims.js';
 import { generateDispatchBrief } from './dispatcher.js';
+import { search } from './search.js';
 import { attemptExecution } from './execution.js';
 import { resolveExecutionCandidate } from './execution-contract.js';
 import { buildHarnessInvocation, resolveHarnessBinding } from './harness-adapters/index.js';
 import { phasePolicy } from './loops/kind-policies.js';
+import { buildIdeationBrief } from './loops/brief-assembly.js';
 import { getLoop } from './loops/store.js';
 import { prepareTurnExecution } from './loops/turn-execution.js';
 import { sendMessage } from './messaging.js';
@@ -60,7 +62,33 @@ export async function dispatchLoopTurn(input) {
         agentId = selection.selected.agent_id;
         result.agent = agent;
     }
-    const scope = `loop:${loop.kind}:${loop.id}:slot:${slot.slot_id}`;
+    const scope = slot.scope_hint ?? `loop:${loop.kind}:${loop.id}:slot:${slot.slot_id}`;
+    const sectionByCategory = {
+        traps: 'traps', decisions: 'decisions', constraints: 'constraints', handoffs: 'handoffs',
+        plans: 'plans', candidates: 'candidates',
+    };
+    const provider = {
+        fetch(category, query, topK) {
+            const section = sectionByCategory[category];
+            if (!section)
+                return [];
+            return search({ query, section, maxResults: topK, cwd: input.cwd, includePending: section === 'candidates' })
+                .map((item) => ({
+                id: item.id, category, text: item.text, score: item.score, relatedPaths: item.related_paths,
+            }));
+        },
+    };
+    const phaseBrief = buildIdeationBrief({
+        thread: loop,
+        slotRole: slot.role,
+        memoryProvider: provider,
+        seedText: input.task,
+        scopeHints: slot.scope_hint ? slot.scope_hint.split(',').map((value) => value.trim()) : [],
+    });
+    const laneContext = slot.lane
+        ? `Lane: ${slot.lane}\nPlans: ${(slot.plan_ids ?? []).join(', ') || '(none)'}\nSteps: ${(slot.step_ids ?? []).join(', ') || '(whole plan)'}`
+        : '';
+    const scopedTask = [phaseBrief.text, laneContext].filter(Boolean).join('\n\n');
     const description = `${loop.kind} loop turn for ${loop.id} slot ${slot.slot_id} phase ${loop.current_phase}. ${input.task}`;
     try {
         const claim = createCoordinatorClaim({
@@ -92,7 +120,7 @@ export async function dispatchLoopTurn(input) {
             dispatcher_session_id: input.session_id,
             scope,
             description,
-            task: input.task,
+            task: scopedTask,
             cwd: input.cwd,
             worktree_path: claim.worktreePath,
             model,
@@ -121,7 +149,7 @@ export async function dispatchLoopTurn(input) {
             ...(prepared.workspace_digest ? { workspace_digest: prepared.workspace_digest } : {}),
         };
         const brief = generateDispatchBrief({
-            task: input.task,
+            task: scopedTask,
             agent,
             claimId: claim.claimId,
             scope,

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

@@ -199,6 +199,26 @@ export function executionContractForGeneration(reservation, generation) {
     if (!reservation.execution_contract || !reservation.capability_snapshot) {
         throw new AttemptGenerationError('invalid_transition', `turn ${reservation.turn_id} has no immutable execution contract`);
     }
+    // Generation zero anchors the already-crossed immutable reservation. Keep
+    // its original serialized contract: on Windows the generation cell stores a
+    // canonicalized (case-folded) workspace path, and rebuilding the contract
+    // from that path changes its hash even though it names the same checkout.
+    // Successor generations still derive a new contract below because their
+    // epoch, run id, and workspace are intentionally different.
+    if (generation.attempt_epoch === 0) {
+        const contract = reservation.execution_contract;
+        if (contract.identity.assignment_id !== generation.assignment_id
+            || contract.identity.run_id !== generation.run_id
+            || canonicalWorkspacePath(contract.workspace_policy.worktree_path ?? contract.workspace_policy.cwd)
+                !== canonicalWorkspacePath(generation.workspace_path)) {
+            throw new AttemptGenerationError('fenced', 'generation zero diverges from its immutable reservation contract');
+        }
+        const ref = executionContractRef(contract, reservation.capability_snapshot);
+        if (ref.hash !== generation.contract_hash) {
+            throw new AttemptGenerationError('fenced', `generation zero contract hash ${generation.contract_hash} does not match reservation ${ref.hash}`);
+        }
+        return { contract, ref };
+    }
     const contract = ExecutionContractSchema.parse({
         ...reservation.execution_contract,
         identity: {

package/dist/core/loops/brief-assembly.js

@@ -45,9 +45,9 @@ const LOOP_INTERNAL_CATEGORIES = new Set([
     'synthesis_artifact',
 ]);
 export function buildIdeationBrief(input) {
-    const { thread, slotRole, memoryProvider, maxChars = DEFAULT_MAX_CHARS, topKPerCategory = DEFAULT_TOP_K_PER_CATEGORY, } = input;
+    const { thread, slotRole, memoryProvider, maxChars = DEFAULT_MAX_CHARS, topKPerCategory = DEFAULT_TOP_K_PER_CATEGORY, seedText, scopeHints = [], } = input;
     const proposal = findProposalArtifact(thread);
-    const proposalText = proposal?.body?.trim() ?? '(no proposal seed found)';
+    const proposalText = seedText?.trim() || proposal?.body?.trim() || '(no proposal seed found)';
     // Resolve which memory categories the current phase wants. If the
     // current phase has no context_filter, fall back to '*' (full bundle).
     const currentPhaseDef = thread.phases.find((p) => p.name === thread.current_phase);
@@ -57,7 +57,7 @@ export function buildIdeationBrief(input) {
     const fetchedItemsByCategory = new Map();
     const categoriesUsed = [];
     for (const category of userFacingCategories) {
-        const items = memoryProvider.fetch(category, proposalText, topKPerCategory);
+        const items = scopeMemoryItems(memoryProvider.fetch(category, `${proposalText} ${scopeHints.join(' ')}`.trim(), topKPerCategory), scopeHints);
         if (items.length > 0) {
             fetchedItemsByCategory.set(category, items);
             categoriesUsed.push(category);
@@ -116,7 +116,7 @@ function expandUserFacingCategories(requested) {
 }
 function renderHeader(thread, slotRole, phase) {
     const lines = [
-        `# ideation_loop brief`,
+        `# ${thread.kind}_loop brief`,
         `loop: ${thread.id}`,
         `phase: ${phase}`,
         `iteration: ${thread.iteration_count}`,
@@ -127,6 +127,23 @@ function renderHeader(thread, slotRole, phase) {
         lines.push(`goal: ${thread.goal}`);
     return lines.join('\n');
 }
+function normalizeScope(value) {
+    return value.replace(/\\/g, '/').replace(/^\.\//, '').toLowerCase();
+}
+/** Keep project-wide memories and memories whose related_paths overlap this lane. */
+function scopeMemoryItems(items, scopeHints) {
+    const scopes = scopeHints.map(normalizeScope).filter(Boolean);
+    if (scopes.length === 0)
+        return items;
+    return items.filter((item) => {
+        if (!item.relatedPaths || item.relatedPaths.length === 0)
+            return true;
+        return item.relatedPaths.some((related) => {
+            const path = normalizeScope(related);
+            return scopes.some((scope) => path.startsWith(scope) || scope.startsWith(path));
+        });
+    });
+}
 function renderProposalBlock(proposalText) {
     return `## proposal\n\n${proposalText}`;
 }

package/dist/core/loops/evidence.js

@@ -24,6 +24,7 @@ export function artifactEvidenceDigest(artifact) {
         produced_by: artifact.produced_by,
         produced_at: artifact.produced_at,
         addresses_critique: artifact.addresses_critique,
+        implementation_verify: artifact.implementation_verify,
         iteration: artifact.iteration ?? 0,
     });
 }

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

@@ -102,6 +102,21 @@ export const BclawLoopCompleteTurnSchema = z.object({
         ref: LoopRefSchema.optional(),
         /** pln#492 synthesis audit trail. Required when type === 'plan_draft'. */
         addresses_critique: z.array(z.string().min(1)).optional(),
+        implementation_verify: z
+            .object({
+            command: z.array(z.string().min(1)).min(1),
+            timeout_ms: z.number().int().positive().optional(),
+        })
+            .optional(),
+    })
+        .superRefine((artifact, ctx) => {
+        if (artifact.type === 'plan_draft' && !artifact.implementation_verify) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "plan_draft requires implementation_verify for deterministic downstream verification",
+                path: ['implementation_verify'],
+            });
+        }
     })
         .optional(),
     expected_version: z.number().int().nonnegative().optional(),
@@ -132,13 +147,29 @@ export const BclawLoopAdvanceSchema = z.object({
 export const BclawLoopAddArtifactSchema = z.object({
     intent: z.literal('add_artifact'),
     loop_id: z.string().regex(/^lop_[0-9a-z]+$/),
-    artifact: z.object({
+    artifact: z
+        .object({
         phase: z.string().min(1),
         type: z.string().min(1),
         body: z.string().optional(),
         ref: LoopRefSchema.optional(),
         /** pln#492 synthesis audit trail. Required when type === 'plan_draft'. */
         addresses_critique: z.array(z.string().min(1)).optional(),
+        implementation_verify: z
+            .object({
+            command: z.array(z.string().min(1)).min(1),
+            timeout_ms: z.number().int().positive().optional(),
+        })
+            .optional(),
+    })
+        .superRefine((artifact, ctx) => {
+        if (artifact.type === 'plan_draft' && !artifact.implementation_verify) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "plan_draft requires implementation_verify for deterministic downstream verification",
+                path: ['implementation_verify'],
+            });
+        }
     }),
     expected_version: z.number().int().nonnegative().optional(),
     ...CallerEnvelopeFields,
@@ -173,6 +204,8 @@ export const BclawLoopCloseSchema = z.object({
 export const BclawLoopVerifySchema = z.object({
     intent: z.literal('verify'),
     loop_id: z.string().regex(/^lop_[0-9a-z]+$/),
+    /** Required when an implementation loop has more than one bound lane. */
+    slot_id: z.string().regex(/^lsl_[0-9a-z]+$/).optional(),
     // No expected_version: runVerify is idempotent by (loop, iteration) via its own
     // two-lock re-check, not optimistic-concurrency CAS (review F3).
     ...CallerEnvelopeFields,

package/dist/core/loops/gate-policy.js

@@ -93,11 +93,14 @@ function hasUsableContent(artifact) {
     return (artifact.body ?? '').trim().length > 0 || artifact.ref !== undefined;
 }
 function legacyEligibleCount(thread, artifacts, purpose, cwd) {
+    return legacyEligibleArtifacts(thread, artifacts, purpose, cwd).length;
+}
+function legacyEligibleArtifacts(thread, artifacts, purpose, cwd) {
     // Kind-specialized purposes stay fail-closed even for persisted legacy
     // loops. Legacy relaxes envelope presence; it does not invent an authority
     // that the kind's policy explicitly forbids.
     if (GATE_POLICIES[thread.kind].requirements[purpose].authorities.length === 0)
-        return 0;
+        return [];
     return artifacts.filter((artifact) => {
         if (purpose !== 'critic_signal' && !hasUsableContent(artifact))
             return false;
@@ -105,7 +108,7 @@ function legacyEligibleCount(thread, artifacts, purpose, cwd) {
             return true;
         return validateArtifactEvidence(thread, artifact).valid
             && reconciledV2AuthorityRejection(thread, artifact, cwd) === undefined;
-    }).length;
+    });
 }
 function payloadFingerprint(artifact) {
     return evidenceDigest({
@@ -425,7 +428,24 @@ export function evaluateGateCondition(thread, condition, cwd) {
         case 'min_artifacts_by_type': {
             const candidates = artifactCandidates(thread, condition);
             const set = selectEligible(thread, candidates, 'artifact', cwd);
-            return decision(thread, condition, set.eligible.length >= condition.n, legacyEligibleCount(thread, candidates, 'artifact', cwd) >= condition.n, set);
+            const requiredLanes = thread.kind === 'implementation' && condition.type === 'verify_report'
+                ? [...new Set(thread.slots.map((slot) => slot.lane).filter((lane) => Boolean(lane)))]
+                : [];
+            const covers = (artifacts) => {
+                if (requiredLanes.length === 0)
+                    return artifacts.length >= condition.n;
+                const reported = new Set(artifacts.flatMap((artifact) => {
+                    try {
+                        const lane = JSON.parse(artifact.body ?? '{}').lane;
+                        return lane ? [lane] : [];
+                    }
+                    catch {
+                        return [];
+                    }
+                }));
+                return requiredLanes.every((lane) => reported.has(lane));
+            };
+            return decision(thread, condition, covers(set.eligible), covers(legacyEligibleArtifacts(thread, candidates, 'artifact', cwd)), set);
         }
         case 'any': {
             const children = condition.conditions.map((child) => evaluateGateCondition(thread, child, cwd));
@@ -460,7 +480,35 @@ export function evaluateCommandGreen(thread, iteration, cwd) {
         }
     });
     const set = selectEligible(thread, candidates, 'command_green', cwd);
-    return decision(thread, { kind: 'command_green', iteration }, set.eligible.length > 0, legacyEligibleCount(thread, candidates, 'command_green', cwd) > 0, set);
+    const requiredLanes = thread.kind === 'implementation'
+        ? [...new Set(thread.slots.map((slot) => slot.lane).filter((lane) => Boolean(lane)))]
+        : [];
+    const greenLanes = new Set(set.eligible.flatMap((artifact) => {
+        try {
+            const lane = JSON.parse(artifact.body ?? '{}').lane;
+            return lane ? [lane] : [];
+        }
+        catch {
+            return [];
+        }
+    }));
+    const allLanesGreen = requiredLanes.length === 0
+        ? set.eligible.length > 0
+        : requiredLanes.every((lane) => greenLanes.has(lane));
+    const legacyCandidates = legacyEligibleArtifacts(thread, candidates, 'command_green', cwd);
+    const legacyGreenLanes = new Set(legacyCandidates.flatMap((artifact) => {
+        try {
+            const lane = JSON.parse(artifact.body ?? '{}').lane;
+            return lane ? [lane] : [];
+        }
+        catch {
+            return [];
+        }
+    }));
+    const legacyAllLanesGreen = requiredLanes.length === 0
+        ? legacyCandidates.length > 0
+        : requiredLanes.every((lane) => legacyGreenLanes.has(lane));
+    return decision(thread, { kind: 'command_green', iteration }, allLanesGreen, legacyAllLanesGreen, set);
 }
 export function evaluateCriticSignal(thread, iteration, cwd) {
     const candidates = thread.artifacts.filter((artifact) => artifact.type === 'critic_signal' && (artifact.iteration ?? 0) === iteration);

package/dist/core/loops/impl-bind.js

@@ -1,7 +1,53 @@
-import { listSequences } from '../sequence.js';
+import { loadSequence } from '../sequence.js';
+import { loadState } from '../state.js';
 import { withLoopLock } from './lock.js';
 import { getLoop } from './store.js';
 import { advance } from './verbs.js';
+function deriveBindings(loop, sequenceId, cwd) {
+    if (!loop)
+        throw new Error('implementation loop disappeared during bind');
+    const sequence = loadSequence(sequenceId, cwd);
+    if (sequence.items.length === 0)
+        throw new Error(`linked sequence ${sequenceId} has no items`);
+    const linkedPlans = new Set(loop.linked?.plan_ids ?? []);
+    if (linkedPlans.size === 0) {
+        throw new Error(`impl-bind requires linked.plan_ids in addition to linked.sequence_ids`);
+    }
+    const plans = new Map(loadState(cwd).plan_items.map((plan) => [plan.id, plan]));
+    for (const item of sequence.items) {
+        if (!linkedPlans.has(item.planId)) {
+            throw new Error(`sequence item rank ${item.rank} references unlinked plan ${item.planId}`);
+        }
+        const plan = plans.get(item.planId);
+        if (!plan)
+            throw new Error(`linked sequence ${sequenceId} references missing plan ${item.planId}`);
+        if (item.stepId && !(plan.steps ?? []).some((step) => step.id === item.stepId)) {
+            throw new Error(`sequence item rank ${item.rank} references missing step ${item.stepId} on plan ${item.planId}`);
+        }
+    }
+    const grouped = new Map();
+    for (const item of sequence.items) {
+        const lane = item.lane?.trim() || 'default';
+        grouped.set(lane, [...(grouped.get(lane) ?? []), item]);
+    }
+    const lanes = [...grouped.keys()].sort();
+    if (loop.slots.length !== lanes.length) {
+        throw new Error(`impl-bind lane/slot mismatch: sequence ${sequenceId} has ${lanes.length} lane(s) (${lanes.join(', ')}) but loop has ${loop.slots.length} slot(s); open one worker slot per lane`);
+    }
+    const bindings = {};
+    loop.slots.forEach((slot, index) => {
+        const lane = lanes[index];
+        const items = grouped.get(lane);
+        const scopes = [...new Set(items.map((item) => item.scope_hint?.trim()).filter((value) => Boolean(value)))];
+        bindings[slot.slot_id] = {
+            lane,
+            scope_hint: scopes.length > 0 ? scopes.join(', ') : undefined,
+            plan_ids: [...new Set(items.map((item) => item.planId))],
+            step_ids: [...new Set(items.flatMap((item) => item.stepId ? [item.stepId] : []))],
+        };
+    });
+    return bindings;
+}
 const ENGINE_ONLY_WARNING = 'implementation bind is engine-only and does not dispatch workers; use bclaw_loop(intent="turn", dispatch=true, slot_id=...) in execute';
 function compatibilityWarnings(input) {
     const usedLaunchOption = input.lanes !== undefined
@@ -44,8 +90,12 @@ export async function runImplBind(input, cwd) {
     if (!sequenceId) {
         throw new Error(`impl-bind requires a linked sequence: open the implementation loop with linked.sequence_ids=[...] (the sequence whose lanes it executes). None found on ${loop_id}.`);
     }
-    if (!listSequences(cwd).some((sequence) => sequence.id === sequenceId)) {
-        throw new Error(`linked sequence ${sequenceId} not found for loop ${loop_id}`);
+    let bindings;
+    try {
+        bindings = deriveBindings(loop, sequenceId, cwd);
+    }
+    catch (error) {
+        throw new Error(`impl-bind validation failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
     if (input.dryRun) {
         return {
@@ -56,6 +106,7 @@ export async function runImplBind(input, cwd) {
             messages_sent: 0,
             warnings: compatibilityWarnings(input),
             reason: `dry run: linked sequence ${sequenceId} is valid; loop stays in 'bind' and no worker is dispatched`,
+            lanes: Object.entries(bindings).map(([slot_id, binding]) => ({ slot_id, lane: binding.lane, scope_hint: binding.scope_hint })),
         };
     }
     const advanced = withLoopLock({
@@ -68,11 +119,11 @@ export async function runImplBind(input, cwd) {
             if (!fresh || fresh.status !== 'open' || fresh.current_phase !== 'bind')
                 return null;
             const freshSequenceId = fresh.linked?.sequence_ids?.[0];
-            if (freshSequenceId !== sequenceId
-                || !listSequences(cwd).some((sequence) => sequence.id === sequenceId)) {
+            if (freshSequenceId !== sequenceId) {
                 throw new Error(`linked sequence ${sequenceId} changed or disappeared before bind could advance`);
             }
-            const result = advance({ id: loop_id, actor: dispatcherAgent }, cwd);
+            const freshBindings = deriveBindings(fresh, sequenceId, cwd);
+            const result = advance({ id: loop_id, actor: dispatcherAgent, slot_bindings: freshBindings }, cwd);
             return { phase: result.loop.current_phase, auto_closed: result.auto_closed };
         },
     });
@@ -97,6 +148,7 @@ export async function runImplBind(input, cwd) {
         messages_sent: 0,
         warnings: compatibilityWarnings(input),
         reason: `validated linked sequence ${sequenceId}; advanced bind -> ${advanced.phase}; dispatch worker slots with turn(dispatch=true)`,
+        lanes: Object.entries(bindings).map(([slot_id, binding]) => ({ slot_id, lane: binding.lane, scope_hint: binding.scope_hint })),
     };
 }
 //# sourceMappingURL=impl-bind.js.map

package/dist/core/loops/reconcile-turn.js

@@ -385,6 +385,7 @@ function convergeLockedTurn(reservation, input, actor, cwd) {
                             body: a.body,
                             produced_by: a.produced_by,
                             addresses_critique: a.addresses_critique,
+                            implementation_verify: a.implementation_verify,
                         },
                     }, cwd);
                 }
@@ -418,6 +419,7 @@ function convergeLockedTurn(reservation, input, actor, cwd) {
                         type: primary.type,
                         body: primary.body,
                         addresses_critique: primary.addresses_critique,
+                        implementation_verify: primary.implementation_verify,
                     },
                 } : {}),
             }, cwd);

package/dist/core/loops/result-reducers.js

@@ -85,8 +85,22 @@ export const ideationReducer = (input, attempt) => {
             if (uniqueAddresses.length === 0) {
                 return { artifacts: [], slot_outcome: 'failed', failure_reason: 'ideation synthesis must cite critique artifact ids in lane.artifacts' };
             }
+            if (!lane.implementation_verify) {
+                return {
+                    artifacts: [],
+                    slot_outcome: 'failed',
+                    failure_reason: 'ideation synthesis must declare implementation_verify for deterministic downstream verification',
+                };
+            }
             return {
-                artifacts: [{ phase, type: artifactType, body: capBody(body), produced_by: attempt.agent, addresses_critique: uniqueAddresses }],
+                artifacts: [{
+                        phase,
+                        type: artifactType,
+                        body: capBody(body),
+                        produced_by: attempt.agent,
+                        addresses_critique: uniqueAddresses,
+                        implementation_verify: lane.implementation_verify,
+                    }],
                 slot_outcome: 'done',
             };
         }

package/dist/core/loops/store.js

@@ -71,6 +71,10 @@ function buildSlot(partial) {
         assignment_id: partial.assignment_id,
         claim_id: partial.claim_id,
         phase: partial.phase,
+        lane: partial.lane,
+        scope_hint: partial.scope_hint,
+        plan_ids: partial.plan_ids,
+        step_ids: partial.step_ids,
         status: partial.status ?? 'open',
     };
 }

package/dist/core/loops/types.js

@@ -15,7 +15,7 @@ export const REVIEW_MODES = ['asymmetric', 'symmetric'];
  */
 export const SLOT_STATUSES = ['open', 'assigned', 'working', 'waiting_input', 'done', 'failed', 'cancelled'];
 export const TERMINAL_SLOT_STATUSES = ['done', 'failed', 'cancelled'];
-export const LOOP_REF_KINDS = ['plan', 'sequence', 'claim', 'handoff', 'candidate', 'message'];
+export const LOOP_REF_KINDS = ['plan', 'sequence', 'claim', 'handoff', 'candidate', 'message', 'commit', 'branch'];
 export const LoopRefSchema = z.object({
     kind: z.enum(LOOP_REF_KINDS),
     id: z.string().min(1),
@@ -23,6 +23,8 @@ export const LoopRefSchema = z.object({
 export const LoopLinksSchema = z.object({
     plan_ids: z.array(z.string().min(1)).optional(),
     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(),
 });
 /**
  * Memory categories a loop phase can request via `context_filter` (pln#492).
@@ -155,6 +157,13 @@ export const LoopSlotSchema = z.object({
     assignment_id: z.string().optional(),
     claim_id: z.string().optional(),
     phase: z.string().optional(),
+    /** Implementation-loop lane bound from the linked sequence at bind time. */
+    lane: z.string().optional(),
+    /** File/path scope carried by the bound sequence lane. */
+    scope_hint: z.string().optional(),
+    /** Plans and steps executed by this lane (derived, never worker-authored). */
+    plan_ids: z.array(z.string().min(1)).optional(),
+    step_ids: z.array(z.string().min(1)).optional(),
     status: z.enum(SLOT_STATUSES),
     /**
      * pln#630 PR2b-a (§13 R1) — pointer to the immutable turn-attempt record for
@@ -418,6 +427,8 @@ export const VerifyReportBodySchema = z.object({
     command_digest: z.string().regex(/^[0-9a-f]{64}$/).optional(),
     workspace_digest: z.string().regex(/^[0-9a-f]{64}$/).optional(),
     workspace_stable: z.boolean().optional(),
+    /** Implementation lane whose worktree was verified. */
+    lane: z.string().optional(),
 });
 export const KNOWN_ARTIFACT_BODY_SCHEMAS = {
     // inline JSON body: body = JSON.stringify({ ...fields per OperatorQuestionBodySchema })
@@ -457,6 +468,8 @@ export const LoopArtifactSchema = z
      * critique artifact) is deferred to v1.1 per the plan.
      */
     addresses_critique: z.array(z.string().min(1)).optional(),
+    /** Executable acceptance command carried from synthesis into implementation. */
+    implementation_verify: LoopVerifyConfigSchema.optional(),
     /**
      * pln#492 phase 2.b — iteration window the artifact was produced in.
      * 0-indexed (proposal/early phases produce iteration=0). Optional for

package/dist/core/loops/verbs.js

@@ -283,6 +283,9 @@ export function advance(input, cwd) {
         mutation_id,
         current_phase: to_phase,
         iteration_count,
+        slots: input.slot_bindings
+            ? current.slots.map((slot) => ({ ...slot, ...(input.slot_bindings?.[slot.slot_id] ?? {}) }))
+            : current.slots,
         updated_at: now,
     };
     // pln#492 phase 2.b — when the iteration engine forces the cycle out

package/dist/core/loops/verify-command.js

@@ -24,6 +24,7 @@
  */
 import { spawnSync } from 'node:child_process';
 import path from 'node:path';
+import { loadAssignment } from '../assignments.js';
 import { getLoop } from './store.js';
 import { withLoopLock } from './lock.js';
 import { addArtifactWithEvidence } from './verbs.js';
@@ -31,6 +32,8 @@ import { artifactsInIteration } from './iteration-engine.js';
 import { evidenceDigest } from './evidence.js';
 import { eligibleArtifactsForPurpose } from './gate-policy.js';
 import { captureWorkspaceDigest } from './workspace-digest.js';
+import { findReservationByAssignmentId } from './attempt-reservation.js';
+import { resolveTurnGenerationChain } from './attempt-generations.js';
 import { VERIFY_DEFAULT_TIMEOUT_MS, LOOP_ARTIFACT_BODY_MAX_BYTES, } from './types.js';
 /** VerifyReportBodySchema caps stdout_tail/stderr_tail at 1024. */
 const TAIL_MAX = 1024;
@@ -51,7 +54,15 @@ export const defaultVerifyRunner = (config) => {
             delete env[k];
     }
     const started = Date.now();
-    const r = spawnSync(config.command[0], config.command.slice(1), {
+    const requestedExecutable = config.command[0];
+    const npmCli = process.platform === 'win32' && (requestedExecutable === 'npm' || requestedExecutable === 'npx')
+        ? path.join(path.dirname(process.execPath), 'node_modules', 'npm', 'bin', `${requestedExecutable}-cli.js`)
+        : undefined;
+    // Node cannot spawn .cmd shims with shell:false on Windows. Invoke npm's JS
+    // entrypoint through the current Node binary so the no-shell security contract holds.
+    const executable = npmCli ? process.execPath : requestedExecutable;
+    const commandArgs = npmCli ? [npmCli, ...config.command.slice(1)] : config.command.slice(1);
+    const r = spawnSync(executable, commandArgs, {
         cwd: config.cwd,
         env,
         shell: false,
@@ -79,19 +90,52 @@ export const defaultVerifyRunner = (config) => {
     };
 };
 /**
- * Resolve the verify command for a loop. PR1: the loop-PROJECT cwd only (the
- * lane-worktree cwd for a sequenced impl loop is a follow-up). Returns `unconfigured`
- * when the loop opted out (no `protocol.verify`).
+ * Resolve the verify command for a loop. Bound implementation lanes run only
+ * in their assignment worktree; legacy/unbound loops retain the project cwd.
+ * Returns `unconfigured` when the loop opted out (no `protocol.verify`).
  */
-export function resolveVerifyCommand(thread, cwd) {
+function assignmentWorktree(assignmentId, cwd) {
+    const assignment = loadAssignment(assignmentId, cwd);
+    const reservation = findReservationByAssignmentId(assignmentId, cwd);
+    const generation = reservation
+        ? resolveTurnGenerationChain(cwd ?? reservation.store_root, reservation.turn_id)?.latest_generation
+        : undefined;
+    return generation?.workspace_path ?? assignment?.worktree_path;
+}
+export function resolveVerifyCommand(thread, cwd, slotId) {
     const cfg = thread.protocol?.verify;
     if (!cfg)
         return { kind: 'unconfigured' };
+    let verifyCwd = path.resolve(cwd ?? process.cwd());
+    if (thread.kind === 'implementation') {
+        const selected = slotId ? thread.slots.find((slot) => slot.slot_id === slotId) : undefined;
+        if (slotId && !selected)
+            throw new Error(`verify: slot ${slotId} not found on loop ${thread.id}`);
+        const candidates = (selected ? [selected] : thread.slots)
+            .filter((slot) => slot.assignment_id)
+            .map((slot) => ({ slot, worktree_path: assignmentWorktree(slot.assignment_id, cwd) }))
+            .filter((entry) => entry.worktree_path);
+        if (!selected && candidates.length > 1) {
+            throw new Error(`verify: implementation loop ${thread.id} has multiple bound worktrees; pass slot_id to verify one lane deterministically`);
+        }
+        if (!selected && thread.slots.some((slot) => slot.lane) && candidates.length === 0) {
+            throw new Error(`verify: implementation loop ${thread.id} has bound lanes but no assignment worktree; dispatch and settle the execute turn first`);
+        }
+        if (selected?.lane && !selected.assignment_id) {
+            throw new Error(`verify: slot ${selected.slot_id} is bound to lane ${selected.lane} but has no assignment worktree; dispatch and settle the execute turn first`);
+        }
+        const candidate = candidates[0];
+        if (selected?.assignment_id && !candidate?.worktree_path) {
+            throw new Error(`verify: slot ${selected.slot_id} assignment ${selected.assignment_id} has no worktree_path`);
+        }
+        if (candidate?.worktree_path)
+            verifyCwd = path.resolve(candidate.worktree_path);
+    }
     return {
         kind: 'ok',
         config: {
             command: cfg.command,
-            cwd: path.resolve(cwd ?? process.cwd()),
+            cwd: verifyCwd,
             timeout_ms: cfg.timeout_ms ?? VERIFY_DEFAULT_TIMEOUT_MS,
         },
     };
@@ -133,8 +177,19 @@ export function buildVerifyReportBody(config, result, bindings) {
     });
 }
 /** True when an authoritative, still-fresh engine report exists for this iteration. */
-function hasVerifyReportForIteration(thread, iteration) {
-    const reports = artifactsInIteration(thread, iteration).filter((artifact) => artifact.type === 'verify_report');
+function hasVerifyReportForIteration(thread, iteration, lane) {
+    const reports = artifactsInIteration(thread, iteration).filter((artifact) => {
+        if (artifact.type !== 'verify_report')
+            return false;
+        if (!lane)
+            return true;
+        try {
+            return JSON.parse(artifact.body ?? '{}').lane === lane;
+        }
+        catch {
+            return false;
+        }
+    });
     return eligibleArtifactsForPurpose(thread, reports, 'command_green').eligible.length > 0;
 }
 /**
@@ -158,16 +213,23 @@ export function runVerify(input, cwd) {
             const thread = getLoop(input.loop_id, cwd);
             if (!thread)
                 throw new Error(`loop ${input.loop_id} not found`);
-            const resolved = resolveVerifyCommand(thread, cwd);
+            const inferredSlots = thread.kind === 'implementation' && !input.slot_id
+                ? thread.slots.filter((slot) => slot.assignment_id && assignmentWorktree(slot.assignment_id, cwd))
+                : [];
+            const selectedSlot = input.slot_id
+                ? thread.slots.find((slot) => slot.slot_id === input.slot_id)
+                : inferredSlots.length === 1 ? inferredSlots[0] : undefined;
+            const lane = selectedSlot?.lane;
+            const resolved = resolveVerifyCommand(thread, cwd, selectedSlot?.slot_id ?? input.slot_id);
             if (resolved.kind === 'unconfigured')
                 return { state: 'unconfigured', thread };
             const iteration = thread.iteration_count;
-            if (hasVerifyReportForIteration(thread, iteration))
+            if (hasVerifyReportForIteration(thread, iteration, lane))
                 return { state: 'deduped', thread };
             // Snapshot the iteration + phase we are about to verify. The command tests THIS
             // iteration's working tree; the report must be attributed to it even if a
             // concurrent advance bumps the loop's iteration while we spawn (review F1).
-            return { state: 'run', thread, config: resolved.config, iteration, phase: thread.current_phase };
+            return { state: 'run', thread, config: resolved.config, iteration, phase: thread.current_phase, lane };
         },
     });
     if (snapshot.state === 'unconfigured')
@@ -175,13 +237,13 @@ export function runVerify(input, cwd) {
     if (snapshot.state === 'deduped')
         return { thread: snapshot.thread, deduped: true };
     // --- OUT OF LOCK: run the command (may take minutes). ---
-    const { config, iteration, phase } = snapshot;
+    const { config, iteration, phase, lane } = snapshot;
     const command_digest = evidenceDigest({ command: config.command });
     const workspaceBefore = captureWorkspaceDigest(config.cwd);
     const runResult = runner(config);
     const workspaceAfter = captureWorkspaceDigest(config.cwd);
     const workspace_stable = workspaceBefore === workspaceAfter;
-    const reportAfterRun = buildVerifyReportBody(config, { ...runResult, passed: runResult.passed && workspace_stable }, { command_digest, workspace_digest: workspaceAfter, workspace_stable });
+    const reportAfterRun = buildVerifyReportBody(config, { ...runResult, passed: runResult.passed && workspace_stable }, { command_digest, workspace_digest: workspaceAfter, workspace_stable, lane });
     // --- Lock scope 2: re-check idempotency (by SNAPSHOT iteration), then append. ---
     return withLoopLock({
         cwd,
@@ -195,7 +257,7 @@ export function runVerify(input, cwd) {
             // Dedup on the SNAPSHOT iteration — a report for the iteration we verified already
             // landed (a concurrent verify won). Checking the snapshot (not the current)
             // iteration is what makes this correct after a concurrent advance (review F1).
-            if (hasVerifyReportForIteration(thread, iteration)) {
+            if (hasVerifyReportForIteration(thread, iteration, lane)) {
                 return { thread, report: reportAfterRun, deduped: true };
             }
             // Close the final out-of-lock race: the bytes verified above must still be the
@@ -203,7 +265,7 @@ export function runVerify(input, cwd) {
             // repeats this freshness check so a post-commit mutation also fails closed.
             const workspaceAtCommit = captureWorkspaceDigest(config.cwd);
             const commitStable = workspace_stable && workspaceAtCommit === workspaceAfter;
-            const report = buildVerifyReportBody(config, { ...runResult, passed: runResult.passed && commitStable }, { command_digest, workspace_digest: workspaceAtCommit, workspace_stable: commitStable });
+            const report = buildVerifyReportBody(config, { ...runResult, passed: runResult.passed && commitStable }, { command_digest, workspace_digest: workspaceAtCommit, workspace_stable: commitStable, lane });
             const updated = addArtifactWithEvidence({
                 id: input.loop_id,
                 actor: input.actor,

package/dist/core/schema.js

@@ -1091,6 +1091,11 @@ export const LaneResultSchema = z.object({
      * reconcile this to its phase's required artifact type.
      */
     artifact_type: z.string().min(1).optional(),
+    /** Synthesis-only executable acceptance policy for the downstream implementation loop. */
+    implementation_verify: z.object({
+        command: z.array(z.string().min(1)).min(1),
+        timeout_ms: z.number().int().positive().max(15 * 60 * 1000).optional(),
+    }).optional(),
     /**
      * pln#628 Focus 4B — review-loop verdict. A worker running a review-loop turn
      * sets this to signal whether the change is good to merge (`approve`) or needs

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.27.0 on 2026-08-23T22:12:22.907Z
+// Source: brainclaw v1.28.0 on 2026-08-24T07:09:07.814Z
 export const FACTS = {
-  "version": "1.27.0",
-  "generated_at": "2026-08-23T22:12:22.907Z",
+  "version": "1.28.0",
+  "generated_at": "2026-08-24T07:09:07.814Z",
   "tools": {
     "count": 70,
     "published_count": 68,
@@ -478,7 +478,7 @@ export const FACTS = {
   },
   "bench": {
     "schema": "brainclaw.bench.v1",
-    "generated_at": "2026-08-23T22:12:20.808Z",
+    "generated_at": "2026-08-24T07:09:05.728Z",
     "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": 76,
+        "duration_ms_median": 81,
         "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": 123,
+        "duration_ms_median": 120,
         "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": 14,
+        "duration_ms_median": 13,
         "payload_chars_median": 1305,
         "payload_tokens_est_median": 326
       }

package/dist/facts.json

@@ -1,6 +1,6 @@
 {
-  "version": "1.27.0",
-  "generated_at": "2026-08-23T22:12:22.907Z",
+  "version": "1.28.0",
+  "generated_at": "2026-08-24T07:09:07.814Z",
   "tools": {
     "count": 70,
     "published_count": 68,
@@ -476,7 +476,7 @@
   },
   "bench": {
     "schema": "brainclaw.bench.v1",
-    "generated_at": "2026-08-23T22:12:20.808Z",
+    "generated_at": "2026-08-24T07:09:05.728Z",
     "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": 76,
+        "duration_ms_median": 81,
         "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": 123,
+        "duration_ms_median": 120,
         "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": 14,
+        "duration_ms_median": 13,
         "payload_chars_median": 1305,
         "payload_tokens_est_median": 326
       }

package/docs/loops/implementation.md

@@ -19,6 +19,11 @@ validates the plan/sequence link and advances to `execute`. It never launches
 a worker. `execute ↔ verify` iterates until the verify command is green or
 the cycle cap is hit.
 
+Binding validates the complete graph: every sequence item must reference a
+linked, existing plan (and an existing step when `stepId` is present). Explicit
+sequence lanes are paired deterministically with worker slots, one slot per
+lane. Each slot then carries its lane, plan/step ids, and `scope_hint`.
+
 ## Default protocol
 
 ```
@@ -67,6 +72,11 @@ iteration** — this guards the narrated-verify anti-pattern where a slot
 claims it verified without actually running the command. `command_green` in
 the iteration engine reads the reports produced against this gate.
 
+For bound lanes, call `bclaw_loop(intent='verify', slot_id=…)`. The command
+runs in that slot assignment's worktree. Omitting `slot_id` when several lane
+worktrees exist fails closed, and `command_green` requires a current-iteration
+green report from every bound lane.
+
 ## Stop condition
 
 ```ts
@@ -96,6 +106,9 @@ the iteration engine reads the reports produced against this gate.
 scope claim created by `turn(dispatch=true)`, and the common driver runs in
 the worktree bound to that claim. `bind` creates neither claim nor assignment.
 `session_id` is observability-only.
+Dispatch also uses the bound `scope_hint` to retrieve only path-related
+decisions, constraints, traps and runtime context (while retaining unscoped
+project-wide memory).
 [Attempt authority](../concepts/attempt-authority.md#ordered-dispatch)
 mints a deterministic `turn_id` from `(loop_id, slot_id, iteration)` on
 every dispatch, so a concurrent re-dispatch hits `reservation_exists` and
@@ -105,6 +118,13 @@ uses `(loop_id, slot_id, phase, iteration)` for a versioned successor logical
 turn. This is a Loop Engine rule shared by every kind, not implementation-loop
 special handling.
 
+At `handoff_ready`, the facade emits a structured `next_actions` call for
+`bclaw_coordinate(intent='review', open_loop=true)`. It remains explicit: the
+engine does not invent a reviewer or silently mutate external state. The
+created review loop persists `linked.source_loop_id`, while the implementation
+loop received the same provenance from its ideation source, so `list/get`
+surfaces the pipeline chain without a separate registry.
+
 ## Recovery
 
 - **Execute worker crashed mid-iteration.** Launch grant lease expires;

package/docs/mcp-schema-changelog.md

@@ -408,7 +408,11 @@ 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:81243f3d507c274e`
+- MCP public surface fingerprint: `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.)
+  Previous: `sha256:81243f3d507c274e`
   (updated 2026-08-23 for the common Loop Engine worker driver: `turn` exposes
   real dispatch/model/candidate controls and `complete_turn` exposes the full
   AttemptAuthority fence; bind remains engine-only with compatibility inputs.)

package/package.json

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