brainclaw 1.28.0 → 1.28.2

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

@@ -446,7 +446,20 @@ export function findReservationByAssignmentId(assignmentId, cwd) {
     // coexists with a real LANE-RESULT (dispatch commits before spawn). Filtering here makes
     // the turn-owned discriminator explicit — a `prepared`/`aborted` reservation must never
     // route a lane to reconcileTurn (it has no live launch generation to accept evidence for).
-    return listReservations({ decision: 'committed' }, cwd).find((r) => r.child_ids.assignment_id === assignmentId);
+    return listReservations({ decision: 'committed' }, cwd).find((reservation) => {
+        if (reservation.child_ids.assignment_id === assignmentId)
+            return true;
+        try {
+            const root = cwd ?? reservation.store_root;
+            const initial = readInitialGeneration(root, reservation.turn_id);
+            return initial
+                ? listAttemptGenerations(root, initial).some((generation) => generation.assignment_id === assignmentId)
+                : false;
+        }
+        catch {
+            return false;
+        }
+    });
 }
 /** Run-scoping key for runtime evidence; undefined preserves legacy assignment-scoped paths. */
 export function currentAttemptRunIdForAssignment(assignmentId, cwd) {

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

@@ -1,16 +1,36 @@
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import { ensureAgentRunProjection, loadAgentRun, transitionAgentRun } from '../agentruns.js';
-import { loadAssignment } from '../assignments.js';
+import { convergeAssignmentToTerminal, loadAssignment, transitionAssignment } from '../assignments.js';
 import { createRuntimeEvent } from '../events.js';
 import { nowISO } from '../ids.js';
 import { prepareAttemptTakeoverV2 } from './attempt-authority.js';
-import { generationDigest } from './attempt-generations.js';
+import { generationDigest, resolveTurnGenerationChain } from './attempt-generations.js';
 import { commitViaIntent } from './commit-intent.js';
 import { evidenceDigest } from './evidence.js';
 import { withLoopLock } from './lock.js';
 import { getReservation } from './attempt-reservation.js';
 import { getLoop, listLoopEvents } from './store.js';
+/**
+ * Signals that the immutable successor generation already won even though a
+ * replayable projection failed afterward. Callers must never roll claims back
+ * on this error; replaying the same takeover input repairs the projections.
+ */
+export class AttemptTakeoverCommittedError extends Error {
+    turn_id;
+    assignment_id;
+    run_id;
+    attempt_epoch;
+    constructor(takeover, cause) {
+        super(`takeover generation ${takeover.next_generation.attempt_epoch} committed; projection repair required: ${cause instanceof Error ? cause.message : String(cause)}`);
+        this.name = 'AttemptTakeoverCommittedError';
+        this.turn_id = takeover.next_generation.turn_id;
+        this.assignment_id = takeover.next_generation.assignment_id;
+        this.run_id = takeover.next_generation.run_id;
+        this.attempt_epoch = takeover.next_generation.attempt_epoch;
+        this.cause = cause;
+    }
+}
 /**
  * Operator/engine takeover transaction.
  *
@@ -25,66 +45,137 @@ export function takeoverLoopAttempt(input) {
         throw new Error(`takeover workspace must already exist as an isolated directory: ${input.next_workspace_path}`);
     }
     const authorityActor = input.actor_id ?? input.actor;
-    const transaction = withLoopLock({
-        cwd: input.cwd,
-        intent: 'attempt-takeover',
-        agentId: authorityActor,
-        scope: { kind: 'loop', loopId: input.loop_id },
-        work: () => {
-            const loop = getLoop(input.loop_id, input.cwd);
-            if (!loop || loop.status !== 'open')
-                throw new Error(`loop ${input.loop_id} is not open`);
-            if (loop.created_by !== authorityActor) {
-                throw new Error(`attempt takeover requires loop coordinator ${loop.created_by}; caller is ${authorityActor}`);
+    let committed;
+    let transaction;
+    try {
+        transaction = withLoopLock({
+            cwd: input.cwd,
+            intent: 'attempt-takeover',
+            agentId: authorityActor,
+            scope: { kind: 'loop', loopId: input.loop_id },
+            work: () => {
+                const loop = getLoop(input.loop_id, input.cwd);
+                if (!loop || loop.status !== 'open')
+                    throw new Error(`loop ${input.loop_id} is not open`);
+                if (loop.created_by !== authorityActor) {
+                    throw new Error(`attempt takeover requires loop coordinator ${loop.created_by}; caller is ${authorityActor}`);
+                }
+                const slot = loop.slots.find((candidate) => candidate.slot_id === input.slot_id);
+                if (!slot)
+                    throw new Error(`slot ${input.slot_id} not found in loop ${input.loop_id}`);
+                const reservation = getReservation(input.turn_id, input.cwd);
+                if (!reservation || reservation.loop_id !== loop.id || reservation.slot_id !== slot.slot_id) {
+                    throw new Error(`turn ${input.turn_id} does not own ${loop.id}/${slot.slot_id}`);
+                }
+                const activeGeneration = resolveTurnGenerationChain(input.cwd, input.turn_id)?.latest_generation;
+                const activeAssignmentId = activeGeneration?.assignment_id ?? reservation.child_ids.assignment_id;
+                if (slot.current_turn_id !== input.turn_id || slot.assignment_id !== activeAssignmentId) {
+                    throw new Error(`slot ${slot.slot_id} is no longer bound to turn ${input.turn_id}`);
+                }
+                const takeover = prepareAttemptTakeoverV2({ ...input, actor: authorityActor });
+                committed = takeover;
+                input.on_stage?.('authority_committed');
+                const duplicate = listLoopEvents(loop.id, input.cwd).some((event) => event.kind === 'attempt_generation_changed'
+                    && event.turn_id === input.turn_id
+                    && event.to_epoch === takeover.next_generation.attempt_epoch
+                    && event.to_run_id === takeover.next_generation.run_id);
+                if (duplicate)
+                    return { loop, takeover, reservation };
+                const now = nowISO();
+                const mutationId = crypto.randomUUID();
+                const executor = takeover.next_generation.executor ?? {
+                    agent: reservation.agent,
+                    agent_id: reservation.agent_id,
+                    claim_id: reservation.claim_id,
+                    capability_snapshot: reservation.capability_snapshot,
+                };
+                const event = {
+                    event_id: crypto.randomUUID(),
+                    loop_id: loop.id,
+                    seq: loop.version + 1,
+                    at: now,
+                    by: authorityActor,
+                    mutation_id: mutationId,
+                    kind: 'attempt_generation_changed',
+                    slot_id: slot.slot_id,
+                    turn_id: input.turn_id,
+                    assignment_id: takeover.next_generation.assignment_id,
+                    claim_id: executor.claim_id,
+                    agent: executor.agent,
+                    agent_id: executor.agent_id,
+                    from_epoch: takeover.previous_generation.attempt_epoch,
+                    to_epoch: takeover.next_generation.attempt_epoch,
+                    from_run_id: takeover.previous_generation.run_id,
+                    to_run_id: takeover.next_generation.run_id,
+                    close_digest: evidenceDigest(takeover.close_cell),
+                    cause: input.cause,
+                };
+                const next = {
+                    ...loop,
+                    version: loop.version + 1,
+                    mutation_id: mutationId,
+                    slots: loop.slots.map((candidate) => candidate.slot_id === slot.slot_id
+                        ? {
+                            ...candidate,
+                            agent: executor.agent,
+                            agent_id: executor.agent_id,
+                            assignment_id: takeover.next_generation.assignment_id,
+                            claim_id: executor.claim_id,
+                            current_turn_id: input.turn_id,
+                            status: 'assigned',
+                        }
+                        : candidate),
+                    updated_at: now,
+                };
+                commitViaIntent({ loop_id: loop.id, base_version: loop.version, events: [event], thread_snapshot: next }, input.cwd);
+                input.on_stage?.('loop_committed');
+                return { loop: next, takeover, reservation };
+            },
+        });
+    }
+    catch (error) {
+        if (committed)
+            throw new AttemptTakeoverCommittedError(committed, error);
+        throw error;
+    }
+    const { takeover, reservation } = transaction;
+    const executor = takeover.next_generation.executor ?? {
+        agent: reservation.agent,
+        agent_id: reservation.agent_id,
+        claim_id: reservation.claim_id,
+        capability_snapshot: reservation.capability_snapshot,
+    };
+    if (takeover.previous_generation.assignment_id !== takeover.next_generation.assignment_id) {
+        try {
+            const previousAssignmentId = takeover.previous_generation.assignment_id;
+            const previousAssignment = loadAssignment(previousAssignmentId, input.cwd);
+            const predecessorTerminal = input.predecessor_assignment_terminal ?? 'cancelled';
+            const statusReason = `fenced by ${input.mode ?? 'takeover'} to epoch ${takeover.next_generation.attempt_epoch}`;
+            // System convergence intentionally covers only file-worker states
+            // (offered/accepted/started). A takeover can win before launch while the
+            // predecessor is still created, or during retry setup; both states have
+            // a legal direct cancellation edge and must be terminal before the stable
+            // claim is rebound to the successor generation.
+            if (predecessorTerminal === 'rerouted' && previousAssignment && previousAssignment.status !== 'rerouted') {
+                transitionAssignment(previousAssignmentId, 'rerouted', {
+                    actor: input.actor,
+                    syncAgentRun: false,
+                    status_reason: statusReason,
+                }, input.cwd);
             }
-            const slot = loop.slots.find((candidate) => candidate.slot_id === input.slot_id);
-            if (!slot)
-                throw new Error(`slot ${input.slot_id} not found in loop ${input.loop_id}`);
-            const reservation = getReservation(input.turn_id, input.cwd);
-            if (!reservation || reservation.loop_id !== loop.id || reservation.slot_id !== slot.slot_id) {
-                throw new Error(`turn ${input.turn_id} does not own ${loop.id}/${slot.slot_id}`);
+            else if (previousAssignment?.status === 'created' || previousAssignment?.status === 'retrying') {
+                transitionAssignment(previousAssignmentId, 'cancelled', {
+                    actor: input.actor,
+                    syncAgentRun: false,
+                    status_reason: statusReason,
+                }, input.cwd);
             }
-            if (slot.current_turn_id !== input.turn_id || slot.assignment_id !== reservation.child_ids.assignment_id) {
-                throw new Error(`slot ${slot.slot_id} is no longer bound to turn ${input.turn_id}`);
+            else {
+                convergeAssignmentToTerminal(previousAssignmentId, 'cancelled', statusReason, input.cwd);
             }
-            const takeover = prepareAttemptTakeoverV2({ ...input, actor: authorityActor });
-            const duplicate = listLoopEvents(loop.id, input.cwd).some((event) => event.kind === 'attempt_generation_changed'
-                && event.turn_id === input.turn_id
-                && event.to_epoch === takeover.next_generation.attempt_epoch
-                && event.to_run_id === takeover.next_generation.run_id);
-            if (duplicate)
-                return { loop, takeover, reservation };
-            const now = nowISO();
-            const mutationId = crypto.randomUUID();
-            const event = {
-                event_id: crypto.randomUUID(),
-                loop_id: loop.id,
-                seq: loop.version + 1,
-                at: now,
-                by: authorityActor,
-                mutation_id: mutationId,
-                kind: 'attempt_generation_changed',
-                slot_id: slot.slot_id,
-                turn_id: input.turn_id,
-                assignment_id: takeover.next_generation.assignment_id,
-                from_epoch: takeover.previous_generation.attempt_epoch,
-                to_epoch: takeover.next_generation.attempt_epoch,
-                from_run_id: takeover.previous_generation.run_id,
-                to_run_id: takeover.next_generation.run_id,
-                close_digest: evidenceDigest(takeover.close_cell),
-                cause: input.cause,
-            };
-            const next = {
-                ...loop,
-                version: loop.version + 1,
-                mutation_id: mutationId,
-                updated_at: now,
-            };
-            commitViaIntent({ loop_id: loop.id, base_version: loop.version, events: [event], thread_snapshot: next }, input.cwd);
-            return { loop: next, takeover, reservation };
-        },
-    });
-    const { takeover, reservation } = transaction;
+        }
+        catch { /* immutable close cell already fences the old assignment */ }
+    }
     const assignment = loadAssignment(takeover.next_generation.assignment_id, input.cwd);
     const previousRun = loadAgentRun(takeover.previous_generation.run_id, input.cwd);
     if (previousRun && !['completed', 'failed', 'cancelled', 'timed_out', 'interrupted'].includes(previousRun.status)) {
@@ -97,23 +188,29 @@ export function takeoverLoopAttempt(input) {
         }
         catch { /* immutable close cell already fences the old run */ }
     }
