brainclaw 1.26.2 → 1.28.0

package/dist/core/loops/verify-command.js

@@ -24,10 +24,16 @@
  */
 import { spawnSync } from 'node:child_process';
 import path from 'node:path';
+import { loadAssignment } from '../assignments.js';
 import { getLoop } from './store.js';
 import { withLoopLock } from './lock.js';
-import { add_artifact } from './verbs.js';
+import { addArtifactWithEvidence } from './verbs.js';
 import { artifactsInIteration } from './iteration-engine.js';
+import { evidenceDigest } from './evidence.js';
+import { eligibleArtifactsForPurpose } from './gate-policy.js';
+import { captureWorkspaceDigest } from './workspace-digest.js';
+import { findReservationByAssignmentId } from './attempt-reservation.js';
+import { resolveTurnGenerationChain } from './attempt-generations.js';
 import { VERIFY_DEFAULT_TIMEOUT_MS, LOOP_ARTIFACT_BODY_MAX_BYTES, } from './types.js';
 /** VerifyReportBodySchema caps stdout_tail/stderr_tail at 1024. */
 const TAIL_MAX = 1024;
@@ -48,7 +54,15 @@ export const defaultVerifyRunner = (config) => {
             delete env[k];
     }
     const started = Date.now();
-    const r = spawnSync(config.command[0], config.command.slice(1), {
+    const requestedExecutable = config.command[0];
+    const npmCli = process.platform === 'win32' && (requestedExecutable === 'npm' || requestedExecutable === 'npx')
+        ? path.join(path.dirname(process.execPath), 'node_modules', 'npm', 'bin', `${requestedExecutable}-cli.js`)
+        : undefined;
+    // Node cannot spawn .cmd shims with shell:false on Windows. Invoke npm's JS
+    // entrypoint through the current Node binary so the no-shell security contract holds.
+    const executable = npmCli ? process.execPath : requestedExecutable;
+    const commandArgs = npmCli ? [npmCli, ...config.command.slice(1)] : config.command.slice(1);
+    const r = spawnSync(executable, commandArgs, {
         cwd: config.cwd,
         env,
         shell: false,
@@ -76,19 +90,52 @@ export const defaultVerifyRunner = (config) => {
     };
 };
 /**
- * Resolve the verify command for a loop. PR1: the loop-PROJECT cwd only (the
- * lane-worktree cwd for a sequenced impl loop is a follow-up). Returns `unconfigured`
- * when the loop opted out (no `protocol.verify`).
+ * Resolve the verify command for a loop. Bound implementation lanes run only
+ * in their assignment worktree; legacy/unbound loops retain the project cwd.
+ * Returns `unconfigured` when the loop opted out (no `protocol.verify`).
  */
-export function resolveVerifyCommand(thread, cwd) {
+function assignmentWorktree(assignmentId, cwd) {
+    const assignment = loadAssignment(assignmentId, cwd);
+    const reservation = findReservationByAssignmentId(assignmentId, cwd);
+    const generation = reservation
+        ? resolveTurnGenerationChain(cwd ?? reservation.store_root, reservation.turn_id)?.latest_generation
+        : undefined;
+    return generation?.workspace_path ?? assignment?.worktree_path;
+}
+export function resolveVerifyCommand(thread, cwd, slotId) {
     const cfg = thread.protocol?.verify;
     if (!cfg)
         return { kind: 'unconfigured' };
+    let verifyCwd = path.resolve(cwd ?? process.cwd());
+    if (thread.kind === 'implementation') {
+        const selected = slotId ? thread.slots.find((slot) => slot.slot_id === slotId) : undefined;
+        if (slotId && !selected)
+            throw new Error(`verify: slot ${slotId} not found on loop ${thread.id}`);
+        const candidates = (selected ? [selected] : thread.slots)
+            .filter((slot) => slot.assignment_id)
+            .map((slot) => ({ slot, worktree_path: assignmentWorktree(slot.assignment_id, cwd) }))
+            .filter((entry) => entry.worktree_path);
+        if (!selected && candidates.length > 1) {
+            throw new Error(`verify: implementation loop ${thread.id} has multiple bound worktrees; pass slot_id to verify one lane deterministically`);
+        }
+        if (!selected && thread.slots.some((slot) => slot.lane) && candidates.length === 0) {
+            throw new Error(`verify: implementation loop ${thread.id} has bound lanes but no assignment worktree; dispatch and settle the execute turn first`);
+        }
+        if (selected?.lane && !selected.assignment_id) {
+            throw new Error(`verify: slot ${selected.slot_id} is bound to lane ${selected.lane} but has no assignment worktree; dispatch and settle the execute turn first`);
+        }
+        const candidate = candidates[0];
+        if (selected?.assignment_id && !candidate?.worktree_path) {
+            throw new Error(`verify: slot ${selected.slot_id} assignment ${selected.assignment_id} has no worktree_path`);
+        }
+        if (candidate?.worktree_path)
+            verifyCwd = path.resolve(candidate.worktree_path);
+    }
     return {
         kind: 'ok',
         config: {
             command: cfg.command,
-            cwd: path.resolve(cwd ?? process.cwd()),
+            cwd: verifyCwd,
             timeout_ms: cfg.timeout_ms ?? VERIFY_DEFAULT_TIMEOUT_MS,
         },
     };
@@ -115,9 +162,10 @@ function fitBody(report) {
     }
     return { ...report, stdout_tail: undefined, stderr_tail: undefined };
 }
-export function buildVerifyReportBody(config, result) {
+export function buildVerifyReportBody(config, result, bindings) {
     return fitBody({
         command: config.command.join(' '),
+        command_argv: config.command,
         exit_code: result.exit_code,
         passed: result.passed,
         duration_ms: result.duration_ms,
@@ -125,11 +173,24 @@ export function buildVerifyReportBody(config, result) {
         timed_out: result.timed_out,
         stdout_tail: result.stdout_tail || undefined,
         stderr_tail: result.stderr_tail || undefined,
+        ...bindings,
     });
 }
-/** True when a verify_report already exists in this iteration (idempotency key = loop+iteration). */
-function hasVerifyReportForIteration(thread, iteration) {
-    return artifactsInIteration(thread, iteration).some((a) => a.type === 'verify_report');
+/** True when an authoritative, still-fresh engine report exists for this iteration. */
+function hasVerifyReportForIteration(thread, iteration, lane) {
+    const reports = artifactsInIteration(thread, iteration).filter((artifact) => {
+        if (artifact.type !== 'verify_report')
+            return false;
+        if (!lane)
+            return true;
+        try {
+            return JSON.parse(artifact.body ?? '{}').lane === lane;
+        }
+        catch {
+            return false;
+        }
+    });
+    return eligibleArtifactsForPurpose(thread, reports, 'command_green').eligible.length > 0;
 }
 /**
  * Run the configured verify command and record a deterministic `verify_report` for the
@@ -152,16 +213,23 @@ export function runVerify(input, cwd) {
             const thread = getLoop(input.loop_id, cwd);
             if (!thread)
                 throw new Error(`loop ${input.loop_id} not found`);
-            const resolved = resolveVerifyCommand(thread, cwd);
+            const inferredSlots = thread.kind === 'implementation' && !input.slot_id
+                ? thread.slots.filter((slot) => slot.assignment_id && assignmentWorktree(slot.assignment_id, cwd))
+                : [];
+            const selectedSlot = input.slot_id
+                ? thread.slots.find((slot) => slot.slot_id === input.slot_id)
+                : inferredSlots.length === 1 ? inferredSlots[0] : undefined;
+            const lane = selectedSlot?.lane;
+            const resolved = resolveVerifyCommand(thread, cwd, selectedSlot?.slot_id ?? input.slot_id);
             if (resolved.kind === 'unconfigured')
                 return { state: 'unconfigured', thread };
             const iteration = thread.iteration_count;
-            if (hasVerifyReportForIteration(thread, iteration))
+            if (hasVerifyReportForIteration(thread, iteration, lane))
                 return { state: 'deduped', thread };
             // Snapshot the iteration + phase we are about to verify. The command tests THIS
             // iteration's working tree; the report must be attributed to it even if a
             // concurrent advance bumps the loop's iteration while we spawn (review F1).
-            return { state: 'run', thread, config: resolved.config, iteration, phase: thread.current_phase };
+            return { state: 'run', thread, config: resolved.config, iteration, phase: thread.current_phase, lane };
         },
     });
     if (snapshot.state === 'unconfigured')
@@ -169,8 +237,13 @@ export function runVerify(input, cwd) {
     if (snapshot.state === 'deduped')
         return { thread: snapshot.thread, deduped: true };
     // --- OUT OF LOCK: run the command (may take minutes). ---
-    const { config, iteration, phase } = snapshot;
-    const report = buildVerifyReportBody(config, runner(config));
+    const { config, iteration, phase, lane } = snapshot;
+    const command_digest = evidenceDigest({ command: config.command });
+    const workspaceBefore = captureWorkspaceDigest(config.cwd);
+    const runResult = runner(config);
+    const workspaceAfter = captureWorkspaceDigest(config.cwd);
+    const workspace_stable = workspaceBefore === workspaceAfter;
+    const reportAfterRun = buildVerifyReportBody(config, { ...runResult, passed: runResult.passed && workspace_stable }, { command_digest, workspace_digest: workspaceAfter, workspace_stable, lane });
     // --- Lock scope 2: re-check idempotency (by SNAPSHOT iteration), then append. ---
     return withLoopLock({
         cwd,
@@ -184,12 +257,25 @@ export function runVerify(input, cwd) {
             // Dedup on the SNAPSHOT iteration — a report for the iteration we verified already
             // landed (a concurrent verify won). Checking the snapshot (not the current)
             // iteration is what makes this correct after a concurrent advance (review F1).
-            if (hasVerifyReportForIteration(thread, iteration)) {
-                return { thread, report, deduped: true };
+            if (hasVerifyReportForIteration(thread, iteration, lane)) {
+                return { thread, report: reportAfterRun, deduped: true };
             }
-            const updated = add_artifact({
+            // Close the final out-of-lock race: the bytes verified above must still be the
+            // bytes present at the evidence commit boundary. A later gate independently
+            // repeats this freshness check so a post-commit mutation also fails closed.
+            const workspaceAtCommit = captureWorkspaceDigest(config.cwd);
+            const commitStable = workspace_stable && workspaceAtCommit === workspaceAfter;
+            const report = buildVerifyReportBody(config, { ...runResult, passed: runResult.passed && commitStable }, { command_digest, workspace_digest: workspaceAtCommit, workspace_stable: commitStable, lane });
+            const updated = addArtifactWithEvidence({
                 id: input.loop_id,
                 actor: input.actor,
+                evidence_context: {
+                    channel: 'verify_command',
+                    producer_kind: 'engine',
+                    producer_id: 'brainclaw:verify-command',
+                    command_digest,
+                    workspace_digest: workspaceAtCommit,
+                },
                 artifact: {
                     // Stamp the SNAPSHOT phase + iteration so the report is attributed to the
                     // iteration whose code it actually tested — never a later iteration a
@@ -198,7 +284,6 @@ export function runVerify(input, cwd) {
                     iteration,
                     type: 'verify_report',
                     body: JSON.stringify(report),
-                    produced_by: 'engine',
                 },
             }, cwd);
             const art = updated.artifacts[updated.artifacts.length - 1];

package/dist/core/loops/workspace-digest.js

@@ -0,0 +1,54 @@
+import crypto from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+function fallbackFiles(root, current = root) {
+    const files = [];
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+        if (entry.name === '.brainclaw' || entry.name === '.git' || entry.name === 'node_modules')
+            continue;
+        const absolute = path.join(current, entry.name);
+        if (entry.isDirectory())
+            files.push(...fallbackFiles(root, absolute));
+        else if (entry.isFile())
+            files.push(path.relative(root, absolute));
+    }
+    return files;
+}
+/** Hash the exact tracked/untracked workspace bytes at a gate boundary. */
+export function captureWorkspaceDigest(cwd) {
+    const rootResult = spawnSync('git', ['-C', cwd, 'rev-parse', '--show-toplevel'], {
+        encoding: 'utf8', shell: false, maxBuffer: 1024 * 1024,
+    });
+    const gitRoot = rootResult.status === 0 ? rootResult.stdout.trim() : undefined;
+    let files;
+    let root;
+    if (gitRoot) {
+        root = path.resolve(gitRoot);
+        const listed = spawnSync('git', ['-C', root, 'ls-files', '--cached', '--others', '--exclude-standard', '-z'], {
+            encoding: 'buffer', shell: false, maxBuffer: 32 * 1024 * 1024,
+        });
+        files = listed.status === 0
+            ? listed.stdout.toString('utf8').split('\0').filter(Boolean)
+            : fallbackFiles(root);
+    }
+    else {
+        root = path.resolve(cwd);
+        files = fallbackFiles(root);
+    }
+    const hash = crypto.createHash('sha256').update(root.normalize('NFC'));
+    for (const relative of [...new Set(files)].sort()) {
+        const absolute = path.resolve(root, relative);
+        try {
+            const stat = fs.lstatSync(absolute);
+            if (!stat.isFile())
+                continue;
+            hash.update('\0').update(relative.normalize('NFC')).update('\0').update(fs.readFileSync(absolute));
+        }
+        catch {
+            hash.update('\0missing\0').update(relative.normalize('NFC'));
+        }
+    }
+    return hash.digest('hex');
+}
+//# sourceMappingURL=workspace-digest.js.map

package/dist/core/review-loop-close.js

@@ -1,5 +1,5 @@
 import { getLoop } from './loops/store.js';
-import { complete_turn, advance } from './loops/verbs.js';
+import { completeTurnWithEvidence, advance } from './loops/verbs.js';
 import { withLoopLock } from './loops/lock.js';
 import { LOOP_ARTIFACT_BODY_MAX_BYTES } from './loops/types.js';
 /** review-loop:lop_xxx → the loop id (mirrors assignment-reconciler.ts). */
@@ -93,8 +93,19 @@ export function closeReviewLoopFromLaneResult(assignment, lane, actor, cwd, opti
                 if (verdict === 'approve') {
                     if (slot) {
                         // isVerdictAccepted fires reviewer_green ONLY on an "accepted…" body.
-                        complete_turn({
+                        completeTurnWithEvidence({
                             id: loopId, slot_id: slot.slot_id, actor,
+                            evidence_context: {
+                                channel: 'complete_turn',
+                                producer_kind: 'slot',
+                                producer_id: slot.slot_id,
+                                agent_id: slot.agent_id,
+                                slot_id: slot.slot_id,
+                                slot_role: slot.role,
+                                turn_id: slot.current_turn_id,
+                                assignment_id: slot.assignment_id ?? assignment.id,
+                                claim_id: slot.claim_id,
+                            },
                             // pln#639 BUG-2 — the phase the slot was DISPATCHED in, not the
                             // loop's phase at close time. Same defect as the ideation closer;
                             // fixed here too because this is the far more travelled path.
@@ -145,8 +156,19 @@ export function closeReviewLoopFromLaneResult(assignment, lane, actor, cwd, opti
                 // is a planned follow-up, so a human drives it. (No re-dispatch means no
                 // worktree reuse, so the claim is released by harvest as usual.)
                 const symmetric = loop.protocol?.review_mode === 'symmetric';
-                complete_turn({
+                completeTurnWithEvidence({
                     id: loopId, slot_id: slot.slot_id, actor,
+                    evidence_context: {
+                        channel: 'complete_turn',
+                        producer_kind: 'slot',
+                        producer_id: slot.slot_id,
+                        agent_id: slot.agent_id,
+                        slot_id: slot.slot_id,
+                        slot_role: slot.role,
+                        turn_id: slot.current_turn_id,
+                        assignment_id: slot.assignment_id ?? assignment.id,
+                        claim_id: slot.claim_id,
+                    },
                     // pln#639 BUG-2 — dispatch phase, not close-time phase (see above).
                     artifact: { phase: slot.phase ?? loop.current_phase, type: 'verdict', body: capVerdictBody('changes-requested', detail) },
                 }, cwd);