brainclaw 1.5.5 → 1.6.0

package/dist/commands/loops-handlers.js

@@ -1,8 +1,11 @@
 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 { add_artifact, advance, AwaitingFileApplyApprovalError, closeLoop, complete_turn, computeNextExpected, getLoop, IdempotencyKeyReusedError, IdempotencyOwnerMismatchError, listLoopEvents, listLoops, LockLostError, LockTimeoutError, openLoop, pause, provideInput, requestInput, resume, sweepPauseTimeouts, turn, VersionConflictError, withLoopLock, } from '../core/loops/index.js';
 import { BclawLoopRequestSchema, BCLAW_LOOP_INTENTS, } from '../core/loops/facade-schema.js';
+// NextExpectedHint type now lives in src/core/loops/next-expected.ts
+// (hoisted per can_e57c7782 follow-up so MCP facade + CLI share the
+// same contract). Imported above.
 function resolveActor(req, defaultActor) {
     const agentId = req.agentId?.trim() || defaultActor;
     const actor = req.agent?.trim() || req.agentId?.trim() || defaultActor;
@@ -128,68 +131,51 @@ function withLockedLoopMutation(req, agentId, cwd, work) {
             // Best-effort fence at entry; see SLOT_BOUND_INTENTS / fence-check
             // discipline comment above for why mid-verb re-checks are deferred.
             fenceCheck();
+            // pln#508 step 3 follow-up (can_810ff9ec): run the timeout sweep
+            // INSIDE the loop lock for mutating intents. Previously the sweep
+            // ran at facade entry (before lock acquisition), which could race
+            // with concurrent writers and turn the caller's expected_version
+            // into a sweep-induced version_conflict. Now: sweep writes happen
+            // under the same lock as the caller's verb — single-writer
+            // serialization preserved. If the sweep bumps the version, the
+            // caller's verb sees the post-sweep state (e.g. their question
+            // already timed out → provide_input legitimately returns
+            // unknown_question, which is correct semantics).
+            trySweepLoopTimeouts(req.loop_id, cwd);
             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: [],
-    };
-}
+// computeNextExpected lives in src/core/loops/next-expected.ts (hoisted
+// per can_e57c7782 follow-up — same contract is now shared by both the
+// MCP facade here and the CLI `brainclaw reply` command).
 function summarizeLoop(loop, autoClosed) {
     const suffix = autoClosed ? ' (auto-closed)' : '';
     return `✔ loop ${loop.id} [${loop.kind}] phase=${loop.current_phase} status=${loop.status}${suffix}`;
 }