-    ensureAgentRunProjection({
-        id: takeover.next_generation.run_id,
-        short_label: takeover.next_generation.run_id,
-        assignment_id: takeover.next_generation.assignment_id,
-        claim_id: reservation.claim_id,
-        attempt_index: takeover.next_generation.attempt_epoch + 1,
-        agent: reservation.agent,
-        agent_id: reservation.agent_id,
-        transport: 'cli_spawn',
-        status: 'created',
-        scope: assignment?.scope ?? reservation.execution_contract?.workspace_policy.scope ?? reservation.cwd,
-        description: assignment?.description ?? `Attempt generation ${takeover.next_generation.attempt_epoch} for ${input.turn_id}`,
-        worktree_path: takeover.next_generation.workspace_path,
-        execution_contract_ref: takeover.execution_contract_ref,
-        capability_snapshot: reservation.capability_snapshot,
-        tags: ['turn-owned', 'loop', 'attempt-takeover', `attempt-generation:${takeover.next_generation.attempt_epoch}`],
-    }, input.cwd);
+    try {
+        ensureAgentRunProjection({
+            id: takeover.next_generation.run_id,
+            short_label: takeover.next_generation.run_id,
+            assignment_id: takeover.next_generation.assignment_id,
+            claim_id: executor.claim_id,
+            attempt_index: takeover.next_generation.attempt_epoch + 1,
+            agent: executor.agent,
+            agent_id: executor.agent_id,
+            transport: 'cli_spawn',
+            status: 'created',
+            scope: assignment?.scope ?? reservation.execution_contract?.workspace_policy.scope ?? reservation.cwd,
+            description: assignment?.description ?? `Attempt generation ${takeover.next_generation.attempt_epoch} for ${input.turn_id}`,
+            worktree_path: takeover.next_generation.workspace_path,
+            execution_contract_ref: takeover.execution_contract_ref,
+            capability_snapshot: executor.capability_snapshot,
+            tags: ['turn-owned', 'loop', 'attempt-takeover', `attempt-generation:${takeover.next_generation.attempt_epoch}`],
+        }, input.cwd);
+        input.on_stage?.('run_projected');
+    }
+    catch (error) {
+        throw new AttemptTakeoverCommittedError(takeover, error);
+    }
     try {
         createRuntimeEvent({
             agent: input.actor,

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