brainclaw 1.27.0 → 1.28.1

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

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

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