brainclaw 1.14.0 → 1.16.0

package/dist/commands/dispatch-watch.js

@@ -42,6 +42,24 @@ export function evaluateWatchTick(input) {
     return 'running';
 }
 const AGENT_CHILD_NAMES = ['claude', 'codex', 'copilot', 'node'];
+/**
+ * Parse `ps -A -o ppid=,comm=` output and return the lowercased command names
+ * whose parent pid equals `ppid`. Pure + exported so the ppid-filter logic is
+ * unit-tested independently of the platform the test runs on (trp_3b096bf4:
+ * BSD `ps` on macOS rejects the GNU `--ppid` flag, so we filter here instead).
+ */
+export function parseChildCommsByPpid(psOutput, ppid) {
+    const target = Math.floor(ppid);
+    return psOutput
+        .split('\n')
+        .map((line) => {
+        const m = /^\s*(\d+)\s+(.*)$/.exec(line);
+        if (!m || Number(m[1]) !== target)
+            return undefined;
+        return m[2].trim().toLowerCase();
+    })
+        .filter((n) => !!n);
+}
 /**
  * Does a real agent process live under the wrapper pid?
  * Returns undefined when the observation itself fails (never treated as death).
@@ -59,10 +77,15 @@ export function probeAgentChildAlive(wrapperPid) {
             const names = out.split(/\r?\n/).map((l) => l.trim().toLowerCase()).filter(Boolean);
             return names.some((n) => AGENT_CHILD_NAMES.some((a) => n.startsWith(a)));
         }
-        const out = execFileSync('ps', ['-o', 'comm=', '--ppid', String(wrapperPid)], {
+        // BSD `ps` (macOS) does NOT support the GNU `--ppid` flag — it errored on
+        // every poll on macOS and broke child-pid discovery there (trp_3b096bf4).
+        // List every process with its parent pid + command (portable across Linux
+        // and macOS — same `-A -o …=` form already used in ai-surface-inventory.ts)
+        // and filter by ppid in parseChildCommsByPpid.
+        const out = execFileSync('ps', ['-A', '-o', 'ppid=,comm='], {
             encoding: 'utf-8', timeout: 15000,
         });
-        const names = out.split('\n').map((l) => l.trim().toLowerCase()).filter(Boolean);
+        const names = parseChildCommsByPpid(out, wrapperPid);
         return names.some((n) => AGENT_CHILD_NAMES.some((a) => n.includes(a)));
     }
     catch {

package/dist/commands/harvest.js

@@ -22,6 +22,7 @@ import { loadAssignment, transitionAssignment } from '../core/assignments.js';
 import { loadClaim, releaseClaimsCascade, logCascadeReleaseResult } from '../core/claims.js';
 import { getCapabilityProfile, dispatchCanCommit } from '../core/agent-capability.js';
 import { commitWorktreeOnBehalf, worktreesBaseDir, resolveGitToplevel } from '../core/worktree.js';
+import { closeReviewLoopFromLaneResult } from '../core/review-loop-close.js';
 /**
  * Auto-detect all worktree directories under the brainclaw-managed base dir.
  * Returns subdirectories that exist on disk (may or may not have an inbox).
@@ -112,10 +113,11 @@ function collectWorktreeCandidateFiles(worktreePath) {
 /**
  * Harvest candidates from worktree inboxes into the main project store.
  *
- * This is the coordinator-side fix for gap 5 of E2E test n°1: agents
- * running under `--sandbox workspace-write` cannot reach the main store
- * via MCP. They write candidates directly to their worktree inbox; the
- * coordinator calls `harvestCandidates` to sync them.
+ * This is the coordinator-side fix for gap 5 of E2E test n°1: a worker that
+ * cannot write to the main store — a genuinely MCP-less agent, or (post
+ * dec#133) a sandboxed codex whose `.git` is read-only so it cannot commit —
+ * leaves candidates in its worktree inbox; the coordinator calls
+ * `harvestCandidates` to sync them.
  *
  * @returns HarvestResult with counts of harvested, skipped, and errors.
  */
@@ -231,8 +233,9 @@ export function runHarvestCandidates(options = {}) {
 //
 // A dispatched worker writes a single `LANE-RESULT.json` at its worktree root
 // as its final step. This is the standard, brief-boilerplate-free channel for a
-// worker (especially a sandboxed one that cannot reach MCP) to report its
-// outcome. The coordinator ingests it with `brainclaw harvest <assignment_id>`.
+// worker (a genuinely MCP-less agent, or a sandboxed codex that cannot git
+// commit) to report its outcome. The coordinator ingests it with
+// `brainclaw harvest <assignment_id>`.
 // ─────────────────────────────────────────────────────────────────────────────
 /** Conventional path of a worker's lane-result file at the worktree root. */
 export function getLaneResultPath(worktreePath) {
@@ -269,6 +272,18 @@ export function harvestLaneResults(options = {}) {
         // Assignment filter (when harvesting a specific lane).
         if (options.assignmentId && lane.assignment_id !== options.assignmentId)
             continue;
+        // pln#628 Focus 4B (Codex review of #87 BLOCKING 1) — a review lane must
+        // close/advance its loop on the plain report-only harvest path too, not only
+        // on `--integrate`. closeReviewLoopFromLaneResult is convergent + idempotent
+        // (a terminal loop is a no-op; a stuck approve is resumed), so firing it here
+        // AND in integrateLaneResults is safe — and it runs BEFORE the harvested
+        // marker short-circuits below, so a re-harvest still resumes a stuck loop.
+        try {
+            const laneAssignment = loadAssignment(lane.assignment_id, cwd);
+            if (laneAssignment)
+                closeReviewLoopFromLaneResult(laneAssignment, lane, agent, cwd);
+        }
+        catch { /* never block harvest on loop-close */ }
         const marker = laneHarvestedMarkerPath(cwd, lane.assignment_id);
         if (fs.existsSync(marker)) {
             result.skipped.push(lane.assignment_id);
@@ -455,6 +470,16 @@ export function integrateLaneResults(options = {}) {
                 if (claimEntry && !claimEntry.released) {
                     reasons.push(`claim release ${claimEntry.reason}${claimEntry.error ? `: ${claimEntry.error}` : ''}`);
                 }
+                // pln#628 Focus 4B — if this lane is a review-loop turn carrying a
+                // verdict, map it onto the loop: record the verdict artifact + advance,
+                // which auto-closes the loop on reviewer_green (approve) without a human
+                // driving complete_turn/advance by hand. No-op for non-review lanes or
+                // lanes without a verdict; never throws (harvest is not blocked on it).
+                const loopClose = closeReviewLoopFromLaneResult(assignment, lane, actor, cwd);
+                if (loopClose) {
+                    entry.review_loop = loopClose;
+                    reasons.push(`review-loop ${loopClose.loop_id}: ${loopClose.action} — ${loopClose.reason}`);
+                }
             }
             else {
                 // blocked / failed: best-effort lifecycle (FSM may reject from offered).