Add artifact-immutability lock at the grid boundary

Nodes get a SHA-256 checksum + byte-size + LOC snapshot locked in as
they render in the React Flow grid. Before a test run can use that
data it re-verifies against the lock and refuses to proceed on a
mismatch; the lock stays checked-out (with a visible timeout) until
the run returns and re-arms it. Jessica's reference photo is a fixed
UI asset, not a pipeline node, so it never enters the checkout cycle.

src/app/testbench/Testbench.tsx

@@ -2,11 +2,12 @@
 
 import { useEffect, useRef, useState } from "react";
 import Link from "next/link";
-import { ArrowLeft, Cpu, ExternalLink, FolderGit2, MessageSquareText, Play, TerminalSquare } from "lucide-react";
+import { ArrowLeft, Cpu, ExternalLink, FolderGit2, Lock, MessageSquareText, Play, ShieldAlert, TerminalSquare, Unlock } from "lucide-react";
 import PipelineGraph from "@/components/PipelineGraph";
 import ExpertChat from "@/components/ExpertChat";
 import { berylPipeline } from "@/lib/beryl-pipeline";
 import { buildSimulatedRunScript, TEST_RUN_BUDGET_MS, type SandboxLogLine } from "@/lib/testbench-log";
+import { snapshotArtifact, DEFAULT_LOCK_TIMEOUT_MS, type ArtifactSnapshot, type LockStatus } from "@/lib/integrity";
 
 type Target = {
   kind: "hf-space" | "github";
@@ -17,7 +18,7 @@ type Target = {
   ok: boolean;
 };
 
-type RunState = "idle" | "running" | "done";
+type RunState = "idle" | "running" | "done" | "blocked";
 
 export default function Testbench() {
   const [targets, setTargets] = useState<Target[] | null>(null);
@@ -33,6 +34,14 @@ export default function Testbench() {
   const [elapsedMs, setElapsedMs] = useState(0);
   const timers = useRef<ReturnType<typeof setTimeout>[]>([]);
   const tickRef = useRef<ReturnType<typeof setInterval> | null>(null);
+  const lockTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  // Artifact-immutability lock at the React Flow (grid) boundary: a checksum
+  // is locked in as soon as nodes render "at the front." Before they leave
+  // for a test run, the lock is re-verified; it stays checked-out until the
+  // run returns or DEFAULT_LOCK_TIMEOUT_MS elapses without returning.
+  const [lockSnapshot, setLockSnapshot] = useState<ArtifactSnapshot | null>(null);
+  const [lockStatus, setLockStatus] = useState<LockStatus>("locked");
 
   useEffect(() => {
     fetch("/api/testbench")
@@ -43,9 +52,15 @@ export default function Testbench() {
       })
       .catch((err) => setTargetsError(err instanceof Error ? err.message : "Failed to load test targets"));
 
+    snapshotArtifact(berylPipeline.nodes).then((snap) => {
+      setLockSnapshot(snap);
+      setLockStatus("locked");
+    });
+
     return () => {
       timers.current.forEach(clearTimeout);
       if (tickRef.current) clearInterval(tickRef.current);
+      if (lockTimeoutRef.current) clearTimeout(lockTimeoutRef.current);
     };
   }, []);
 
@@ -61,19 +76,45 @@ export default function Testbench() {
     );
   }
 
-  function runTest() {
+  async function runTest() {
     if (runState === "running") return;
     timers.current.forEach(clearTimeout);
     if (tickRef.current) clearInterval(tickRef.current);
+    if (lockTimeoutRef.current) clearTimeout(lockTimeoutRef.current);
+
+    setTab("console");
+
+    // Re-verify the lock right at the boundary where nodes leave the grid.
+    const fresh = await snapshotArtifact(berylPipeline.nodes);
+    if (!lockSnapshot || fresh.checksum !== lockSnapshot.checksum) {
+      setLockStatus("violated");
+      setRunState("blocked");
+      setLog([
+        {
+          atMs: 0,
+          level: "warn",
+          text: `BLOCKED — artifact checksum mismatch at the grid boundary. Locked ${
+            lockSnapshot?.checksum.slice(0, 12) ?? "n/a"
+          }… vs current ${fresh.checksum.slice(0, 12)}…. Nodes were modified after the lock; run refused.`,
+        },
+      ]);
+      return;
+    }
 
     const target = targets?.[activeTargetIdx];
     const label = target ? `${target.owner}/${target.name}` : "reference target";
     const script = buildSimulatedRunScript(berylPipeline, label);
 
-    setLog([]);
+    setLog([
+      {
+        atMs: 0,
+        level: "ok",
+        text: `Artifact lock verified — sha256:${fresh.checksum.slice(0, 16)}… · ${fresh.byteSize}B · ${fresh.loc} LOC · ${fresh.nodeCount} nodes. Checked out from the front for this run.`,
+      },
+    ]);
     setElapsedMs(0);
     setRunState("running");
-    setTab("console");
+    setLockStatus("checked-out");
 
     const start = Date.now();
     tickRef.current = setInterval(() => setElapsedMs(Date.now() - start), 200);
@@ -85,15 +126,48 @@ export default function Testbench() {
       timers.current.push(timer);
     });
 
+    lockTimeoutRef.current = setTimeout(() => {
+      setLockStatus((s) => (s === "checked-out" ? "expired" : s));
+      setLog((prev) => [
+        ...prev,
+        {
+          atMs: DEFAULT_LOCK_TIMEOUT_MS,
+          level: "warn",
+          text: `Artifact lock expired after ${DEFAULT_LOCK_TIMEOUT_MS / 1000}s away from the front without returning.`,
+        },
+      ]);
+    }, DEFAULT_LOCK_TIMEOUT_MS);
+
     const finishAt = script[script.length - 1]?.atMs ?? 0;
-    const finishTimer = setTimeout(() => {
+    const finishTimer = setTimeout(async () => {
       setRunState("done");
       if (tickRef.current) clearInterval(tickRef.current);
+      if (lockTimeoutRef.current) clearTimeout(lockTimeoutRef.current);
+      const returned = await snapshotArtifact(berylPipeline.nodes);
+      setLockSnapshot(returned);
+      setLockStatus("locked");
+      setLog((prev) => [
+        ...prev,
+        {
+          atMs: finishAt + 200,
+          level: "ok",
+          text: `Nodes returned to the front — lock re-armed at sha256:${returned.checksum.slice(0, 16)}….`,
+        },
+      ]);
     }, finishAt + 300);
     timers.current.push(finishTimer);
   }
 
   const budgetPct = Math.min(100, (elapsedMs / TEST_RUN_BUDGET_MS) * 100);
+  const lockRemainingMs = Math.max(0, DEFAULT_LOCK_TIMEOUT_MS - elapsedMs);
+
+  const LOCK_STATUS_LABEL: Record<LockStatus, string> = {
+    locked: "LOCKED",
+    "checked-out": "CHECKED OUT",
+    returned: "RETURNED",
+    expired: "EXPIRED",
+    violated: "VIOLATED",
+  };
 
   return (
     <div className="flex-1 flex flex-col h-[100dvh]">
@@ -216,10 +290,50 @@ export default function Testbench() {
 
             {tab === "console" && (
               <div className="p-4 flex flex-col gap-3 h-full">
+                <div
+                  className={`rounded-lg border px-2.5 py-2 flex flex-col gap-1 ${
+                    lockStatus === "expired" || lockStatus === "violated"
+                      ? "border-red-400/40 bg-red-500/5"
+                      : lockStatus === "checked-out"
+                      ? "border-amber-400/40 bg-amber-500/5"
+                      : "border-emerald-400/30 bg-emerald-500/5"
+                  }`}
+                >
+                  <div className="flex items-center gap-1.5 text-[10px] font-semibold">
+                    {lockStatus === "locked" && <Lock size={11} className="text-emerald-300" />}
+                    {lockStatus === "checked-out" && <Unlock size={11} className="text-amber-300" />}
+                    {(lockStatus === "expired" || lockStatus === "violated") && (
+                      <ShieldAlert size={11} className="text-red-300" />
+                    )}
+                    <span
+                      className={
+                        lockStatus === "expired" || lockStatus === "violated"
+                          ? "text-red-300"
+                          : lockStatus === "checked-out"
+                          ? "text-amber-300"
+                          : "text-emerald-300"
+                      }
+                    >
+                      ARTIFACT {LOCK_STATUS_LABEL[lockStatus]}
+                    </span>
+                    {lockStatus === "checked-out" && (
+                      <span className="ml-auto text-[9px] text-[var(--muted)]">
+                        {(lockRemainingMs / 1000).toFixed(0)}s until timeout
+                      </span>
+                    )}
+                  </div>
+                  {lockSnapshot && (
+                    <span className="text-[9.5px] text-[var(--muted)] font-mono">
+                      sha256:{lockSnapshot.checksum.slice(0, 16)}… · {lockSnapshot.byteSize}B · {lockSnapshot.loc} LOC ·{" "}
+                      {lockSnapshot.nodeCount} nodes
+                    </span>
+                  )}
+                </div>
+
                 <div className="flex items-center gap-2">
                   <button
                     onClick={runTest}
-                    disabled={runState === "running" || !targets}
+                    disabled={runState === "running" || !targets || !lockSnapshot}
                     className="deep-dive-btn rounded-full px-3 py-1.5 text-[11px] flex items-center gap-1.5 disabled:opacity-50"
                   >
                     <Play size={11} /> {runState === "running" ? "Running..." : "Run Test"}
@@ -286,6 +400,12 @@ export default function Testbench() {
           <span className="text-[9.5px] text-[var(--muted)] text-center leading-relaxed">
             Jessica — the source identity driving Vision + Avatar in this test run.
           </span>
+          <span className="flex items-center gap-1 text-[9px] font-semibold text-emerald-300 border border-emerald-400/30 rounded-full px-2 py-0.5">
+            <Lock size={9} /> ANCHORED — NEVER CHECKED OUT
+          </span>
+          <span className="text-[9px] text-[var(--muted)] text-center leading-relaxed">
+            Only pipeline nodes cross the grid boundary and get locked/verified. Jessica stays fixed at the front through every run.
+          </span>
         </aside>
       </div>
     </div>

src/lib/integrity.ts

@@ -0,0 +1,64 @@
+import type { PipelineNode } from "./types";
+
+// Artifact-immutability gate for the boundary between the React Flow grid
+// (nodes "at the front") and the Test Bench execution console. A snapshot is
+// locked the moment nodes render into the grid; before any run is allowed to
+// use that data, a fresh snapshot is recomputed and compared. A mismatch
+// blocks the run rather than silently proceeding on stale/altered data.
+
+export type ArtifactSnapshot = {
+  checksum: string;
+  byteSize: number;
+  loc: number;
+  nodeCount: number;
+};
+
+export type LockStatus = "locked" | "checked-out" | "returned" | "expired" | "violated";
+
+// Placeholder until the real duration is specified — how long a checked-out
+// artifact may stay away from the front before its lock is treated as expired.
+export const DEFAULT_LOCK_TIMEOUT_MS = 180_000;
+
+function canonicalize(nodes: PipelineNode[]): string {
+  const stable = nodes
+    .map((n) => ({
+      id: n.id,
+      label: n.label,
+      category: n.category,
+      summary: n.summary,
+      handoffOut: n.handoffOut ?? null,
+      expertNote: n.expertNote,
+      confidence: n.confidence ?? null,
+      implementations: n.implementations,
+    }))
+    .sort((a, b) => a.id.localeCompare(b.id));
+  return JSON.stringify(stable);
+}
+
+// No literal source files exist per node, so LOC is a defensible proxy: the
+// count of non-empty lines across each node's authored text fields.
+function countLoc(nodes: PipelineNode[]): number {
+  return nodes.reduce((sum, n) => {
+    const text = [n.summary, n.expertNote, n.handoffOut ?? ""].join("\n");
+    return sum + text.split("\n").filter((line) => line.trim().length > 0).length;
+  }, 0);
+}
+
+async function sha256Hex(text: string): Promise<string> {
+  const bytes = new TextEncoder().encode(text);
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return Array.from(new Uint8Array(digest))
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+}
+
+export async function snapshotArtifact(nodes: PipelineNode[]): Promise<ArtifactSnapshot> {
+  const canon = canonicalize(nodes);
+  const checksum = await sha256Hex(canon);
+  return {
+    checksum,
+    byteSize: new TextEncoder().encode(canon).length,
+    loc: countLoc(nodes),
+    nodeCount: nodes.length,
+  };
+}