brainclaw 1.26.2 → 1.27.0

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

@@ -26,8 +26,11 @@ import { spawnSync } from 'node:child_process';
 import path from 'node:path';
 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 { VERIFY_DEFAULT_TIMEOUT_MS, LOOP_ARTIFACT_BODY_MAX_BYTES, } from './types.js';
 /** VerifyReportBodySchema caps stdout_tail/stderr_tail at 1024. */
 const TAIL_MAX = 1024;
@@ -115,9 +118,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 +129,13 @@ 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). */
+/** True when an authoritative, still-fresh engine report exists for this iteration. */
 function hasVerifyReportForIteration(thread, iteration) {
-    return artifactsInIteration(thread, iteration).some((a) => a.type === 'verify_report');
+    const reports = artifactsInIteration(thread, iteration).filter((artifact) => artifact.type === 'verify_report');
+    return eligibleArtifactsForPurpose(thread, reports, 'command_green').eligible.length > 0;
 }
 /**
  * Run the configured verify command and record a deterministic `verify_report` for the
@@ -170,7 +176,12 @@ export function runVerify(input, cwd) {
         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 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 });
     // --- Lock scope 2: re-check idempotency (by SNAPSHOT iteration), then append. ---
     return withLoopLock({
         cwd,
@@ -185,11 +196,24 @@ export function runVerify(input, cwd) {
             // 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 };
+                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 });
+            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 +222,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);