brainclaw 1.27.0 → 1.28.1

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/index.js

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

package/dist/core/loops/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,14 @@ 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(),
+    /** Exact upstream artifact that authorized this continuation. */
+    source_artifact_id: z.string().regex(/^art_[0-9a-z]+$/).optional(),
+    /** Sealed digest of source_artifact_id at continuation evaluation time. */
+    source_artifact_digest: z.string().regex(/^[a-f0-9]{64}$/).optional(),
+    /** Durable, deterministic identity of the policy decision that created this loop. */
+    continuation_key: z.string().regex(/^[a-f0-9]{64}$/).optional(),
 });
 /**
  * Memory categories a loop phase can request via `context_filter` (pln#492).
@@ -155,6 +163,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 +433,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 +474,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/reviewer-policy.js

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

package/dist/core/schema.js

@@ -923,11 +923,18 @@ export const ActionRequiredResponseSchema = z.object({
     responded_by_id: z.string().optional(),
     responded_at: z.string(),
 });
+export const ActionRequiredTargetSchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('assignment'), assignment_id: z.string() }),
+    z.object({ kind: z.literal('continuation'), continuation_id: z.string().regex(/^ctn_[a-f0-9]{24}$/) }),
+]);
 export const ActionRequiredSchema = z.object({
     schema_version: z.number().int().positive().optional(),
     id: z.string(),
     short_label: z.string().optional(),
-    assignment_id: z.string(),
+    /** Legacy top-level assignment link; retained for v1 records. */
+    assignment_id: z.string().optional(),
+    /** Discriminated approval target. New records always persist this field. */
+    target: ActionRequiredTargetSchema.optional(),
     run_id: z.string().optional(),
     claim_id: z.string().optional(),
     message_id: z.string().optional(),
@@ -949,6 +956,14 @@ export const ActionRequiredSchema = z.object({
     resolved_at: z.string().optional(),
     response: ActionRequiredResponseSchema.optional(),
     tags: TagsWithDefaultSchema,
+}).superRefine((action, ctx) => {
+    const target = action.target ?? (action.assignment_id ? { kind: 'assignment', assignment_id: action.assignment_id } : undefined);
+    if (!target) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['target'], message: 'ActionRequired requires an assignment or continuation target' });
+    }
+    if (target?.kind === 'assignment' && action.assignment_id && target.assignment_id !== action.assignment_id) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['target'], message: 'assignment target must match assignment_id' });
+    }
 });
 // --- Runtime notes schemas ---
 export const RuntimeNoteTypeSchema = z.enum(['observation', 'session_start', 'session_end']);
@@ -1091,6 +1106,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.1 on 2026-08-24T17:40:07.204Z
 export const FACTS = {
-  "version": "1.27.0",
-  "generated_at": "2026-08-23T22:12:22.907Z",
+  "version": "1.28.1",
+  "generated_at": "2026-08-24T17:40:07.204Z",
   "tools": {
     "count": 70,
     "published_count": 68,
@@ -478,7 +478,7 @@ export const FACTS = {
   },
   "bench": {
     "schema": "brainclaw.bench.v1",
-    "generated_at": "2026-08-23T22:12:20.808Z",
+    "generated_at": "2026-08-24T17:40:05.036Z",
     "node_version": "v24.19.0",
     "platform": "linux-x64",
     "repeats": 3,
@@ -487,7 +487,7 @@ export const FACTS = {
         "name": "cold_onboard",
         "volume": "empty",
         "description": "fresh machine → init → first useful context. Baseline for time-to-first-value.",
-        "duration_ms_median": 76,
+        "duration_ms_median": 85,
         "payload_chars_median": 1640,
         "payload_tokens_est_median": 410
       },
@@ -495,7 +495,7 @@ export const FACTS = {
         "name": "warm_work",
         "volume": "medium",
         "description": "bclaw_work consult over a real-shaped store (~200 plans / 500 handoffs / 450 claims).",
-        "duration_ms_median": 123,
+        "duration_ms_median": 128,
         "payload_chars_median": 2626,
         "payload_tokens_est_median": 657
       },
@@ -503,7 +503,7 @@ export const FACTS = {
         "name": "first_edit",
         "volume": "medium",
         "description": "code_find + code_brief on the fresh-agent path (missing index, first touch).",
-        "duration_ms_median": 14,
+        "duration_ms_median": 11,
         "payload_chars_median": 1305,
         "payload_tokens_est_median": 326
       }