brainclaw 1.26.2 → 1.27.0

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

@@ -0,0 +1,485 @@
+import { evidenceDigest, validateArtifactEvidence } from './evidence.js';
+import { captureWorkspaceDigest } from './workspace-digest.js';
+import { currentNonce, findReservationByAssignmentId, getReservation, } from './attempt-reservation.js';
+import { readLaunchDecision, resolveTurnGenerationChain, } from './attempt-generations.js';
+const OBSERVATION = {
+    right: 'gate:artifact',
+    authorities: [
+        { channel: 'complete_turn', producer_kind: 'slot', attestation: 'observation', issuer: 'brainclaw:artifact-commit', required_subject_fields: ['slot_id'] },
+        { channel: 'reconcile_turn', producer_kind: 'slot', attestation: 'observation', issuer: 'brainclaw:artifact-commit', required_subject_fields: ['slot_id', 'turn_id', 'run_id', 'nonce_digest', 'attempt_epoch', 'execution_contract_hash', 'workspace_digest'] },
+        { channel: 'operator_input', producer_kind: 'slot', attestation: 'observation', issuer: 'brainclaw:artifact-commit', required_subject_fields: ['slot_id'] },
+        { channel: 'operator_input', producer_kind: 'operator', attestation: 'observation', issuer: 'brainclaw:artifact-commit' },
+        { channel: 'operator_input', producer_kind: 'engine', attestation: 'observation', issuer: 'brainclaw:artifact-commit' },
+        { channel: 'system_hook', producer_kind: 'engine', attestation: 'observation', issuer: 'brainclaw:artifact-commit' },
+        { channel: 'verify_command', producer_kind: 'engine', attestation: 'verification', issuer: 'brainclaw:verify-command', required_subject_fields: ['command_digest', 'workspace_digest'] },
+    ],
+};
+const APPROVAL = {
+    right: 'gate:reviewer_green',
+    authorities: [
+        { channel: 'complete_turn', producer_kind: 'slot', attestation: 'approval', issuer: 'brainclaw:review-slot', required_subject_fields: ['slot_id'] },
+        { channel: 'reconcile_turn', producer_kind: 'slot', attestation: 'approval', issuer: 'brainclaw:review-slot', required_subject_fields: ['slot_id', 'turn_id', 'run_id', 'nonce_digest', 'attempt_epoch', 'execution_contract_hash', 'workspace_digest'] },
+    ],
+};
+const VERIFICATION = {
+    right: 'gate:command_green',
+    authorities: [
+        { channel: 'verify_command', producer_kind: 'engine', attestation: 'verification', issuer: 'brainclaw:verify-command', required_subject_fields: ['command_digest', 'workspace_digest'] },
+    ],
+};
+const CRITIC_OBSERVATION = {
+    right: 'gate:artifact',
+    authorities: OBSERVATION.authorities.filter((authority) => authority.channel === 'complete_turn' || authority.channel === 'reconcile_turn'),
+};
+const NO_REVIEWER_GREEN = { right: 'gate:reviewer_green', authorities: [] };
+const NO_COMMAND_GREEN = { right: 'gate:command_green', authorities: [] };
+const NO_CRITIC_SIGNAL = { right: 'gate:artifact', authorities: [] };
+/** Policies refine the five protocol graphs; they do not duplicate phase order. */
+export const GATE_POLICIES = {
+    review: {
+        version: 'gate-policy-v1',
+        kind: 'review',
+        requirements: {
+            artifact: OBSERVATION,
+            reviewer_green: APPROVAL,
+            command_green: NO_COMMAND_GREEN,
+            critic_signal: NO_CRITIC_SIGNAL,
+        },
+    },
+    ideation: {
+        version: 'gate-policy-v1',
+        kind: 'ideation',
+        requirements: {
+            artifact: OBSERVATION,
+            reviewer_green: NO_REVIEWER_GREEN,
+            command_green: NO_COMMAND_GREEN,
+            critic_signal: CRITIC_OBSERVATION,
+        },
+    },
+    implementation: {
+        version: 'gate-policy-v1',
+        kind: 'implementation',
+        requirements: {
+            artifact: OBSERVATION,
+            reviewer_green: NO_REVIEWER_GREEN,
+            command_green: VERIFICATION,
+            critic_signal: NO_CRITIC_SIGNAL,
+        },
+    },
+    research: {
+        version: 'gate-policy-v1',
+        kind: 'research',
+        requirements: {
+            artifact: OBSERVATION,
+            reviewer_green: NO_REVIEWER_GREEN,
+            command_green: NO_COMMAND_GREEN,
+            // The shipped research FSM exits investigate↔synthesize on this signal.
+            critic_signal: CRITIC_OBSERVATION,
+        },
+    },
+    debug: {
+        version: 'gate-policy-v1',
+        kind: 'debug',
+        requirements: {
+            artifact: OBSERVATION,
+            reviewer_green: NO_REVIEWER_GREEN,
+            // The shipped debug FSM exits hypothesize↔isolate↔fix on command_green.
+            command_green: VERIFICATION,
+            critic_signal: NO_CRITIC_SIGNAL,
+        },
+    },
+};
+function hasUsableContent(artifact) {
+    return (artifact.body ?? '').trim().length > 0 || artifact.ref !== undefined;
+}
+function legacyEligibleCount(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 artifacts.filter((artifact) => {
+        if (purpose !== 'critic_signal' && !hasUsableContent(artifact))
+            return false;
+        if (!artifact.evidence)
+            return true;
+        return validateArtifactEvidence(thread, artifact).valid
+            && reconciledV2AuthorityRejection(thread, artifact, cwd) === undefined;
+    }).length;
+}
+function payloadFingerprint(artifact) {
+    return evidenceDigest({
+        phase: artifact.phase,
+        type: artifact.type,
+        body: artifact.body,
+        ref: artifact.ref,
+        iteration: artifact.iteration ?? 0,
+        producer: artifact.evidence?.subject.slot_id ?? artifact.evidence?.producer.id ?? artifact.produced_by,
+    });
+}
+/**
+ * A reconciled v2 envelope is only a claim about an attempt until the gate
+ * compares it with immutable AttemptAuthority. The persisted nonce is a digest
+ * (never the bearer token), so compare it with a server-derived digest of the
+ * current generation nonce.
+ *
+ * No v2 chain enters an explicit restrictive legacy verifier backed by the
+ * committed reservation. Missing/unverifiable authority and every tuple
+ * mismatch are fail-closed in both modes.
+ */
+function reconciledV2AuthorityRejection(thread, artifact, cwd) {
+    const envelope = artifact.evidence;
+    if (!envelope || envelope.producer.channel !== 'reconcile_turn')
+        return undefined;
+    const subject = envelope.subject;
+    const reservation = subject.assignment_id
+        ? findReservationByAssignmentId(subject.assignment_id, cwd)
+        : undefined;
+    const resolvedReservation = reservation ?? (subject.turn_id ? getReservation(subject.turn_id, cwd) : undefined);
+    if (!resolvedReservation)
+        return 'reconciled_authority_missing';
+    let chain;
+    try {
+        chain = resolveTurnGenerationChain(resolvedReservation.store_root, resolvedReservation.turn_id);
+    }
+    catch {
+        return 'reconciled_authority_unreadable';
+    }
+    if (!chain) {
+        // Legacy is deliberately narrow, not permissive: every binding is
+        // reconstructed from the committed, crossed reservation. Pre-P1 records
+        // have no stored ExecutionContract, so use the same deterministic
+        // compatibility identities the reconciler seals. This preserves dual-read
+        // without accepting a caller-chosen hash.
+        const nonce = currentNonce(resolvedReservation);
+        if (resolvedReservation.decision !== 'committed'
+            || resolvedReservation.launch?.status !== 'crossed'
+            || !nonce) {
+            return 'reconciled_legacy_authority_unverifiable';
+        }
+        const contractHash = resolvedReservation.execution_contract_ref?.hash ?? evidenceDigest({
+            version: 'legacy-uncontracted-reservation-v1',
+            turn_id: resolvedReservation.turn_id,
+            run_id: resolvedReservation.child_ids.run_id,
+            epoch: resolvedReservation.epoch,
+            phase: resolvedReservation.phase,
+            iteration: resolvedReservation.iteration,
+            cwd: resolvedReservation.cwd,
+        });
+        const workspaceDigest = evidenceDigest({
+            workspace_policy: resolvedReservation.execution_contract?.workspace_policy,
+            cwd: resolvedReservation.cwd,
+            store_root: resolvedReservation.store_root,
+        });
+        const expectedLegacy = {
+            loop_id: resolvedReservation.loop_id,
+            slot_id: resolvedReservation.slot_id,
+            turn_id: resolvedReservation.turn_id,
+            assignment_id: resolvedReservation.child_ids.assignment_id,
+            run_id: resolvedReservation.child_ids.run_id,
+            nonce_digest: evidenceDigest({ launch_nonce: nonce }),
+            attempt_epoch: resolvedReservation.epoch,
+            execution_contract_hash: contractHash,
+            workspace_digest: workspaceDigest,
+        };
+        const actualLegacy = {
+            loop_id: thread.id,
+            slot_id: subject.slot_id,
+            turn_id: subject.turn_id,
+            assignment_id: subject.assignment_id,
+            run_id: subject.run_id,
+            nonce_digest: subject.nonce_digest,
+            attempt_epoch: subject.attempt_epoch,
+            execution_contract_hash: subject.execution_contract_hash,
+            workspace_digest: subject.workspace_digest,
+        };
+        const mismatch = Object.keys(expectedLegacy)
+            .find((field) => actualLegacy[field] !== expectedLegacy[field]);
+        return mismatch ? `reconciled_legacy_authority_mismatch:${mismatch}` : undefined;
+    }
+    if (chain.status !== 'active' && chain.status !== 'settled') {
+        return `reconciled_authority_not_usable:${chain.status}`;
+    }
+    const generation = chain.latest_generation;
+    let launch;
+    try {
+        launch = readLaunchDecision(resolvedReservation.store_root, generation.turn_id, generation.attempt_epoch);
+    }
+    catch {
+        return 'reconciled_authority_unreadable';
+    }
+    if (launch?.decision !== 'crossed')
+        return 'reconciled_authority_launch_not_crossed';
+    const expected = {
+        loop_id: resolvedReservation.loop_id,
+        slot_id: resolvedReservation.slot_id,
+        turn_id: generation.turn_id,
+        assignment_id: generation.assignment_id,
+        run_id: generation.run_id,
+        nonce_digest: evidenceDigest({ launch_nonce: generation.launch_nonce }),
+        attempt_epoch: generation.attempt_epoch,
+        execution_contract_hash: generation.contract_hash,
+        workspace_digest: generation.workspace_digest,
+    };
+    const actual = {
+        loop_id: thread.id,
+        slot_id: subject.slot_id,
+        turn_id: subject.turn_id,
+        assignment_id: subject.assignment_id,
+        run_id: subject.run_id,
+        nonce_digest: subject.nonce_digest,
+        attempt_epoch: subject.attempt_epoch,
+        execution_contract_hash: subject.execution_contract_hash,
+        workspace_digest: subject.workspace_digest,
+    };
+    const mismatch = Object.keys(expected)
+        .find((field) => actual[field] !== expected[field]);
+    return mismatch ? `reconciled_authority_mismatch:${mismatch}` : undefined;
+}
+function selectEligible(thread, artifacts, purpose, cwd) {
+    const mode = thread.evidence_policy?.mode ?? 'legacy';
+    const requirement = GATE_POLICIES[thread.kind].requirements[purpose];
+    const eligible = [];
+    const accepted_evidence_ids = [];
+    const rejected = [];
+    const fingerprints = new Set();
+    for (const artifact of artifacts) {
+        // critic_signal is intentionally a typed marker; unlike deliverable
+        // artifacts it does not require an inline/ref payload.
+        if (purpose !== 'critic_signal' && !hasUsableContent(artifact)) {
+            rejected.push({ artifact_id: artifact.artifact_id, reason: 'no_usable_content' });
+            continue;
+        }
+        // A present envelope is always validated, including on legacy threads.
+        if (artifact.evidence) {
+            const validity = validateArtifactEvidence(thread, artifact);
+            if (!validity.valid) {
+                rejected.push({ artifact_id: artifact.artifact_id, reason: validity.reasons.join(',') });
+                continue;
+            }
+        }
+        else if (mode === 'strict' || mode === 'shadow') {
+            rejected.push({ artifact_id: artifact.artifact_id, reason: 'missing_evidence' });
+            continue;
+        }
+        if (mode !== 'legacy') {
+            const envelope = artifact.evidence;
+            if (purpose === 'reviewer_green' && (artifact.iteration ?? 0) !== thread.iteration_count) {
+                rejected.push({ artifact_id: artifact.artifact_id, reason: 'stale_subject_iteration' });
+                continue;
+            }
+            const channelAuthorities = requirement.authorities.filter((authority) => authority.channel === envelope.producer.channel);
+            if (channelAuthorities.length === 0) {
+                rejected.push({ artifact_id: artifact.artifact_id, reason: `channel_not_allowed:${envelope.producer.channel}` });
+                continue;
+            }
+            const producerAuthorities = channelAuthorities.filter((authority) => authority.producer_kind === envelope.producer.kind);
+            if (producerAuthorities.length === 0) {
+                rejected.push({ artifact_id: artifact.artifact_id, reason: `producer_channel_mismatch:${envelope.producer.kind}:${envelope.producer.channel}` });
+                continue;
+            }
+            const authority = producerAuthorities.find((candidate) => envelope.attestations.some((item) => item.kind === candidate.attestation
+                && item.issuer === candidate.issuer
+                && item.rights.includes(requirement.right)));
+            if (!authority) {
+                rejected.push({ artifact_id: artifact.artifact_id, reason: `missing_authorized_attestation:${requirement.right}` });
+                continue;
+            }
+            const missingSubject = authority.required_subject_fields?.find((field) => envelope.subject[field] === undefined || envelope.subject[field] === '');
+            if (missingSubject) {
+                rejected.push({ artifact_id: artifact.artifact_id, reason: `missing_subject_binding:${missingSubject}` });
+                continue;
+            }
+            if (envelope.subject.slot_id) {
+                const slot = thread.slots.find((candidate) => candidate.slot_id === envelope.subject.slot_id);
+                if (!slot) {
+                    rejected.push({ artifact_id: artifact.artifact_id, reason: 'unknown_subject_slot' });
+                    continue;
+                }
+                if (slot.current_turn_id && envelope.subject.turn_id !== slot.current_turn_id) {
+                    rejected.push({ artifact_id: artifact.artifact_id, reason: 'wrong_subject_turn' });
+                    continue;
+                }
+                if (slot.assignment_id && envelope.subject.assignment_id !== slot.assignment_id) {
+                    rejected.push({ artifact_id: artifact.artifact_id, reason: 'wrong_subject_assignment' });
+                    continue;
+                }
+                if (slot.claim_id && envelope.subject.claim_id !== slot.claim_id) {
+                    rejected.push({ artifact_id: artifact.artifact_id, reason: 'wrong_subject_claim' });
+                    continue;
+                }
+            }
+            if (envelope.producer.channel === 'verify_command') {
+                let report;
+                try {
+                    report = JSON.parse(artifact.body ?? '{}');
+                }
+                catch {
+                    report = {};
+                }
+                if (report.workspace_stable !== true
+                    || !report.command_argv
+                    || evidenceDigest({ command: report.command_argv }) !== report.command_digest
+                    || (thread.protocol?.verify
+                        && evidenceDigest({ command: thread.protocol.verify.command }) !== report.command_digest)
+                    || report.command_digest !== envelope.subject.command_digest
+                    || report.workspace_digest !== envelope.subject.workspace_digest) {
+                    rejected.push({ artifact_id: artifact.artifact_id, reason: 'verification_subject_mismatch' });
+                    continue;
+                }
+                try {
+                    if (!report.cwd || captureWorkspaceDigest(report.cwd) !== envelope.subject.workspace_digest) {
+                        rejected.push({ artifact_id: artifact.artifact_id, reason: 'workspace_changed_after_verification' });
+                        continue;
+                    }
+                }
+                catch {
+                    rejected.push({ artifact_id: artifact.artifact_id, reason: 'workspace_freshness_unavailable' });
+                    continue;
+                }
+            }
+            if (envelope.producer.channel === 'reconcile_turn' && envelope.subject.execution_contract_hash === undefined) {
+                rejected.push({ artifact_id: artifact.artifact_id, reason: 'missing_subject_binding:execution_contract_hash' });
+                continue;
+            }
+            const authorityRejection = reconciledV2AuthorityRejection(thread, artifact, cwd);
+            if (authorityRejection) {
+                rejected.push({ artifact_id: artifact.artifact_id, reason: authorityRejection });
+                continue;
+            }
+        }
+        if (mode !== 'legacy') {
+            const fingerprint = payloadFingerprint(artifact);
+            if (fingerprints.has(fingerprint)) {
+                rejected.push({ artifact_id: artifact.artifact_id, reason: 'duplicate_payload' });
+                continue;
+            }
+            fingerprints.add(fingerprint);
+        }
+        eligible.push(artifact);
+        if (artifact.evidence)
+            accepted_evidence_ids.push(artifact.evidence.evidence_id);
+    }
+    return { eligible, accepted_evidence_ids, rejected };
+}
+function modeFor(thread) {
+    return thread.evidence_policy?.mode ?? 'legacy';
+}
+function decision(thread, condition, strictPassed, legacyPassed, set = { eligible: [], accepted_evidence_ids: [], rejected: [] }) {
+    const mode = modeFor(thread);
+    return {
+        passed: mode === 'legacy' || mode === 'shadow' ? legacyPassed : strictPassed,
+        strict_passed: strictPassed,
+        legacy_passed: legacyPassed,
+        policy_version: mode === 'legacy' ? 'legacy' : 'gate-policy-v1',
+        mode,
+        condition_digest: evidenceDigest(condition),
+        accepted_evidence_ids: [...new Set(set.accepted_evidence_ids)],
+        rejected: set.rejected,
+    };
+}
+function artifactCandidates(thread, condition) {
+    return thread.artifacts.filter((artifact) => {
+        if (artifact.type !== condition.type)
+            return false;
+        if (condition.kind === 'artifact_produced')
+            return artifact.phase === condition.phase;
+        if (condition.scope !== 'phase')
+            return true;
+        if (artifact.phase !== thread.current_phase)
+            return false;
+        const iterationAware = thread.iteration_count > 0 || thread.artifacts.some((item) => item.iteration !== undefined);
+        return !iterationAware || (artifact.iteration ?? 0) === thread.iteration_count;
+    });
+}
+/** One evaluator owns both terminal stop conditions and phase gates. */
+export function evaluateGateCondition(thread, condition, cwd) {
+    if (!condition)
+        return decision(thread, { kind: 'absent' }, false, false);
+    switch (condition.kind) {
+        case 'phase_reached': {
+            const passed = thread.current_phase === condition.phase;
+            return decision(thread, condition, passed, passed);
+        }
+        case 'max_iterations':
+        case 'min_iterations': {
+            const passed = thread.iteration_count >= condition.n;
+            return decision(thread, condition, passed, passed);
+        }
+        case 'no_open_questions': {
+            const passed = thread.open_questions.length === 0;
+            return decision(thread, condition, passed, passed);
+        }
+        case 'manual':
+            return decision(thread, condition, false, false);
+        case 'reviewer_green': {
+            const candidates = thread.artifacts.filter((artifact) => artifact.type === 'verdict' && /^accepted(?:\b|[:\s])/.test((artifact.body ?? '').trim().toLowerCase()));
+            const set = selectEligible(thread, candidates, 'reviewer_green', cwd);
+            return decision(thread, condition, set.eligible.length > 0, legacyEligibleCount(thread, candidates, 'reviewer_green', cwd) > 0, set);
+        }
+        case 'artifact_produced': {
+            const candidates = artifactCandidates(thread, condition);
+            const set = selectEligible(thread, candidates, 'artifact', cwd);
+            return decision(thread, condition, set.eligible.length > 0, legacyEligibleCount(thread, candidates, 'artifact', cwd) > 0, set);
+        }
+        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);
+        }
+        case 'any': {
+            const children = condition.conditions.map((child) => evaluateGateCondition(thread, child, cwd));
+            return decision(thread, condition, children.some((child) => child.strict_passed ?? child.passed), children.some((child) => child.legacy_passed ?? child.passed), {
+                eligible: [],
+                accepted_evidence_ids: children.flatMap((child) => child.accepted_evidence_ids),
+                rejected: children.flatMap((child) => child.rejected),
+            });
+        }
+        case 'all': {
+            const children = condition.conditions.map((child) => evaluateGateCondition(thread, child, cwd));
+            return decision(thread, condition, children.every((child) => child.strict_passed ?? child.passed), children.every((child) => child.legacy_passed ?? child.passed), {
+                eligible: [],
+                accepted_evidence_ids: children.flatMap((child) => child.accepted_evidence_ids),
+                rejected: children.flatMap((child) => child.rejected),
+            });
+        }
+    }
+}
+export function eligibleArtifactsForPurpose(thread, artifacts, purpose, cwd) {
+    return selectEligible(thread, artifacts, purpose, cwd);
+}
+export function evaluateCommandGreen(thread, iteration, cwd) {
+    const candidates = thread.artifacts.filter((artifact) => {
+        if (artifact.type !== 'verify_report' || (artifact.iteration ?? 0) !== iteration)
+            return false;
+        try {
+            return JSON.parse(artifact.body ?? '{}').passed === true;
+        }
+        catch {
+            return false;
+        }
+    });
+    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);
+}
+export function evaluateCriticSignal(thread, iteration, cwd) {
+    const candidates = thread.artifacts.filter((artifact) => artifact.type === 'critic_signal' && (artifact.iteration ?? 0) === iteration);
+    const set = selectEligible(thread, candidates, 'critic_signal', cwd);
+    return decision(thread, { kind: 'critic_signal', iteration }, set.eligible.length > 0, legacyEligibleCount(thread, candidates, 'critic_signal', cwd) > 0, set);
+}
+export function evaluateNoNewCritique(thread, iteration, cwd) {
+    const candidates = thread.artifacts.filter((artifact) => artifact.type === 'critique' && (artifact.iteration ?? 0) === iteration);
+    const set = selectEligible(thread, candidates, 'artifact', cwd);
+    const closureCandidates = thread.artifacts.filter((artifact) => artifact.type === 'critique_window_closed' && (artifact.iteration ?? 0) === iteration);
+    const closure = selectEligible(thread, closureCandidates, 'artifact', cwd);
+    // Invalid/replayed critiques cannot be used to manufacture a negative convergence signal.
+    const strictPassed = set.eligible.length === 0
+        && set.rejected.length === 0
+        && closure.eligible.length > 0;
+    return decision(thread, { kind: 'no_new_critique_artifacts', iteration }, strictPassed, candidates.length === 0, {
+        eligible: closure.eligible,
+        accepted_evidence_ids: [...set.accepted_evidence_ids, ...closure.accepted_evidence_ids],
+        rejected: [...set.rejected, ...closure.rejected],
+    });
+}
+//# sourceMappingURL=gate-policy.js.map

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

