brainclaw 1.8.0 → 1.9.1

package/dist/core/archival.js

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { resolveEntityDir } from './io.js';
 import { logger } from './logger.js';
+import { mutate } from './mutation-pipeline.js';
 /** Default age threshold: items older than 30 days are eligible for archival. */
 const DEFAULT_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
 /**
@@ -11,15 +12,20 @@ const DEFAULT_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
  * This is lossless — all data is preserved in the archive.
  */
 export function archiveStalePlansAndHandoffs(cwd, maxAgeMs = DEFAULT_MAX_AGE_MS) {
-    const results = [];
-    const cutoff = new Date(Date.now() - maxAgeMs).toISOString();
-    results.push(archiveEntity('plans', cutoff, (item) => {
-        return item.status === 'done' || item.status === 'dropped';
-    }, cwd));
-    results.push(archiveEntity('handoffs', cutoff, (item) => {
-        return item.status === 'closed';
-    }, cwd));
-    return results.filter(r => r.archived > 0);
+    // Review follow-up O4 (lop_e2d566765b8b4ce3): the append+unlink pairs must
+    // run inside the store mutation lock — outside it, a concurrent stale-snapshot
+    // persistState could RECREATE the just-archived files (resurrection).
+    return mutate({ cwd }, () => {
+        const results = [];
+        const cutoff = new Date(Date.now() - maxAgeMs).toISOString();
+        results.push(archiveEntity('plans', cutoff, (item) => {
+            return item.status === 'done' || item.status === 'dropped';
+        }, cwd));
+        results.push(archiveEntity('handoffs', cutoff, (item) => {
+            return item.status === 'closed';
+        }, cwd));
+        return results.filter(r => r.archived > 0);
+    });
 }
 function archiveEntity(entity, cutoffDate, isEligible, cwd) {
     const dir = resolveEntityDir(entity, cwd ?? process.cwd(), 'read');

package/dist/core/assignment-reconciler.js

@@ -0,0 +1,56 @@
+/**
+ * Lazy reconciler for orphaned review-loop assignments (pln#563, layer B).
+ *
+ * A review-loop assignment whose loop already reached a terminal status but
+ * which is itself still stuck in `offered`/`accepted`/`started` (the file-based
+ * worker never reported terminal; the coordinator couldn't cross-update it —
+ * trp#547) is converged on read. This is the house lazy-reconcile-at-read
+ * pattern (feedback_lazy_reconcile_pattern / pln#496): no daemon, convergence
+ * happens the next time open_work is computed.
+ *
+ * Layer A (the closeLoop cascade) handles the common path going forward; this
+ * backstop cleans the existing backlog and any future close that didn't cascade
+ * (e.g. a loop force-closed out of band). Kept in its own module to avoid an
+ * import cycle (loops/store → assignments for the cascade; this → both).
+ */
+import { listAssignments, convergeAssignmentToTerminal } from './assignments.js';
+import { getLoop } from './loops/store.js';
+/** review-loop:lop_xxx → the loop id. */
+const LOOP_SCOPE_RE = /^review-loop:(lop_[0-9a-z]+)/;
+const LOOP_TERMINAL = new Set(['completed', 'cancelled', 'blocked']);
+/**
+ * Converge any review-loop assignment whose loop is terminal. Returns the
+ * count converged. Pure best-effort and cheap: it only does a loop lookup for
+ * assignments whose scope is a review-loop, and only writes when a stuck one is
+ * found (the steady state is zero writes).
+ */
+export function reconcileOrphanedLoopAssignments(cwd) {
+    return reconcileOrphanedLoopAssignmentsFromList(listAssignments(cwd), cwd).length;
+}
+/**
+ * Same reconciliation as reconcileOrphanedLoopAssignments, but reuses an
+ * already-loaded assignment list. This keeps open_work context building from
+ * doing a second full assignment directory scan just to clean loop orphans.
+ */
+export function reconcileOrphanedLoopAssignmentsFromList(assignments, cwd) {
+    const convergedIds = [];
+    const loopCache = new Map();
+    for (const a of assignments) {
+        const match = a.scope?.match(LOOP_SCOPE_RE);
+        if (!match)
+            continue;
+        let loop = loopCache.get(match[1]);
+        if (!loopCache.has(match[1])) {
+            loop = getLoop(match[1], cwd);
+            loopCache.set(match[1], loop);
+        }
+        if (!loop || !LOOP_TERMINAL.has(loop.status))
+            continue;
+        const terminal = loop.status === 'completed' ? 'completed' : 'cancelled';
+        if (convergeAssignmentToTerminal(a.id, terminal, `loop ${match[1]} ${loop.status} (lazy reconcile)`, cwd)) {
+            convergedIds.push(a.id);
+        }
+    }
+    return convergedIds;
+}
+//# sourceMappingURL=assignment-reconciler.js.map

package/dist/core/assignment-sweeper.js

@@ -4,15 +4,100 @@
  * Runs opportunistically (no daemon): integrated into dispatch().
  * Future: integrate into session_start() and expose as CLI `brainclaw sweep`.
  *
+ * can_948acfd6 (sprint 1.5): the sweep consults IMPLICIT worker evidence
+ * before declaring an administrative death. Three live workers were expired
+ * by the acceptance-TTL in a single sprint because they could not call
+ * bclaw_assignment_update (sandboxed / no MCP) — yet their ack sentinel,
+ * heartbeat, filesystem activity and commits were all observable. This is the
+ * acceptance-sweep counterpart of the pln#527 no-heartbeat veto.
+ *
  * @module
  */
+import { spawnSync } from 'node:child_process';
 import { listAssignments, transitionAssignment } from './assignments.js';
+import { signalExists, readHeartbeat, latestActivityMs } from './runtime-signals.js';
+function lastCommitAgeMs(worktreePath, nowMs) {
+    if (!worktreePath)
+        return undefined;
+    try {
+        const res = spawnSync('git', ['log', '-1', '--format=%ct'], {
+            cwd: worktreePath, encoding: 'utf-8', windowsHide: true, timeout: 10_000,
+        });
+        if (res.status !== 0)
+            return undefined;
+        const epochSec = parseInt((res.stdout ?? '').trim(), 10);
+        if (!Number.isFinite(epochSec))
+            return undefined;
+        return nowMs - epochSec * 1000;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Collect implicit life-signs for an assignment: ack sentinel, heartbeat
+ * (project-root OR worktree-local), filesystem activity (logs + worktree),
+ * and a post-dispatch commit on the worktree branch.
+ *
+ * `sinceMs` anchors the commit check (a commit older than the offer is not
+ * evidence of THIS assignment's worker). `freshTtlMs` bounds what counts as
+ * "currently active" for the accepted/started branches.
+ */
+function collectImplicitEvidence(assignment, cwd, nowMs, sinceMs, freshTtlMs) {
+    const root = cwd ?? process.cwd();
+    const parts = [];
+    let freshest;
+    const bump = (ageMs) => {
+        if (ageMs === undefined)
+            return;
+        if (freshest === undefined || ageMs < freshest)
+            freshest = ageMs;
+    };
+    try {
+        if (signalExists(root, assignment.id, 'ack'))
+            parts.push('ack sentinel');
+    }
+    catch { /* defensive */ }
+    try {
+        const hb = readHeartbeat(root, assignment.id, assignment.worktree_path);
+        if (hb.exists && hb.mtimeMs !== undefined) {
+            const age = nowMs - hb.mtimeMs;
+            parts.push(`heartbeat ${Math.round(age / 1000)}s old`);
+            bump(age);
+        }
+    }
+    catch { /* defensive */ }
+    try {
+        const lastFs = latestActivityMs(root, assignment.id, assignment.worktree_path);
+        if (lastFs !== undefined) {
+            const age = nowMs - lastFs;
+            parts.push(`fs activity ${Math.round(age / 1000)}s old`);
+            bump(age);
+        }
+    }
+    catch { /* defensive */ }
+    const commitAge = lastCommitAgeMs(assignment.worktree_path, nowMs);
+    if (commitAge !== undefined && nowMs - commitAge >= sinceMs) {
+        parts.push(`post-dispatch commit ${Math.round(commitAge / 1000)}s old`);
+        bump(commitAge);
+    }
+    return {
+        any: parts.length > 0,
+        fresh: freshest !== undefined && freshest <= freshTtlMs,
+        description: parts.join(' + ') || 'none',
+    };
+}
 // ── Sweeper ──────────────────────────────────────────────────
 /**
  * Scan all active assignments and timeout those past their TTL.
  *
  * - `started` assignments with no heartbeat within `heartbeat_ttl_ms` → `timed_out`
+ *   UNLESS file evidence (heartbeat sentinel / fs activity / commit) is fresh.
+ * - `accepted` assignments not started within `acceptance_ttl_ms` → `timed_out`
+ *   UNLESS fresh evidence ⇒ implicit `started`.
  * - `offered` assignments not accepted within `acceptance_ttl_ms` → `expired`
+ *   UNLESS any evidence ⇒ implicit `accepted` (ack/heartbeat/fs/commit are
+ *   acceptance, just delivered by a worker that cannot reach MCP).
  *
  * @param cwd - Project root
  * @param options.nowMs - Override current time for testing
@@ -21,7 +106,7 @@ import { listAssignments, transitionAssignment } from './assignments.js';
 export function sweepAssignments(cwd, options) {
     const now = options?.nowMs ?? Date.now();
     const actor = options?.actor ?? 'sweeper';
-    const result = { timed_out: [], expired: [] };
+    const result = { timed_out: [], expired: [], implicitly_advanced: [] };
     const all = listAssignments(cwd);
     for (const assignment of all) {
         // Check started assignments for heartbeat timeout
@@ -31,9 +116,16 @@ export function sweepAssignments(cwd, options) {
                 continue;
             const ageMs = now - new Date(lastBeat).getTime();
             if (ageMs > assignment.heartbeat_ttl_ms) {
+                // can_948acfd6: a worker without MCP cannot bump last_heartbeat_at —
+                // its file evidence is the heartbeat. Fresh file activity vetoes the
+                // administrative timeout.
+                const sinceMs = new Date(assignment.started_at ?? assignment.created_at).getTime();
+                const evidence = collectImplicitEvidence(assignment, cwd, now, sinceMs, assignment.heartbeat_ttl_ms);
+                if (evidence.fresh)
+                    continue;
                 try {
                     transitionAssignment(assignment.id, 'timed_out', {
-                        status_reason: `No heartbeat for ${Math.round(ageMs / 60_000)} minutes (TTL: ${Math.round(assignment.heartbeat_ttl_ms / 60_000)}min)`,
+                        status_reason: `No heartbeat for ${Math.round(ageMs / 60_000)} minutes (TTL: ${Math.round(assignment.heartbeat_ttl_ms / 60_000)}min); implicit evidence: ${evidence.description}`,
                         actor,
                     }, cwd);
                     result.timed_out.push({ assignment_id: assignment.id, agent: assignment.agent, age_ms: ageMs });
@@ -49,9 +141,23 @@ export function sweepAssignments(cwd, options) {
             const ageMs = now - new Date(acceptedAt).getTime();
             // Use acceptance_ttl for accepted→timed_out (same window: agent should start quickly after accepting)
             if (ageMs > assignment.acceptance_ttl_ms) {
+                const sinceMs = new Date(acceptedAt).getTime();
+                const evidence = collectImplicitEvidence(assignment, cwd, now, sinceMs, assignment.acceptance_ttl_ms);
+                if (evidence.fresh) {
+                    // Working without MCP — record the implicit start so the FSM matches reality.
+                    try {
+                        transitionAssignment(assignment.id, 'started', {
+                            status_reason: `Implicit start inferred by sweeper: ${evidence.description}`,
+                            actor,
+                        }, cwd);
+                        result.implicitly_advanced.push({ assignment_id: assignment.id, agent: assignment.agent, to: 'started', evidence: evidence.description });
+                    }
+                    catch { /* skip */ }
+                    continue;
+                }
                 try {
                     transitionAssignment(assignment.id, 'timed_out', {
-                        status_reason: `Accepted but not started within ${Math.round(ageMs / 60_000)} minutes`,
+                        status_reason: `Accepted but not started within ${Math.round(ageMs / 60_000)} minutes; implicit evidence: ${evidence.description}`,
                         actor,
                     }, cwd);
                     result.timed_out.push({ assignment_id: assignment.id, agent: assignment.agent, age_ms: ageMs });
@@ -66,9 +172,26 @@ export function sweepAssignments(cwd, options) {
                 continue;
             const ageMs = now - new Date(offeredAt).getTime();
             if (ageMs > assignment.acceptance_ttl_ms) {
+                // can_948acfd6: ANY worker evidence (ack sentinel touched pre-exec,
+                // heartbeat written, files edited, commit landed) is an implicit
+                // acceptance — the worker just couldn't say so via MCP. Expiring it
+                // is the false-administrative-death observed three times in sprint 1.
+                const sinceMs = new Date(offeredAt).getTime();
+                const evidence = collectImplicitEvidence(assignment, cwd, now, sinceMs, assignment.acceptance_ttl_ms);
+                if (evidence.any) {
+                    try {
+                        transitionAssignment(assignment.id, 'accepted', {
+                            status_reason: `Implicit acceptance inferred by sweeper: ${evidence.description}`,
+                            actor,
+                        }, cwd);
+                        result.implicitly_advanced.push({ assignment_id: assignment.id, agent: assignment.agent, to: 'accepted', evidence: evidence.description });
+                    }
+                    catch { /* skip */ }
+                    continue;
+                }
                 try {
                     transitionAssignment(assignment.id, 'expired', {
-                        status_reason: `Not accepted within ${Math.round(ageMs / 60_000)} minutes (TTL: ${Math.round(assignment.acceptance_ttl_ms / 60_000)}min)`,
+                        status_reason: `Not accepted within ${Math.round(ageMs / 60_000)} minutes (TTL: ${Math.round(assignment.acceptance_ttl_ms / 60_000)}min); no implicit evidence`,
                         actor,
                     }, cwd);
                     result.expired.push({ assignment_id: assignment.id, agent: assignment.agent, age_ms: ageMs });

package/dist/core/assignments.js

@@ -7,6 +7,7 @@ import { JsonStore } from './json-store.js';
 import { appendAuditEntry } from './audit.js';
 import { appendEvent } from './event-log.js';
 import { createRuntimeEvent } from './events.js';
+import { emitRegistryPostImage, emitRegistryTombstone, registryFaultPoint } from './events/registry-post-image.js';
 import { findLatestAgentRunForAssignment, recordAgentRunProgress, syncAgentRunFromAssignmentTransition } from './agentruns.js';
 // ── Directory / Store ────────────────────────────────────────
 function assignmentsDir(cwd, mode = 'read') {
@@ -36,7 +37,12 @@ export function saveAssignment(assignment, cwd) {
             getId: (a) => a.id,
             sort: (a, b) => a.created_at.localeCompare(b.created_at),
         });
-        store.save(AssignmentSchema.parse(assignment));
+        const parsed = AssignmentSchema.parse(assignment);
+        // pln#568 (I2): journal the post-image BEFORE the projection write.
+        const created = !store.exists(parsed.id);
+        emitRegistryPostImage('assignment', parsed, { created, agent: parsed.agent, agent_id: parsed.agent_id, session_id: parsed.session_id, cwd });
+        registryFaultPoint('after_registry_journal');
+        store.save(parsed);
     });
 }
 export function loadAssignment(id, cwd) {
@@ -65,20 +71,22 @@ export function listAssignments(cwd, filter) {
     return items;
 }
 export function deleteAssignment(id, cwd) {
-    const store = assignmentStore(cwd);
-    if (!store.exists(id)) {
-        return false;
-    }
-    mutate({ cwd }, () => {
+    return mutate({ cwd }, () => {
         const writableStore = new JsonStore({
             dirPath: assignmentsDir(cwd, 'write'),
             documentType: 'assignment',
             getId: (a) => a.id,
             sort: (a, b) => a.created_at.localeCompare(b.created_at),
         });
+        if (!writableStore.exists(id)) {
+            return false;
+        }
+        const assignment = writableStore.load(id);
+        emitRegistryTombstone('assignment', assignment.id, { agent: assignment.agent, agent_id: assignment.agent_id, session_id: assignment.session_id, cwd });
+        registryFaultPoint('after_registry_journal');
         writableStore.delete(id);
+        return true;
     });
-    return true;
 }
 // ── ID Generation ────────────────────────────────────────────
 export function generateAssignmentId(cwd) {
@@ -102,7 +110,12 @@ const VALID_TRANSITIONS = new Map([
     ['timed_out', new Set(['retrying', 'rerouted', 'cancelled'])],
     ['retrying', new Set(['offered', 'rerouted', 'cancelled'])],
     ['blocked', new Set(['rerouted', 'started', 'failed', 'cancelled'])],
-    // Terminal: completed, cancelled, expired, rerouted (no outgoing transitions)
+    // can_948acfd6: evidence can arrive AFTER an administrative expiry — the
+    // worker was alive all along but never acked (sandboxed, no MCP), and its
+    // commit / LANE-RESULT surfaced later. Allow the late convergence so
+    // harvest/reconcile can record the truth instead of being FSM-blocked.
+    ['expired', new Set(['completed'])],
+    // Terminal: completed, cancelled, rerouted (no outgoing transitions)
 ]);
 export function validateTransition(from, to) {
     const allowed = VALID_TRANSITIONS.get(from);
@@ -119,6 +132,9 @@ export function validateTransition(from, to) {
  * Updates relevant timestamps, emits event and audit entry.
  */
 export function transitionAssignment(id, newStatus, options, cwd) {
+    return transitionAssignmentInternal(id, newStatus, options, cwd);
+}
+function transitionAssignmentInternal(id, newStatus, options, cwd) {
     const assignment = loadAssignment(id, cwd);
     if (!assignment) {
         throw new Error(`Assignment not found: ${id}`);
@@ -131,9 +147,17 @@ export function transitionAssignment(id, newStatus, options, cwd) {
         saveAssignment(assignment, cwd);
         return { assignment, previous_status: newStatus, idempotent: true };
     }
-    const validation = validateTransition(assignment.status, newStatus);
-    if (!validation.valid) {
-        throw new Error(validation.reason);
+    if (options.systemConvergence) {
+        const validation = validateSystemConvergence(assignment.status, newStatus, options.actor);
+        if (!validation.valid) {
+            throw new Error(validation.reason);
+        }
+    }
+    else {
+        const validation = validateTransition(assignment.status, newStatus);
+        if (!validation.valid) {
+            throw new Error(validation.reason);
+        }
     }
     const previous_status = assignment.status;
     const now = nowISO();
@@ -300,6 +324,40 @@ export function createAssignment(options, cwd) {
 // ── Active Assignment Lookup ─────────────────────────────────
 /** Statuses that indicate a finished assignment (no longer active). */
 const TERMINAL_STATUSES = new Set(['completed', 'cancelled', 'expired', 'rerouted']);
+/**
+ * Statuses a file-based worker leaves an assignment stuck in — it never calls
+ * bclaw_assignment_update, so the assignment never advances past these (pln#563).
+ * These are the only states a system convergence (loop-close cascade / lazy
+ * reconciler) fast-forwards; failed/blocked/timed_out carry real signal and are
+ * left alone.
+ */
+const CONVERGEABLE_STATUSES = new Set(['offered', 'accepted', 'started']);
+function validateSystemConvergence(from, to, actor) {
+    if (actor !== 'system') {
+        return { valid: false, reason: 'System convergence must be performed by actor=system' };
+    }
+    if (!CONVERGEABLE_STATUSES.has(from) || (to !== 'completed' && to !== 'cancelled')) {
+        return { valid: false, reason: `Invalid system convergence: ${from} → ${to}` };
+    }
+    return { valid: true };
+}
+/**
+ * Force a stuck assignment to a terminal status as a SYSTEM convergence
+ * (pln#563). No-op (returns false) if the assignment is missing or not in a
+ * convergeable state, so callers can fire it best-effort. Used by the loop-close
+ * cascade and the lazy orphan reconciler.
+ */
+export function convergeAssignmentToTerminal(id, terminal, reason, cwd) {
+    const assignment = loadAssignment(id, cwd);
+    if (!assignment || !CONVERGEABLE_STATUSES.has(assignment.status))
+        return false;
+    transitionAssignmentInternal(id, terminal, {
+        actor: 'system',
+        status_reason: reason,
+        systemConvergence: true,
+    }, cwd);
+    return true;
+}
 /**
  * Return the most recently created non-terminal assignment for the given agent.
  * When `claimId` is provided, it is used as a fast-path lookup before falling