+/**
+ * pln#508 step 3 — lazy pause-timeout reconcile at facade entry.
+ *
+ * Phase 0 spec §6: any time the facade is invoked against a loop_id, sweep
+ * the target loop for timed-out operator_question artifacts BEFORE
+ * dispatching the intent. The downstream verb then sees the corrected state
+ * (e.g. a `cancel_loop` timeout already fired → mutating intents will get
+ * the natural `already cancelled` error from assertMutable; a `use_default`
+ * timeout already fired → open_questions reflects the synthesized answer).
+ *
+ * Best-effort: wrapped in try/catch so any reconcile error (corrupt loop on
+ * disk, fs hiccup, …) never blocks the facade. The handler proceeds with
+ * stale state in that case, which is no worse than the pre-step-3 behavior.
+ *
+ * Mirrors the lazy-reconcile pattern used by `agentrun-reconciler.ts` for
+ * agent_run silent completion (see entity-operations.ts loadAgentRunsWithReconciliation).
+ */
+function trySweepLoopTimeouts(loop_id, cwd) {
+    try {
+        sweepPauseTimeouts(loop_id, undefined, cwd);
+    }
+    catch { /* best-effort: never block facade on sweep errors */ }
+}
 export function handleBclawLoop(options) {
     const startMs = Date.now();
     const defaultActor = options.defaultActor ?? 'bclaw_loop';
@@ -204,6 +190,15 @@ export function handleBclawLoop(options) {
         return errorResponse(req.intent, 'validation_error', semanticError, Date.now() - startMs);
     }
     const { actor, agentId } = resolveActor(req, defaultActor);
+    // pln#508 step 3 — lazy pause-timeout reconcile at facade entry. Only
+    // for the `get` read-only intent (no withLockedLoopMutation wrapper).
+    // Mutating intents sweep INSIDE withLockedLoopMutation to keep all
+    // writes under the same loop lock as the caller's verb — see
+    // can_810ff9ec follow-up. `open` has no existing loop_id; `list`
+    // enumerates many loops (unbounded fan-out, not in scope).
+    if (req.intent === 'get' && typeof req.loop_id === 'string') {
+        trySweepLoopTimeouts(req.loop_id, options.cwd);
+    }
     try {
         switch (req.intent) {
             case 'open': {
@@ -309,6 +304,7 @@ export function handleBclawLoop(options) {
                                 type: req.artifact.type,
                                 body: req.artifact.body,
                                 ref: req.artifact.ref,
+                                addresses_critique: req.artifact.addresses_critique,
                             }
                             : undefined,
                         actor,
@@ -343,6 +339,7 @@ export function handleBclawLoop(options) {
                             body: req.artifact.body,
                             produced_by: req.artifact.produced_by,
                             ref: req.artifact.ref,
+                            addresses_critique: req.artifact.addresses_critique,
                         },
                         actor,
                     }, options.cwd);
@@ -366,6 +363,54 @@ export function handleBclawLoop(options) {
                     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 'request_input': {
+                return withLockedLoopMutation(req, agentId, options.cwd, () => {
+                    const beforeEvents = snapshotLoopEvents(req.loop_id, options.cwd);
+                    const result = requestInput({
+                        loop_id: req.loop_id,
+                        slot_id: req.slot_id,
+                        phase: req.phase,
+                        question_text: req.question_text,
+                        evidence: req.evidence,
+                        suggested_default: req.suggested_default,
+                        options: req.options,
+                        pause_scope: req.pause_scope,
+                        on_timeout: req.on_timeout,
+                        timeout_at: req.timeout_at,
+                        actor,
+                    }, options.cwd);
+                    const newEvents = findNewLoopEvents(result.thread.id, beforeEvents, options.cwd);
+                    return successResponse('request_input', {
+                        loop: result.thread,
+                        question_id: result.question_id,
+                        artifact_id: result.artifact_id,
+                        next_expected: computeNextExpected(result.thread),
+                    }, [loopArtifactEntry(result.thread.id), ...loopEventArtifacts(newEvents)], [sideEffectUpdate('loop', result.thread.id), ...loopEventSideEffects(newEvents)], [], Date.now() - startMs, summarizeLoop(result.thread));
+                });
+            }
+            case 'provide_input': {
+                return withLockedLoopMutation(req, agentId, options.cwd, () => {
+                    const beforeEvents = snapshotLoopEvents(req.loop_id, options.cwd);
+                    const result = provideInput({
+                        loop_id: req.loop_id,
+                        replies_to: req.replies_to,
+                        resolved_via: req.resolved_via,
+                        answer_text: req.answer_text,
+                        chosen_option_id: req.chosen_option_id,
+                        by: req.by,
+                        actor,
+                    }, options.cwd);
+                    const newEvents = findNewLoopEvents(result.thread.id, beforeEvents, options.cwd);
+                    return successResponse('provide_input', {
+                        loop: result.thread,
+                        artifact_id: result.artifact_id,
+                        duplicate: result.duplicate,
+                        next_expected: computeNextExpected(result.thread),
+                    }, [loopArtifactEntry(result.thread.id), ...loopEventArtifacts(newEvents)], [sideEffectUpdate('loop', result.thread.id), ...loopEventSideEffects(newEvents)], result.duplicate
+                        ? ['provide_input: idempotent replay — replies_to was already resolved; returning existing answer']
+                        : [], Date.now() - startMs, summarizeLoop(result.thread));
+                });
+            }
             case 'close': {
                 return withLockedLoopMutation(req, agentId, options.cwd, () => {
                     const beforeEvents = snapshotLoopEvents(req.loop_id, options.cwd);
@@ -395,6 +440,16 @@ export function handleBclawLoop(options) {
         if (err instanceof LockLostError) {
             return errorResponse(req.intent, 'lock_lost', err.message, Date.now() - startMs);
         }
+        if (err instanceof AwaitingFileApplyApprovalError) {
+            // pln#512 phase 3 codex review fix #1: surface structurally so callers
+            // can branch on the code without parsing the message text.
+            return errorResponse(req.intent, 'awaiting_file_apply_approval', err.message, Date.now() - startMs, {
+                loop_id: err.loop_id,
+                question_id: err.question_id,
+                target_path: err.target_path,
+                diff_artifact_id: err.diff_artifact_id,
+            });
+        }
         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);

package/dist/commands/mcp-read-handlers.js

@@ -13,6 +13,7 @@ import { listClaims, assessClaimLiveness } from '../core/claims.js';
 import { listAssignments } from '../core/assignments.js';
 import { listAgentRuns } from '../core/agentruns.js';
 import { reconcileAgentRun } from '../core/agentrun-reconciler.js';
+import { getDispatchStatus } from '../core/dispatch-status.js';
 import { listActionRequired } from '../core/actions.js';
 import { queryRuntimeEvents } from '../core/events.js';
 import { listSequences, getActiveSequence } from '../core/sequence.js';
@@ -1627,6 +1628,42 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
             structuredContent: { thread_id: threadId, total: messages.length, messages, schema_version: SCHEMA_VERSION },
         };
     }
+    if (name === 'bclaw_dispatch_status') {
+        const targetId = String(args.target_id ?? '');
+        if (!targetId) {
+            throw new Error('Missing required argument: target_id (asgn_/clm_/lop_/run_)');
+        }
+        const tailLogLines = typeof args.tail_log_lines === 'number' ? args.tail_log_lines : undefined;
+        const stallThresholdMs = typeof args.stall_threshold_ms === 'number' ? args.stall_threshold_ms : undefined;
+        const status = getDispatchStatus({
+            target_id: targetId,
+            cwd,
+            tail_log_lines: tailLogLines,
+            stall_threshold_ms: stallThresholdMs,
+        });
+        // Text view: short, single-screen summary so an agent can decide what to do
+        // without parsing the structured payload.
+        const lines = [
+            `Dispatch status for ${targetId} (resolved_from=${status.resolved_from})`,
+            `Health: ${status.diagnosis.health}`,
+            `Summary: ${status.diagnosis.summary}`,
+            `Next action: ${status.diagnosis.recommended_next_action}`,
+            '',
+            'Entities:',
+            `  assignment=${status.entities.assignment_id ?? '-'} (status=${status.assignment?.status ?? '-'})`,
+            `  claim=${status.entities.claim_id ?? '-'} (status=${status.claim?.status ?? '-'})`,
+            `  loop=${status.entities.loop_id ?? '-'} (phase=${status.loop?.current_phase ?? '-'})`,
+            `  run=${status.entities.run_id ?? '-'} (status=${status.agent_run?.status ?? '-'})`,
+            '',
+            `Runtime: pid=${status.runtime.pid ?? '-'} alive=${status.runtime.pid_alive ?? 'unknown'} ack=${status.runtime.ack_file.exists}`,
+            `  stdout: ${status.runtime.log_files.stdout?.exists ? `${status.runtime.log_files.stdout.size_bytes}B` : 'absent'}`,
+            `  stderr: ${status.runtime.log_files.stderr?.exists ? `${status.runtime.log_files.stderr.size_bytes}B` : 'absent'}`,
+        ];
+        return {
+            content: [{ type: 'text', text: lines.join('\n') }],
+            structuredContent: { ...status, schema_version: SCHEMA_VERSION },
+        };
+    }
     throw new Error(`Unknown read tool: ${name}`);
 }
 //# sourceMappingURL=mcp-read-handlers.js.map