@@ -1,32 +1,22 @@
-/**
- * pln#632 impl-loop bind — the ENGINE action for an implementation loop's `bind` phase.
- *
- * The implementation protocol declares `bind` as "bind plan+sequence and dispatch" (see
- * LOOP_PROTOCOLS.implementation in types.ts). This is that action: read the loop's linked
- * sequence, dispatch its ready lanes via the EXISTING sequence spawner, then advance
- * `bind → execute` so the loop enters its execute↔verify cycle.
- *
- * Reuses `dispatch()` ADDITIVELY via its `sequenceId` option (pln#632) so the loop drives
- * its OWN linked sequence WITHOUT touching the project's global active-sequence pointer —
- * no hijack of whatever sequence other bclaw_dispatch work is using. Mirrors the
- * async-handler-spawns pattern already used by bclaw_coordinate(open_loop=true) for review
- * loops; touches NO review/ideation dispatch. The live spawn happens only when this runs
- * on a real loop (exactly like bclaw_dispatch) — `dryRun` previews with no spawn and no
- * phase mutation, so the flow is unit-testable.
- */
-import { dispatch } from '../dispatcher.js';
 import { listSequences } from '../sequence.js';
+import { withLoopLock } from './lock.js';
 import { getLoop } from './store.js';
 import { advance } from './verbs.js';
