brainclaw 0.29.2 → 1.5.4

package/dist/commands/list-claims.js

@@ -1,11 +1,40 @@
 import { memoryExists } from '../core/io.js';
-import { listClaims } from '../core/claims.js';
+import { listClaims, expireStaleActiveClaims, isClaimExpired, assessClaimLiveness } from '../core/claims.js';
+import { resolveStoreChain } from '../core/store-resolution.js';
 export function runListClaims(options = {}) {
     if (!memoryExists(options.cwd)) {
         console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
         process.exit(1);
     }
-    let claims = listClaims(options.cwd);
+    const effectiveCwd = options.cwd ?? process.cwd();
+    // Auto-expire claims whose TTL has passed before listing (local store only — writes are always local)
+    expireStaleActiveClaims(options.cwd);
+    let claims;
+    if (options.localOnly) {
+        claims = listClaims(options.cwd);
+    }
+    else {
+        const chain = resolveStoreChain(effectiveCwd);
+        const seenIds = new Set();
+        claims = [];
+        for (const store of chain) {
+            try {
+                // Expire stale claims in each parent store too
+                expireStaleActiveClaims(store.cwd);
+                for (const claim of listClaims(store.cwd)) {
+                    if (!seenIds.has(claim.id)) {
+                        seenIds.add(claim.id);
+                        claims.push(claim);
+                    }
+                }
+            }
+            catch { /* skip unreadable stores */ }
+        }
+        // Fallback when no chain found
+        if (claims.length === 0 && chain.length === 0) {
+            claims = listClaims(options.cwd);
+        }
+    }
     if (!options.all) {
         claims = claims.filter(c => c.status === 'active');
     }
@@ -30,6 +59,7 @@ export function runListClaims(options = {}) {
     console.log(`${claims.length} ${label}:`);
     console.log('');
     for (const c of claims) {
+        const expired = isClaimExpired(c) ? ' [EXPIRED]' : '';
         const status = c.status !== 'active' ? ` (${c.status})` : '';
         const extras = [];
         if (c.session_id)
@@ -38,8 +68,23 @@ export function runListClaims(options = {}) {
             extras.push(`plan ${c.plan_id}`);
         if (c.project)
             extras.push(`project ${c.project}`);
+        if (c.expires_at && !isClaimExpired(c))
+            extras.push(`expires ${c.expires_at.slice(0, 16).replace('T', ' ')}`);
         const suffix = extras.length ? ` [${extras.join(', ')}]` : '';
-        console.log(`  [${c.id}] ${c.agent} → ${c.scope}: ${c.description}${suffix}${status}`);
+        // Liveness tag for active claims (omit for released/done)
+        let livenessTag = '';
+        if (c.status === 'active') {
+            const liveness = assessClaimLiveness(c, { cwd: options.cwd });
+            if (liveness.status === 'live')
+                livenessTag = ' [LIVE]';
+            else if (liveness.status === 'orphaned')
+                livenessTag = ' [ORPHANED]';
+            else if (liveness.status === 'never-adopted')
+                livenessTag = ' [NEVER-ADOPTED]';
+            else if (liveness.status === 'stale')
+                livenessTag = ' [STALE]';
+        }
+        console.log(`  [${c.id}] ${c.agent} → ${c.scope}: ${c.description}${suffix}${livenessTag}${status}${expired}`);
     }
 }
 //# sourceMappingURL=list-claims.js.map

package/dist/commands/list-plans.js

@@ -1,48 +1,152 @@
+import path from 'node:path';
 import { loadState } from '../core/state.js';
 import { memoryExists } from '../core/io.js';
-export function runListPlans(options = {}) {
-    if (!memoryExists(options.cwd)) {
-        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
-        process.exit(1);
-    }
-    let plans = loadState(options.cwd).plan_items;
+import { resolveStoreChain } from '../core/store-resolution.js';
+import { scanNestedBrainclawProjects } from '../core/workspace-projects.js';
+function filterPlans(plans, options) {
+    let filtered = plans;
     if (!options.all) {
-        plans = plans.filter((plan) => plan.status !== 'done' && plan.status !== 'dropped');
+        filtered = filtered.filter((plan) => plan.status !== 'done' && plan.status !== 'dropped');
     }
     if (options.status) {
-        plans = plans.filter((plan) => plan.status === options.status);
+        filtered = filtered.filter((plan) => plan.status === options.status);
     }
     if (options.type) {
-        plans = plans.filter((plan) => plan.type === options.type);
+        filtered = filtered.filter((plan) => plan.type === options.type);
     }
     if (options.assignee) {
         const target = options.assignee.toLowerCase();
-        plans = plans.filter((plan) => plan.assignee?.toLowerCase() === target);
+        filtered = filtered.filter((plan) => plan.assignee?.toLowerCase() === target);
     }
     if (options.project) {
         const project = options.project.toLowerCase();
-        plans = plans.filter((plan) => plan.project?.toLowerCase() === project);
+        filtered = filtered.filter((plan) => plan.project?.toLowerCase() === project);
+    }
+    return filtered;
+}
+function formatPlan(plan) {
+    const meta = [plan.type ?? 'feat', plan.status, plan.priority];
+    if (plan.assignee)
+        meta.push(`assignee ${plan.assignee}`);
+    if (plan.project)
+        meta.push(`project ${plan.project}`);
+    if (plan.depends_on.length > 0)
+        meta.push(`depends_on ${plan.depends_on.join(',')}`);
+    const tags = plan.tags.length ? ` [${plan.tags.join(', ')}]` : '';
+    return `  [${plan.id}] ${plan.text} (${meta.join(' · ')})${tags}`;
+}
+export function scanDescendantPlans(cwd, options) {
+    const resolvedCwd = path.resolve(cwd ?? process.cwd());
+    const descendants = scanNestedBrainclawProjects(resolvedCwd);
+    const groups = [];
+    // In recursive mode, --project filters by descendant project name/path, not plan.project field
+    const projectFilter = options.project?.toLowerCase();
+    const filterOpts = { ...options, project: undefined };
+    for (const project of descendants) {
+        const relativePath = path.relative(resolvedCwd, project.path);
+        const projectName = project.project_name?.toLowerCase();
+        const relLower = relativePath.toLowerCase();
+        const baseLower = path.basename(project.path).toLowerCase();
+        if (projectFilter && projectName !== projectFilter && relLower !== projectFilter && baseLower !== projectFilter) {
+            continue;
+        }
+        try {
+            const plans = filterPlans(loadState(project.path).plan_items, filterOpts);
+            if (plans.length > 0) {
+                groups.push({
+                    path: project.path,
+                    relative_path: relativePath,
+                    project_name: project.project_name,
+                    plans,
+                });
+            }
+        }
+        catch { /* skip unreadable project */ }
+    }
+    return groups;
+}
+export function runListPlans(options = {}) {
+    if (!memoryExists(options.cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const effectiveCwd = options.cwd ?? process.cwd();
+    let rawPlans;
+    if (options.localOnly) {
+        rawPlans = loadState(options.cwd).plan_items;
+    }
+    else {
+        const chain = resolveStoreChain(effectiveCwd);
+        const seenIds = new Set();
+        rawPlans = [];
+        for (const store of chain) {
+            try {
+                for (const plan of loadState(store.cwd).plan_items) {
+                    if (!seenIds.has(plan.id)) {
+                        seenIds.add(plan.id);
+                        rawPlans.push(plan);
+                    }
+                }
+            }
+            catch { /* skip unreadable stores */ }
+        }
+        // Fallback when no chain found (should not happen if memoryExists passed)
+        if (rawPlans.length === 0 && chain.length === 0) {
+            rawPlans = loadState(options.cwd).plan_items;
+        }
+    }
+    const localPlans = filterPlans(rawPlans, options);
+    if (options.recursive) {
+        const cwd = options.cwd ?? process.cwd();
+        const descendantGroups = scanDescendantPlans(cwd, options);
+        const totalDescendantPlans = descendantGroups.reduce((sum, g) => sum + g.plans.length, 0);
+        if (options.json) {
+            console.log(JSON.stringify({
+                local: localPlans,
+                descendants: descendantGroups,
+                total: localPlans.length + totalDescendantPlans,
+            }, null, 2));
+            return;
+        }
+        // Local plans
+        console.log(`── local (${localPlans.length} plans) ──`);
+        if (localPlans.length === 0) {
+            console.log('  (none)');
+        }
+        else {
+            for (const plan of localPlans)
+                console.log(formatPlan(plan));
+        }
+        // Descendant plans
+        for (const group of descendantGroups) {
+            const label = group.project_name ?? group.relative_path;
+            console.log(`\n── ${label} (${group.plans.length} plans) ──`);
+            for (const plan of group.plans)
+                console.log(formatPlan(plan));
+        }
+        if (localPlans.length === 0 && totalDescendantPlans === 0) {
+            console.log('\nNo plan items found locally or in descendants.');
+        }
+        return;
     }
     if (options.json) {
-        console.log(JSON.stringify(plans, null, 2));
+        console.log(JSON.stringify(localPlans, null, 2));
         return;
     }
-    if (plans.length === 0) {
+    if (localPlans.length === 0) {
+        // Check descendants for signal
+        const cwd = options.cwd ?? process.cwd();
+        const descendantGroups = scanDescendantPlans(cwd, options);
+        const totalDescendantPlans = descendantGroups.reduce((sum, g) => sum + g.plans.length, 0);
         console.log('No plan items found.');
+        if (totalDescendantPlans > 0) {
+            console.log(`ℹ ${totalDescendantPlans} plan(s) found in ${descendantGroups.length} descendant project(s) (use --recursive to see all)`);
+        }
         return;
     }
-    console.log(`${plans.length} plan item(s):`);
+    console.log(`${localPlans.length} plan item(s):`);
     console.log('');
-    for (const plan of plans) {
-        const meta = [plan.type ?? 'feat', plan.status, plan.priority];
-        if (plan.assignee)
-            meta.push(`assignee ${plan.assignee}`);
-        if (plan.project)
-            meta.push(`project ${plan.project}`);
-        if (plan.depends_on.length > 0)
-            meta.push(`depends_on ${plan.depends_on.join(',')}`);
-        const tags = plan.tags.length ? ` [${plan.tags.join(', ')}]` : '';
-        console.log(`  [${plan.id}] ${plan.text} (${meta.join(' · ')})${tags}`);
-    }
+    for (const plan of localPlans)
+        console.log(formatPlan(plan));
 }
 //# sourceMappingURL=list-plans.js.map

package/dist/commands/loops-handlers.js

@@ -0,0 +1,409 @@
+import { ZodError } from 'zod';
+import { listAgentRuns } from '../core/agentruns.js';
+import { reconcileAgentRun } from '../core/agentrun-reconciler.js';
+import { add_artifact, advance, closeLoop, complete_turn, getLoop, IdempotencyKeyReusedError, IdempotencyOwnerMismatchError, listLoopEvents, listLoops, LockLostError, LockTimeoutError, openLoop, pause, resume, turn, VersionConflictError, withLoopLock, } from '../core/loops/index.js';
+import { BclawLoopRequestSchema, BCLAW_LOOP_INTENTS, } from '../core/loops/facade-schema.js';
+function resolveActor(req, defaultActor) {
+    const agentId = req.agentId?.trim() || defaultActor;
+    const actor = req.agent?.trim() || req.agentId?.trim() || defaultActor;
+    return { actor, agentId };
+}
+function successResponse(intent, result, artifacts, side_effects, warnings, durationMs, summary) {
+    return {
+        response: {
+            status: 'ok',
+            intent: `bclaw_loop.${intent}`,
+            result,
+            artifacts,
+            side_effects,
+            warnings,
+            duration_ms: durationMs,
+        },
+        summary,
+    };
+}
+function errorResponse(intent, code, message, durationMs, result = null) {
+    return {
+        response: {
+            status: 'error',
+            intent: `bclaw_loop.${intent}`,
+            result,
+            artifacts: [],
+            side_effects: [],
+            warnings: [],
+            error: `${code}: ${message}`,
+            duration_ms: durationMs,
+        },
+        summary: `✘ bclaw_loop[${intent}] ${code}: ${message}`,
+    };
+}
+function inferIntent(args) {
+    if (!args || typeof args !== 'object')
+        return 'unknown';
+    const candidate = args.intent;
+    if (typeof candidate !== 'string')
+        return 'unknown';
+    return BCLAW_LOOP_INTENTS.includes(candidate)
+        ? candidate
+        : 'unknown';
+}
+function loopArtifactEntry(id) {
+    return { type: 'loop', id };
+}
+function loopEventArtifactEntry(id) {
+    return { type: 'loop_event', id };
+}
+function sideEffectCreate(entity, id) {
+    return { action: 'create', entity, id };
+}
+function sideEffectUpdate(entity, id) {
+    return { action: 'update', entity, id };
+}
+function snapshotLoopEvents(loopId, cwd) {
+    return new Set(listLoopEvents(loopId, cwd).map((event) => event.event_id));
+}
+function findNewLoopEvents(loopId, before, cwd) {
+    const events = listLoopEvents(loopId, cwd);
+    if (!before)
+        return events;
+    return events.filter((event) => !before.has(event.event_id));
+}
+function loopEventArtifacts(events) {
+    return events.map((event) => loopEventArtifactEntry(event.event_id));
+}
+function loopEventSideEffects(events) {
+    return events.map((event) => sideEffectCreate('loop_event', event.event_id));
+}
+function validateSemanticRequest(req) {
+    if (req.intent === 'turn' && !req.slot_id && !req.role) {
+        return 'turn requires slot_id or role';
+    }
+    return null;
+}
+function requestPayload(req) {
+    const { agent, agentId, client_request_id, ...rest } = req;
+    return rest;
+}
+function currentLoopVersion(loopId, cwd) {
+    return getLoop(loopId, cwd)?.version ?? 0;
+}
+/**
+ * Slot-bound intents must not let a cached idempotent response leak to a
+ * different caller. `complete_turn` is the obvious case: it carries auth
+ * semantics (caller_agent_id must match the slot owner or loop.created_by).
+ * Without caller-match enforcement on the idempotency cache, a second caller
+ * who learned the client_request_id could replay it and receive the cached
+ * success payload — bypassing slot-bound auth from an information-disclosure
+ * perspective even though the state change already happened. Intents listed
+ * here get `requireCallerMatch: true` on their withLoopLock invocation.
+ */
+const SLOT_BOUND_INTENTS = new Set(['complete_turn']);
+/**
+ * Fence-check discipline for mutations.
+ *
+ * The `work` callback calls `fenceCheck()` at entry before invoking the verb.
+ * This closes the "lock acquired, then reaped mid-wait, then foreign writer
+ * took over" window — the verb will not proceed if the lock's mutation_id
+ * changed between `acquireLock` and `work` dispatch. It does NOT cover mid-verb
+ * fs operations: the verbs themselves (`openLoop`, `advance`, …) perform their
+ * atomic-rename + JSONL append without consulting the fence. That gap is
+ * intentional for the MVP because the verbs are synchronous and complete in
+ * single-digit milliseconds, much shorter than any reasonable hard_deadline
+ * (default 30_000 ms). If a future slice adds async dispatch inside a
+ * mutation, thread `fenceCheck` down into the verb and call it before each
+ * committing write.
+ */
+function withLockedLoopMutation(req, agentId, cwd, work) {
+    return withLoopLock({
+        cwd,
+        intent: req.intent,
+        agentId,
+        scope: { kind: 'loop', loopId: req.loop_id },
+        expectedVersion: req.expected_version,
+        clientRequestId: req.client_request_id,
+        requestPayload: requestPayload(req),
+        currentVersion: () => currentLoopVersion(req.loop_id, cwd),
+        requireCallerMatch: SLOT_BOUND_INTENTS.has(req.intent),
+        work: ({ fenceCheck }) => {
+            // Best-effort fence at entry; see SLOT_BOUND_INTENTS / fence-check
+            // discipline comment above for why mid-verb re-checks are deferred.
+            fenceCheck();
+            return work();
+        },
+    });
+}
+/**
+ * `NextExpectedHint` — self-describing hint to the caller about the most
+ * natural next intent. Kept conservative for the MVP: we look at the loop's
+ * status + slot states and pick the smallest correct action.
+ */
+function computeNextExpected(loop) {
+    if (loop.status === 'completed' || loop.status === 'cancelled' || loop.status === 'blocked') {
+        return null;
+    }
+    if (loop.status === 'paused') {
+        return null;
+    }
+    const currentPhaseSlots = loop.slots.filter((s) => (s.phase ?? loop.current_phase) === loop.current_phase);
+    const openSlots = currentPhaseSlots.filter((s) => s.status === 'open');
+    if (openSlots.length > 0) {
+        const first = openSlots[0];
+        return {
+            action: 'turn',
+            intent: 'bclaw_loop.turn',
+            phase: loop.current_phase,
+            slot_id: first.slot_id,
+            role: first.role,
+            blocking_on: openSlots.map((s) => s.slot_id),
+        };
+    }
+    const assignedOrWorking = currentPhaseSlots.filter((s) => s.status === 'assigned' || s.status === 'working');
+    if (assignedOrWorking.length > 0) {
+        return {
+            action: 'complete_turn',
+            intent: 'bclaw_loop.complete_turn',
+            phase: loop.current_phase,
+            slot_id: assignedOrWorking[0].slot_id,
+            role: assignedOrWorking[0].role,
+            blocking_on: assignedOrWorking.map((s) => s.slot_id),
+        };
+    }
+    const phaseNames = loop.phases.map((p) => p.name);
+    const currentIndex = phaseNames.indexOf(loop.current_phase);
+    if (currentIndex >= 0 && currentIndex + 1 < phaseNames.length) {
+        return {
+            action: 'advance',
+            intent: 'bclaw_loop.advance',
+            from_phase: loop.current_phase,
+            to_phase: phaseNames[currentIndex + 1],
+            blocking_on: [],
+        };
+    }
+    return {
+        action: 'close',
+        intent: 'bclaw_loop.close',
+        reason: 'terminal_phase_reached',
+        blocking_on: [],
+    };
+}
+function summarizeLoop(loop, autoClosed) {
+    const suffix = autoClosed ? ' (auto-closed)' : '';
+    return `✔ loop ${loop.id} [${loop.kind}] phase=${loop.current_phase} status=${loop.status}${suffix}`;
+}
+export function handleBclawLoop(options) {
+    const startMs = Date.now();
+    const defaultActor = options.defaultActor ?? 'bclaw_loop';
+    const inferredIntent = inferIntent(options.args);
+    const parseResult = BclawLoopRequestSchema.safeParse(options.args);
+    if (!parseResult.success) {
+        return errorResponse(inferredIntent, 'validation_error', parseResult.error.message, Date.now() - startMs);
+    }
+    const req = parseResult.data;
+    const semanticError = validateSemanticRequest(req);
+    if (semanticError) {
+        return errorResponse(req.intent, 'validation_error', semanticError, Date.now() - startMs);
+    }
+    const { actor, agentId } = resolveActor(req, defaultActor);
+    try {
+        switch (req.intent) {
+            case 'open': {
+                if (!req.allow_orphan) {
+                    return errorResponse('open', 'validation_error', "Direct bclaw_loop(intent='open') creates a loop with no dispatch — no claim, no inbox message, no agent will pick up the work. Use bclaw_coordinate(intent='review', open_loop=true) for review loops (recommended), or pass allow_orphan: true to acknowledge that you will handle turn() + dispatch manually (advanced/test use only). See CLAUDE.md anti-pattern note and pln#461.", Date.now() - startMs);
+                }
+                const runOpen = () => {
+                    const loop = openLoop({
+                        kind: req.kind,
+                        title: req.title,
+                        goal: req.goal,
+                        phases: req.phases,
+                        slots: req.slots,
+                        linked: req.linked,
+                        stop_condition: req.stop_condition,
+                        mode: req.mode,
+                        created_by: agentId,
+                    }, options.cwd);
+                    const newEvents = findNewLoopEvents(loop.id, undefined, options.cwd);
+                    return successResponse('open', { loop, next_expected: computeNextExpected(loop) }, [loopArtifactEntry(loop.id), ...loopEventArtifacts(newEvents)], [sideEffectCreate('loop', loop.id), ...loopEventSideEffects(newEvents)], [], Date.now() - startMs, `✔ opened ${loop.id} [${loop.kind}] phase=${loop.current_phase}`);
+                };
+                if (!req.client_request_id) {
+                    return runOpen();
+                }
+                return withLoopLock({
+                    cwd: options.cwd,
+                    intent: req.intent,
+                    agentId,
+                    scope: { kind: 'open_idempotency', clientRequestId: req.client_request_id },
+                    clientRequestId: req.client_request_id,
+                    requestPayload: requestPayload(req),
+                    loopIdForIdempotency: undefined,
+                    work: () => runOpen(),
+                });
+            }
+            case 'get': {
+                const loop = getLoop(req.loop_id, options.cwd);
+                if (!loop) {
+                    return errorResponse('get', 'not_found', `unknown loop_id ${req.loop_id}`, Date.now() - startMs);
+                }
+                // pln#496 Phase 2: reconcile each slot's assigned run before
+                // returning the loop. Catches the silent-completion case where a
+                // dispatched reviewer committed work / released their claim but
+                // never emitted run_completed — the loop appeared stuck on
+                // 'assigned' slots forever in May 2026 (lop_3b2068e25166e183 +
+                // lop_ea5852302acb8cbb). Targeted to slots with assignment_id so
+                // we never run a broad scan here.
+                try {
+                    for (const slot of loop.slots ?? []) {
+                        const slotStatus = slot.status;
+                        const assignmentId = slot.assignment_id;
+                        if (!assignmentId)
+                            continue;
+                        if (slotStatus === 'done' || slotStatus === 'failed' || slotStatus === 'cancelled')
+                            continue;
+                        for (const run of listAgentRuns(options.cwd, { assignment_id: assignmentId })) {
+                            reconcileAgentRun(run.id, options.cwd);
+                        }
+                    }
+                }
+                catch { /* defensive: never block loop reads on reconcile errors */ }
+                // Re-load the loop after reconciliation so any slot transitions
+                // triggered by the reconciler (e.g. via assignment lifecycle hooks)
+                // are reflected in the response. Cheap (fs read).
+                const reconciledLoop = getLoop(req.loop_id, options.cwd) ?? loop;
+                const events = req.include_events ? listLoopEvents(req.loop_id, options.cwd) : undefined;
+                return successResponse('get', { loop: reconciledLoop, events, next_expected: computeNextExpected(reconciledLoop) }, [loopArtifactEntry(reconciledLoop.id)], [], [], Date.now() - startMs, summarizeLoop(reconciledLoop));
+            }
+            case 'list': {
+                const loops = listLoops({ kind: req.kind, status: req.status }, options.cwd);
+                const sliced = typeof req.offset === 'number' || typeof req.limit === 'number'
+                    ? loops.slice(req.offset ?? 0, (req.offset ?? 0) + (req.limit ?? loops.length))
+                    : loops;
+                return successResponse('list', { loops: sliced, total: loops.length }, sliced.map((l) => loopArtifactEntry(l.id)), [], [], Date.now() - startMs, `✔ list ${sliced.length}/${loops.length} loops`);
+            }
+            case 'turn': {
+                return withLockedLoopMutation(req, agentId, options.cwd, () => {
+                    const beforeEvents = snapshotLoopEvents(req.loop_id, options.cwd);
+                    const loop = turn({
+                        id: req.loop_id,
+                        slot_id: req.slot_id,
+                        role: req.role,
+                        input: req.input,
+                        dispatch: req.dispatch,
+                        assignment_id: req.assignment_id,
+                        actor,
+                    }, options.cwd);
+                    const newEvents = findNewLoopEvents(loop.id, beforeEvents, options.cwd);
+                    return successResponse('turn', { loop, next_expected: computeNextExpected(loop) }, [loopArtifactEntry(loop.id), ...loopEventArtifacts(newEvents)], [sideEffectUpdate('loop', loop.id), ...loopEventSideEffects(newEvents)], [], Date.now() - startMs, summarizeLoop(loop));
+                });
+            }
+            case 'complete_turn': {
+                return withLockedLoopMutation(req, agentId, options.cwd, () => {
+                    const beforeEvents = snapshotLoopEvents(req.loop_id, options.cwd);
+                    const loop = complete_turn({
+                        id: req.loop_id,
+                        slot_id: req.slot_id,
+                        outcome: req.outcome,
+                        failure_reason: req.failure_reason,
+                        artifact: req.artifact
+                            ? {
+                                phase: req.artifact.phase,
+                                type: req.artifact.type,
+                                body: req.artifact.body,
+                                ref: req.artifact.ref,
+                            }
+                            : undefined,
+                        actor,
+                        caller_agent_id: req.agentId,
+                    }, options.cwd);
+                    const newEvents = findNewLoopEvents(loop.id, beforeEvents, options.cwd);
+                    return successResponse('complete_turn', { loop, next_expected: computeNextExpected(loop) }, [loopArtifactEntry(loop.id), ...loopEventArtifacts(newEvents)], [sideEffectUpdate('loop', loop.id), ...loopEventSideEffects(newEvents)], [], Date.now() - startMs, summarizeLoop(loop));
+                });
+            }
+            case 'advance': {
+                return withLockedLoopMutation(req, agentId, options.cwd, () => {
+                    const beforeEvents = snapshotLoopEvents(req.loop_id, options.cwd);
+                    const result = advance({
+                        id: req.loop_id,
+                        to_phase: req.to_phase,
+                        reason: req.reason,
+                        force: req.force,
+                        actor,
+                    }, options.cwd);
+                    const newEvents = findNewLoopEvents(result.loop.id, beforeEvents, options.cwd);
+                    return successResponse('advance', { loop: result.loop, auto_closed: result.auto_closed, next_expected: computeNextExpected(result.loop) }, [loopArtifactEntry(result.loop.id), ...loopEventArtifacts(newEvents)], [sideEffectUpdate('loop', result.loop.id), ...loopEventSideEffects(newEvents)], [], Date.now() - startMs, summarizeLoop(result.loop, result.auto_closed));
+                });
+            }
+            case 'add_artifact': {
+                return withLockedLoopMutation(req, agentId, options.cwd, () => {
+                    const beforeEvents = snapshotLoopEvents(req.loop_id, options.cwd);
+                    const loop = add_artifact({
+                        id: req.loop_id,
+                        artifact: {
+                            phase: req.artifact.phase,
+                            type: req.artifact.type,
+                            body: req.artifact.body,
+                            produced_by: req.artifact.produced_by,
+                            ref: req.artifact.ref,
+                        },
+                        actor,
+                    }, options.cwd);
+                    const newEvents = findNewLoopEvents(loop.id, beforeEvents, options.cwd);
+                    return successResponse('add_artifact', { loop, next_expected: computeNextExpected(loop) }, [loopArtifactEntry(loop.id), ...loopEventArtifacts(newEvents)], [sideEffectUpdate('loop', loop.id), ...loopEventSideEffects(newEvents)], [], Date.now() - startMs, summarizeLoop(loop));
+                });
+            }
+            case 'pause': {
+                return withLockedLoopMutation(req, agentId, options.cwd, () => {
+                    const beforeEvents = snapshotLoopEvents(req.loop_id, options.cwd);
+                    const loop = pause({ id: req.loop_id, reason: req.reason, actor }, options.cwd);
+                    const newEvents = findNewLoopEvents(loop.id, beforeEvents, options.cwd);
+                    return successResponse('pause', { loop, next_expected: null }, [loopArtifactEntry(loop.id), ...loopEventArtifacts(newEvents)], [sideEffectUpdate('loop', loop.id), ...loopEventSideEffects(newEvents)], [], Date.now() - startMs, summarizeLoop(loop));
+                });
+            }
+            case 'resume': {
+                return withLockedLoopMutation(req, agentId, options.cwd, () => {
+                    const beforeEvents = snapshotLoopEvents(req.loop_id, options.cwd);
+                    const loop = resume({ id: req.loop_id, actor }, options.cwd);
+                    const newEvents = findNewLoopEvents(loop.id, beforeEvents, options.cwd);
+                    return successResponse('resume', { loop, next_expected: computeNextExpected(loop) }, [loopArtifactEntry(loop.id), ...loopEventArtifacts(newEvents)], [sideEffectUpdate('loop', loop.id), ...loopEventSideEffects(newEvents)], [], Date.now() - startMs, summarizeLoop(loop));
+                });
+            }
+            case 'close': {
+                return withLockedLoopMutation(req, agentId, options.cwd, () => {
+                    const beforeEvents = snapshotLoopEvents(req.loop_id, options.cwd);
+                    const loop = closeLoop({ id: req.loop_id, final_status: req.status, reason: req.reason, actor }, options.cwd);
+                    const newEvents = findNewLoopEvents(loop.id, beforeEvents, options.cwd);
+                    return successResponse('close', { loop, next_expected: null }, [loopArtifactEntry(loop.id), ...loopEventArtifacts(newEvents)], [sideEffectUpdate('loop', loop.id), ...loopEventSideEffects(newEvents)], [], Date.now() - startMs, summarizeLoop(loop));
+                });
+            }
+        }
+    }
+    catch (err) {
+        if (err instanceof ZodError) {
+            return errorResponse(req.intent, 'validation_error', err.message, Date.now() - startMs);
+        }
+        if (err instanceof VersionConflictError) {
+            return errorResponse(req.intent, 'version_conflict', `expected=${err.expected} actual=${err.actual}`, Date.now() - startMs, { actual_version: err.actual });
+        }
+        if (err instanceof IdempotencyKeyReusedError) {
+            return errorResponse(req.intent, 'idempotency_key_reused_with_different_body', `stored_hash=${err.storedHash} submitted_hash=${err.submittedHash}`, Date.now() - startMs, { stored_hash: err.storedHash, submitted_hash: err.submittedHash });
+        }
+        if (err instanceof IdempotencyOwnerMismatchError) {
+            return errorResponse(req.intent, 'idempotency_owner_mismatch', `stored_owner=${err.storedOwner ?? 'unknown'} submitted_owner=${err.submittedOwner}`, Date.now() - startMs, { stored_owner: err.storedOwner, submitted_owner: err.submittedOwner });
+        }
+        if (err instanceof LockTimeoutError) {
+            return errorResponse(req.intent, 'lock_timeout', err.message, Date.now() - startMs);
+        }
+        if (err instanceof LockLostError) {
+            return errorResponse(req.intent, 'lock_lost', err.message, Date.now() - startMs);
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes('unauthorized_slot_write')) {
+            return errorResponse(req.intent, 'unauthorized_slot_write', message, Date.now() - startMs);
+        }
+        if (message.startsWith('unknown loop_id')) {
+            return errorResponse(req.intent, 'not_found', message, Date.now() - startMs);
+        }
+        return errorResponse(req.intent, 'verb_error', message, Date.now() - startMs);
+    }
+    return errorResponse('unknown', 'unreachable', 'unexpected fallthrough', Date.now() - startMs);
+}
+//# sourceMappingURL=loops-handlers.js.map