brainclaw 1.15.0 → 1.17.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,8 @@ 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';
+import { dispatchReviewLoopTurn } from '../core/review-loop-turn-dispatch.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 +114,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 +234,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 +273,21 @@ 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.
+        // PR2: cycleOnRequestChanges=false — the report path only closes on approve;
+        // it must NOT advance a request_changes cycle it cannot follow through on
+        // (no re-dispatch, no claim retention). `harvest --integrate` owns the cycle.
+        try {
+            const laneAssignment = loadAssignment(lane.assignment_id, cwd);
+            if (laneAssignment)
+                closeReviewLoopFromLaneResult(laneAssignment, lane, agent, cwd, { cycleOnRequestChanges: false });
+        }
+        catch { /* never block harvest on loop-close */ }
         const marker = laneHarvestedMarkerPath(cwd, lane.assignment_id);
         if (fs.existsSync(marker)) {
             result.skipped.push(lane.assignment_id);
@@ -376,7 +395,7 @@ function forceCompleteAssignment(assignmentId, artifacts, statusReason, actor, c
 export function integrateLaneResults(options = {}) {
     const cwd = options.cwd ?? process.cwd();
     const actor = options.agent ?? 'coordinator';
-    const result = { integrated: [], skipped: [], errors: [] };
+    const result = { integrated: [], skipped: [], errors: [], next_turns: [] };
     const worktreePaths = resolveLaneScanPaths(options, cwd);
     for (const worktreePath of worktreePaths) {
         const file = getLaneResultPath(worktreePath);
@@ -444,16 +463,55 @@ export function integrateLaneResults(options = {}) {
                     ...entry.files_changed.slice(0, 50).map((f) => ({ type: 'file', ref: f })),
                 ];
                 entry.assignment_completed = forceCompleteAssignment(lane.assignment_id, artifacts, `pln#534 on-behalf integration: ${lane.summary.slice(0, 120)}`, actor, cwd);
-                // trp#928 — use the cascade helper (was releaseClaimWithCascade — same
-                // logic for the last-claim rule but the cascade wrapper LOGS per-claim,
-                // so a silent ownership failure is observable in the runtime event log
-                // rather than only in this in-memory `reasons` string).
-                const cascade = releaseClaimsCascade([assignment.claim_id], { cwd, planStatus: 'done' });
-                logCascadeReleaseResult({ actor, trigger: 'harvest_integrate', assignment_id: lane.assignment_id, claim_id: assignment.claim_id, cascade, cwd });
-                const claimEntry = cascade.entries[0];
-                entry.claim_released = claimEntry?.released === true;
-                if (claimEntry && !claimEntry.released) {
-                    reasons.push(`claim release ${claimEntry.reason}${claimEntry.error ? `: ${claimEntry.error}` : ''}`);
+                // pln#628 Focus 4B — map this lane onto its review loop BEFORE deciding
+                // teardown: PR1 records the verdict + advances (auto-close on approve);
+                // PR2 continues the fix cycle on request_changes (bump round, emit a
+                // next_turn) unless the iteration cap is hit. This is the --integrate
+                // path, so it MAY cycle (it can re-dispatch AND retain the claim). No-op
+                // for non-review lanes / lanes without a verdict; never throws.
+                const loopClose = closeReviewLoopFromLaneResult(assignment, lane, actor, cwd);
+                if (loopClose) {
+                    entry.review_loop = loopClose;
+                    reasons.push(`review-loop ${loopClose.loop_id}: ${loopClose.action} — ${loopClose.reason}`);
+                    if (loopClose.next_turn) {
+                        result.next_turns.push({ loop_id: loopClose.loop_id, ...loopClose.next_turn });
+                    }
+                }
+                // PR2 claim-teardown gate. Skip the release when either:
+                //  (a) keep_claim — the symmetric fix cycle reuses the claim/worktree for
+                //      the re-dispatched turn (commits accumulate on one branch); or
+                //  (b) Codex review P0 — an idempotent re-harvest of an OLD lane whose
+                //      loop is still OPEN returns a `noop` (the reviewer slot is now bound
+                //      to a NEWER assignment under an active cycle). Releasing here would
+                //      tear down the reused claim/worktree out from under the live turn
+                //      and strand the fix cycle. The loop machinery owns the lifecycle
+                //      while it is open; only a terminal close (approve/blocked, action
+                //      'closed') or an asymmetric hand-off ('advanced' without keep_claim)
+                //      releases here. A `noop` on a TERMINAL loop still releases (safe —
+                //      the closing pass already released, so this is a no-op).
+                const loopStillOpen = loopClose?.loop_status !== undefined &&
+                    !['completed', 'cancelled', 'blocked'].includes(loopClose.loop_status);
+                const keepClaimAlive = loopClose?.keep_claim === true || (loopClose?.action === 'noop' && loopStillOpen);
+                if (keepClaimAlive) {
+                    // The next_turn spawn (async) is awaited by runHarvestLane. The
+                    // assignment for THIS turn is still completed above.
+                    entry.claim_released = false;
+                    reasons.push(loopClose?.keep_claim
+                        ? 'claim kept alive for review fix-cycle re-dispatch (PR2)'
+                        : 'claim left intact — idempotent re-harvest on an active review loop (no strand)');
+                }
+                else {
+                    // trp#928 — use the cascade helper (was releaseClaimWithCascade — same
+                    // logic for the last-claim rule but the cascade wrapper LOGS per-claim,
+                    // so a silent ownership failure is observable in the runtime event log
+                    // rather than only in this in-memory `reasons` string).
+                    const cascade = releaseClaimsCascade([assignment.claim_id], { cwd, planStatus: 'done' });
+                    logCascadeReleaseResult({ actor, trigger: 'harvest_integrate', assignment_id: lane.assignment_id, claim_id: assignment.claim_id, cascade, cwd });
+                    const claimEntry = cascade.entries[0];
+                    entry.claim_released = claimEntry?.released === true;
+                    if (claimEntry && !claimEntry.released) {
+                        reasons.push(`claim release ${claimEntry.reason}${claimEntry.error ? `: ${claimEntry.error}` : ''}`);
+                    }
                 }
             }
             else {
@@ -672,7 +730,7 @@ export function harvestOrphaned(options) {
     }
     return report;
 }
-export function runHarvestLane(assignmentId, options = {}) {
+export async function runHarvestLane(assignmentId, options = {}) {
     const cwd = options.cwd ?? process.cwd();
     if (!memoryExists(cwd)) {
         console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
@@ -734,8 +792,30 @@ export function runHarvestLane(assignmentId, options = {}) {
             dryRun: options.dryRun,
             cwd,
         });
+        // pln#628 Focus 4B PR2 — spawn the review fix-cycle turns the sync integrate
+        // pass emitted. Re-dispatches the SAME reviewer into the SAME (kept) worktree
+        // to apply the requested changes + re-review. Dry-run only reports them.
+        const dispatchedTurns = [];
+        if (!options.dryRun) {
+            for (const nt of integ.next_turns) {
+                const dispatched = await dispatchReviewLoopTurn({
+                    loopId: nt.loop_id,
+                    slot: { slot_id: nt.slot_id, role: nt.role, agent: nt.agent, agent_id: nt.agent_id },
+                    phase: nt.phase,
+                    task: nt.task,
+                    dispatcherAgent: options.agent ?? 'coordinator',
+                    cwd,
+                    // NO worktreeBaseRef: reuse the kept worktree so the fixes accumulate;
+                    // pinning a ref would reset the branch and wipe prior-round commits.
+                });
+                dispatchedTurns.push({
+                    loop_id: nt.loop_id, agent: nt.agent, iteration: nt.iteration,
+                    execution_status: dispatched.execution_status, error: dispatched.error,
+                });
+            }
+        }
         if (options.json) {
-            console.log(JSON.stringify(integ, null, 2));
+            console.log(JSON.stringify({ ...integ, dispatched_turns: dispatchedTurns }, null, 2));
             return;
         }
         const dry = options.dryRun ? ' (dry-run)' : '';
@@ -762,7 +842,14 @@ export function runHarvestLane(assignmentId, options = {}) {
         }
         for (const err of integ.errors)
             console.error(`  ✗ ${err}`);
-        console.log(`\n✔ Lane integrate complete${dry}: ${integ.integrated.length} integrated, ${integ.errors.length} error(s).`);
+        for (const dt of dispatchedTurns) {
+            const status = dt.error ? `error: ${dt.error}` : (dt.execution_status ?? 'unknown');
+            console.log(`  ↻ Fix-cycle re-dispatch [${dt.loop_id}] round ${dt.iteration} → ${dt.agent} (${status})`);
+        }
+        if (options.dryRun && integ.next_turns.length > 0) {
+            console.log(`  (dry-run) ${integ.next_turns.length} fix-cycle turn(s) would be re-dispatched.`);
+        }
+        console.log(`\n✔ Lane integrate complete${dry}: ${integ.integrated.length} integrated, ${dispatchedTurns.length} re-dispatched, ${integ.errors.length} error(s).`);
         return;
     }
     const result = harvestLaneResults({