-import { withLoopLock } from './lock.js';
+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
+        || input.autoExecute !== undefined
+        || input.model !== undefined
+        || input.maxAssignments !== undefined;
+    return usedLaunchOption
+        ? [`${ENGINE_ONLY_WARNING}; bind launch options are retained but ignored`]
+        : [ENGINE_ONLY_WARNING];
+}
 /**
- * Bind an implementation loop to its linked sequence and dispatch it. Async because the
- * underlying spawn is async (the only awaited work; `dryRun` resolves synchronously).
+ * Validate an implementation loop's linked sequence and advance to execute.
  *
- * Idempotent: a loop already past `bind` returns a `noop` (never re-dispatches on a second
- * bind after it advanced). A crash BETWEEN dispatch and advance leaves the loop in `bind`,
- * so a retry re-dispatches only the still-unassigned lanes (dispatch skips lanes with an
- * active assignment) and re-attempts the advance — safe crash-recovery.
+ * Idempotent: a loop already past `bind` returns `noop`. The phase re-check and
+ * advance happen under the loop lock, so racing bind calls cannot advance twice.
  */
 export async function runImplBind(input, cwd) {
     const { loop_id, dispatcherAgent } = input;
@@ -36,16 +26,10 @@ export async function runImplBind(input, cwd) {
     if (loop.kind !== 'implementation') {
         throw new Error(`bind is only valid for implementation loops (loop ${loop_id} is kind='${loop.kind}'); review/ideation loops dispatch via bclaw_coordinate`);
     }
-    // bind SPAWNS real workers via dispatch() — never do that on a loop that is not open.
-    // A paused loop keeps current_phase='bind' (pause only flips status), and open→close
-    // leaves the phase at 'bind' too, so the phase-idempotency check below is NOT sufficient
-    // to stop a spawn on a held/terminal loop (review Finding 1). Gate on status FIRST, so
-    // no dispatch fires and we don't spawn then throw at the advance.
     if (loop.status !== 'open') {
         throw new Error(`bind requires an open loop; loop ${loop_id} is ${loop.status} (resume a paused loop, or reopen a terminal one, before binding)`);
     }
     const sequenceId = loop.linked?.sequence_ids?.[0];
-    // Idempotency: `bind` is the loop's FIRST phase. A loop already past it was bound before.
     if (loop.current_phase !== 'bind') {
         return {
             loop_id,
@@ -53,58 +37,27 @@ export async function runImplBind(input, cwd) {
             action: 'noop',
             dispatch: null,
             messages_sent: 0,
-            reason: `loop is in phase '${loop.current_phase}', not 'bind' — already bound (idempotent)`,
+            warnings: compatibilityWarnings(input),
+            reason: `loop is in phase '${loop.current_phase}', not 'bind' - already bound (idempotent)`,
         };
     }
     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}.`);
+        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}.`);
     }
-    // Validate up-front (non-throwing lookup) so a missing sequence fails with a clear
-    // message rather than a silent null dispatch.
-    const seq = listSequences(cwd).find((s) => s.id === sequenceId);
-    if (!seq)
+    if (!listSequences(cwd).some((sequence) => sequence.id === sequenceId)) {
         throw new Error(`linked sequence ${sequenceId} not found for loop ${loop_id}`);
-    const dispatched = await dispatch({
-        sequenceId,
-        dispatcherAgent,
-        dispatcherAgentId: input.dispatcherAgentId,
-        sessionId: input.sessionId,
-        dryRun: input.dryRun,
-        lanes: input.lanes,
-        autoExecute: input.autoExecute,
-        model: input.model,
-        maxAssignments: input.maxAssignments,
-    }, cwd ?? process.cwd());
-    const result = dispatched?.result ?? null;
-    const messages_sent = result?.messages_sent.length ?? 0;
-    // Guard a race: the sequence disappeared between validation and dispatch → don't advance.
-    if (!dispatched) {
-        return {
-            loop_id,
-            sequence_id: sequenceId,
-            action: 'noop',
-            dispatch: null,
-            messages_sent: 0,
-            reason: `sequence ${sequenceId} yielded no dispatch analysis (unavailable); loop stays in 'bind'`,
-        };
     }
     if (input.dryRun) {
         return {
             loop_id,
             sequence_id: sequenceId,
             action: 'preview',
-            dispatch: result,
-            messages_sent,
-            reason: `dry run: ${result?.delivery_plan.length ?? 0} lane(s) would dispatch; loop stays in 'bind' (no spawn, no advance)`,
+            dispatch: null,
+            messages_sent: 0,
+            warnings: compatibilityWarnings(input),
+            reason: `dry run: linked sequence ${sequenceId} is valid; loop stays in 'bind' and no worker is dispatched`,
         };
     }
-    // Real bind: advance bind → execute so the loop enters the execute↔verify cycle. The
-    // implementation protocol's `bind` phase carries no advance_gate, so the advance is
-    // unconditional FROM bind — but the phase-check and the advance must be ATOMIC or two
-    // racing binds each advance once and push the loop bind→execute→verify with no execute
-    // work done (review Finding 2). advance() does not self-lock (its callers — the facade's
-    // withLockedLoopMutation and the ideation closer — provide the lock), so we take the loop
-    // lock here and re-check the phase under it: only the bind that still sees 'bind' advances.
     const advanced = withLoopLock({
         cwd,
         intent: 'impl-bind-advance',
@@ -112,12 +65,15 @@ export async function runImplBind(input, cwd) {
         scope: { kind: 'loop', loopId: loop_id },
         work: () => {
             const fresh = getLoop(loop_id, cwd);
-            // Raced: a concurrent bind (or a pause/close) moved the loop out of an open 'bind'
-            // state → do NOT advance again. Idempotent by construction.
             if (!fresh || fresh.status !== 'open' || fresh.current_phase !== 'bind')
                 return null;
-            const a = advance({ id: loop_id, actor: dispatcherAgent }, cwd);
-            return { phase: a.loop.current_phase, auto_closed: a.auto_closed };
+            const freshSequenceId = fresh.linked?.sequence_ids?.[0];
+            if (freshSequenceId !== sequenceId
+                || !listSequences(cwd).some((sequence) => sequence.id === sequenceId)) {
+                throw new Error(`linked sequence ${sequenceId} changed or disappeared before bind could advance`);
+            }
+            const result = advance({ id: loop_id, actor: dispatcherAgent }, cwd);
+            return { phase: result.loop.current_phase, auto_closed: result.auto_closed };
         },
     });
     if (!advanced) {
@@ -125,9 +81,10 @@ export async function runImplBind(input, cwd) {
             loop_id,
             sequence_id: sequenceId,
             action: 'noop',
-            dispatch: result,
-            messages_sent,
-            reason: `dispatched ${messages_sent} assignment(s); phase already advanced out of 'bind' under a concurrent bind (idempotent — not re-advanced)`,
+            dispatch: null,
+            messages_sent: 0,
+            warnings: compatibilityWarnings(input),
+            reason: `phase already advanced out of 'bind' under a concurrent bind (idempotent - not re-advanced)`,
         };
     }
     return {
@@ -136,9 +93,10 @@ export async function runImplBind(input, cwd) {
         action: 'bound',
         advanced_to: advanced.phase,
         auto_closed: advanced.auto_closed,
-        dispatch: result,
-        messages_sent,
-        reason: `dispatched ${messages_sent} assignment(s) on sequence ${sequenceId}; advanced bind → ${advanced.phase}`,
+        dispatch: null,
+        messages_sent: 0,
+        warnings: compatibilityWarnings(input),
+        reason: `validated linked sequence ${sequenceId}; advanced bind -> ${advanced.phase}; dispatch worker slots with turn(dispatch=true)`,
     };
 }
 //# sourceMappingURL=impl-bind.js.map