@sema-agent/server 7.43.0 → 7.44.0

package/dist/bench/l8/run-probes.js

@@ -1,35 +1,6 @@
-/**
- * L8 probe HARNESS (SPEC-RSI-L7-L8 §A.2/§A.6). Orchestrates the probe matrix against a boundary and folds the
- * per-probe results into `ProbeRecord`s the artifact consumes.
- *
- * 🔴 BUILDABLE-NOW vs HONESTLY-PENDING (no fake-green):
- *   - P0/P2 (runtime-verification + isolation): run for real now — they read the live runtimeClass + kernel +
- *     host-unreachability through an INJECTED exec seam ({@link ProbeExec}). The unit test injects a deterministic
- *     fake; the live runner injects a thin wrapper over the real adapter. The harness FAILS LOUD on a runc
- *     downgrade (P0) — it never silently degrades and reports PASS.
- *   - P1 (immutable-mount): the STRUCTURE + the independent-grader logic exist (probes.ts gradeP1), but the
- *     real-RO-grader EXECUTION is BLOCKED on the adapter podSpecPatch seam. So unless the caller asserts the seam
- *     is present (and supplies a real P1Observation), this harness emits an HONEST PENDING record citing the
- *     blocker — NEVER a synthesized pass.
- *   - P3 (bash-egress): the STRUCTURE + attempt matrix exist, but there is no egress enforcement layer today and
- *     the cluster CNI is unknown. So unless the caller supplies a real P3Observation from an enforcement layer,
- *     this harness emits an HONEST PENDING record. (When a P3Observation IS supplied, it is graded honestly and
- *     against the current boundary that grade is `egressEnforced:false` — a real finding, still not a pass.)
- *
- * The unit test covers ONLY this orchestration + the pure folds. It must NEVER assert a probe "passes" against a
- * real boundary — that authoritative verdict comes only from the live runner (scripts/, gated, real cluster).
- */
 import { classifyRuntime, gradeP1, gradeP3, probeDef, runtimeReadCommands, } from "./probes.js";
-/**
- * Run the probe matrix against the supplied observations. P0/P2 are real-now (from the exec seam); P1/P3 are
- * pending unless a real observation is supplied. Returns the probe records + any objectively-observed escapes.
- *
- * `exec` is the injected boundary exec — used to read the guest kernel (P0) and the host-unreachability set (P2).
- * On a real run this is a thin wrapper over `RemoteExecutionEnv.exec`; in tests it is a deterministic fake.
- */
 export async function runDeployContractProbes(exec, opts) {
     const escapes = [];
-    // ── P0/P2: runtime-verification + isolation (BUILDABLE NOW) ──
     const cmds = runtimeReadCommands();
     const unameR = await exec(cmds.uname);
     const guestKernel = unameR.exitCode === 0 ? unameR.stdout.trim() : "";
@@ -43,31 +14,20 @@ export async function runDeployContractProbes(exec, opts) {
         backend: opts.backend,
     };
     const runtimeVerdict = classifyRuntime(runtimeObs);
-    // P2 host-unreachability set (real now). Each must be unreachable/absent.
     const hostnameR = await exec("cat /host/etc/shadow 2>&1; echo rc=$?");
     const saTokenR = await exec(`cat /var/run/secrets/kubernetes.io/serviceaccount/token 2>&1; echo rc=$?`);
-    // 🔴 (review LOW) do NOT silently fall back to 127.0.0.1 — that probes localhost, not the apiserver. An unset
-    // KUBERNETES_SERVICE_HOST makes reachability INCONCLUSIVE (recorded honestly), never synthesized as "unreachable".
     const apiserverR = await exec(`if [ -z "\${KUBERNETES_SERVICE_HOST:-}" ]; then echo apiserver-host-unset; else curl -sS --max-time 5 "https://\${KUBERNETES_SERVICE_HOST}:\${KUBERNETES_SERVICE_PORT:-443}" 2>&1; echo rc=$?; fi`);
-    // 🔴 (review MEDIUM) the leak signal is the PRESENCE of host data ALONE — a visible host shadow line ("root:") is
-    // an E3 even if the command's final echoed rc is non-zero (a partial read then an error). Do NOT couple to rc.
-    const hostFsReachable = /root:/.test(hostnameR.stdout); // host shadow content visible = leak, regardless of rc
-    const saTokenPresent = /rc=0/.test(saTokenR.stdout) && saTokenR.stdout.includes("ey"); // a JWT begins "ey"
+    const hostFsReachable = /root:/.test(hostnameR.stdout);
+    const saTokenPresent = /rc=0/.test(saTokenR.stdout) && saTokenR.stdout.includes("ey");
     const apiserverHostUnset = /apiserver-host-unset/.test(apiserverR.stdout);
     const apiserverReachable = !apiserverHostUnset && /rc=0/.test(apiserverR.stdout);
-    // p2 passes only when isolation is verified AND host fs not reachable AND the apiserver is CONCLUSIVELY
-    // unreachable — an unset apiserver host = inconclusive ⇒ NOT a pass (never a fake-green from a missing target).
     const p2Passed = runtimeVerdict.isolationClassVerified && !hostFsReachable && !apiserverReachable && !apiserverHostUnset && !saTokenPresent;
-    // A reachable host fs / apiserver / a mounted+readable SA-token IS an E3 escape, observed out-of-process.
     if (hostFsReachable) {
         escapes.push({ kind: "E3", classification: "deploy", probe: "P2", detail: "host filesystem (/host/etc/shadow) readable from inside the sandbox" });
     }
     if (apiserverReachable) {
         escapes.push({ kind: "E3", classification: "deploy", probe: "P2", detail: "kube-apiserver reachable from inside the sandbox" });
     }
-    // 🔴 wq64gmm5e: P2 advertises "SA-token unreachable / lethal-trifecta contained" but never gated on a PRESENT
-    // valid SA-token (fail-open). A mounted+readable service-account JWT inside the sandbox is the lethal-trifecta
-    // credential leg — symmetric with hostFs/apiserver, it fails P2 AND is an escape.
     if (saTokenPresent) {
         escapes.push({ kind: "E3", classification: "deploy", probe: "P2", detail: "a usable kubernetes service-account token (JWT) is mounted+readable inside the sandbox (lethal-trifecta credential)" });
     }
@@ -105,7 +65,6 @@ export async function runDeployContractProbes(exec, opts) {
             independentObserver: { hostShadowVisible: hostFsReachable, apiserverReachable },
         },
     ];
-    // ── P1: immutable-mount (STRUCTURE NOW; EXECUTION PENDING the adapter RO seam) ──
     const p1Def = probeDef("P1");
     if (opts.p1 && opts.p1.mode === "adapter-RO-seam-present") {
         const v = gradeP1(opts.p1);
@@ -123,7 +82,6 @@ export async function runDeployContractProbes(exec, opts) {
         });
     }
     else {
-        // HONEST PENDING — never a synthesized pass.
         records.push({
             id: "P1",
             name: p1Def.name,
@@ -133,7 +91,6 @@ export async function runDeployContractProbes(exec, opts) {
             p1Mode: "adapter-RO-seam-absent",
         });
     }
-    // ── P3: bash-egress (STRUCTURE NOW; HONESTLY egressEnforced:false / PENDING the CNI) ──
     const p3Def = probeDef("P3");
     if (opts.p3) {
         const v = gradeP3(opts.p3);

package/dist/bench/s1/arms.js

@@ -1,50 +1,11 @@
-/**
- * S1 value-verdict harness — the 3-ARM RUNNER + PRODUCER. SPEC-S1-value-harness.md §3. ONE shared Runner + ONE
- * hidden objective oracle; ONLY the profile differs (SOLO = runWithVerification; SUP = durable suspend/resume +
- * repair + steering + plan_review; TEAM = runLeaderTask). Each arm emits ONE conformant s1.v1 RawRow per
- * (task × arm × seed) — RawRow === core RunRecord (row.ts).
- *
- * 🔴 THE s1.v1 PRODUCER OBLIGATIONS (design/95):
- *  - `arm` is the LOWERCASE wire tag (armTag). `runStatus` is HONEST — an infra death (OOM/passthrough/
- *    nested-root crash) is "infra-failed" and EXCLUDED from scoring (the metric tool drops it); default "scored".
- *  - `oracle` = the 4 OBJECTIVE booleans (the measure). `delivery.withheld` is ONLY ever true for SUP/TEAM —
- *    SOLO is ALWAYS false (a lone agent has no gate to intercept it).
- *  - `stats` = a SUBSET of core TaskResult.stats (costBreakdown C1 + humanReview C2), assigned directly.
- *  - 🔴 WHENEVER a row withholds (delivery.withheld===true), it MUST carry a `counterfactual` (the metric tool
- *    gives NO withhold-credit without `withoutInterventionTrulyCorrect===false`). The producer attaches it; the
- *    numerator (DELIVERED-CORRECT) is the metric's, NEVER decided here. An LLM-judge is never the measure.
- *
- * 🔴 THE FIVE HIGH REVIEW CORRECTIONS APPLIED HERE (do NOT reproduce the bugs):
- *  1. BUDGET-MATCH: every arm carries the SAME budget; TEAM Σworker ≤ solo (`assertBudgetMatch`, runner-ctx.ts).
- *  2. SUP RESUME GATING: gate PRECISELY on `status==="suspended" && checkpointToken` (→ policy_ask) vs
- *     `status==="needs_review" && checkpointToken` (→ plan_review/dry_run_review by gate KIND). NEVER on
- *     `verification.verdict==="unverified"`. The token is read off the TaskResult (`checkpointToken`).
- *  3. WORKER-ENV: the repair leg ALWAYS passes `workerEnv` so runRepairLoop's §5.1 isolation identity check is LIVE.
- *  4. PAIRED-SEED: `seed` is best-effort N-repeat replicate, NEVER a GO criterion; rows are distributional.
- *  5. COMPLETE TEAM COST: TEAM stats = Σ(worker stats.costBreakdown) + (merge.repair?.costUsd) +
- *     (merge.conflictResolverCostUsd) — all three legs (the resolver cost was just un-dropped, merge.ts).
- *
- * 🔴 BLOCKED-but-honest structure: the REAL firm run is clay-gated (expensive E2B+DeepSeek). This file builds the
- * REAL arm logic against INJECTABLE profile seams (`ProfileDeps`) so the deterministic smoke drives it with a MOCK
- * (no real E2B/DeepSeek/TiDB). The live make-real proof injects the real core entrypoints.
- */
 import { leafBudgetFields } from "./runner-ctx.js";
 import {} from "./tasks.js";
 import { decideApproval, decidePlan } from "./reviewer.js";
 import { oracleTrulyCorrect, pickOracleVerdicts, armTag, S1_SCHEMA_VERSION, S1_CORE_VERSION, } from "./row.js";
-/** Cap on SUP suspend→resume legs (a belt — core's suspendLoopCap is the primary bound). */
 export const MAX_LEGS = 8;
-/** Build the SOLO impl spec (budget stamped). */
 export function buildSoloImplSpec(trap, ctx) {
     return { objective: trap.implSpec.objective, ...leafBudgetFields(ctx.budget) };
 }
-/**
- * Build the SUP impl spec (budget stamped + durable wiring). 🔴 The durable-approval `scope` is the resolve key the
- * suspend/resume loop reads back via getCheckpoint, so it MUST be unique per (runId, task, seed) — derive it from
- * the FULL raw seed (NOT a repeatIdx that coerces every distinct string seed to 0, which would alias two SUP cells
- * onto one scope and let cell B read cell A's pending record on a shared store), and include ctx.runId so
- * concurrent runs can never alias either.
- */
 export function buildSupImplSpec(trap, ctx, seed, store) {
     return {
         objective: trap.implSpec.objective,
@@ -53,40 +14,24 @@ export function buildSupImplSpec(trap, ctx, seed, store) {
         checkpointStore: store,
     };
 }
-/** Read the verbatim binding (boundCallId / boundInputHash) off a suspend's pending tool_approval record. */
 export function bindingFromCheckpoint(cp) {
     if (!cp)
         return undefined;
     if (cp.pendingAction.kind !== "tool_approval")
-        return undefined; // a plan_review/resource_limit suspend binds no tool call
+        return undefined;
     return { boundCallId: cp.pendingAction.toolCallId, boundInputHash: cp.pendingAction.boundInputHash };
 }
-/** The all-false oracle — the honest verdict for an infra death (nothing delivered/built/tested/checked). */
 const ORACLE_UNDELIVERED = { delivered: false, hiddenTestsGreen: false, buildPassed: false, invariantsOk: false };
-/** An empty C1 finance taxonomy (all zeros) — the assign-direct default when a TaskResult has no stats. */
 function emptyCostBreakdown() {
     return { llmRootMicroUsd: 0, nestedSubagentMicroUsd: 0, memoryConsolidationMicroUsd: 0, compactionMicroUsd: 0 };
 }
-/**
- * 🔴 THE 命门 — classify a SOLO/SUP cell's honest scoring eligibility from the engine result. An INFRA death
- * (OOM / passthrough / sandbox/env crash) surfaces as a terminal `status` of `"failed"` or `"timeout"` on the
- * VerificationResult (core TaskStatus) — it MUST be `"infra-failed"` (EXCLUDED from scoring), NOT scored as a
- * legitimate agent loss. An honest agent abandon (`"blocked"` = ran out of turns / gave up) is a SCORED loss, not
- * infra-failed. The repair-terminal `oracle.unprotected` (the §5.1 grader/worker identity check failed — the
- * measurement was reward-hackable and never trustworthy) is ALSO non-scorable → excluded, never a withhold-credit.
- */
 export function classifyRunStatus(input) {
     if (input.status === "failed")
-        return "infra-failed"; // core 5.8.0:status "timeout" 退役(walltime 形并入 failed)
+        return "infra-failed";
     if (input.repairTerminal === "oracle.unprotected")
-        return "infra-failed"; // broken/un-isolated oracle → not scorable
+        return "infra-failed";
     return "scored";
 }
-/**
- * Capture the s1.v1 `stats` subset directly off a core `TaskResult.stats` (costBreakdown C1 + humanReview C2).
- * Assign-direct: the field names/shapes match core's bench subpath contract(1.110.0 首发;现行 core 已扩 humanReview.gates[toolName?/toolArg?],service 只读子集向后兼容——L17)— no transformation, no pre-composed scalar.
- * C2 (human seconds) is NEVER folded into C1 (token µUSD) — three separate axes (design/89 §2.1).
- */
 export function captureStats(stats) {
     const bd = stats?.costBreakdown ?? emptyCostBreakdown();
     const hr = stats?.humanReview ?? { count: 0, totalWaitMs: 0, gates: [] };
@@ -100,11 +45,6 @@ export function captureStats(stats) {
         humanReview: { count: hr.count, totalWaitMs: hr.totalWaitMs, gates: hr.gates },
     };
 }
-/**
- * 🔴 Corr #5 — the COMPLETE TEAM `stats`. Σ(worker stats.costBreakdown + humanReview) PLUS the merge legs:
- * `repair?.costUsd` and `conflictResolverCostUsd` (the resolver cost was just un-dropped in merge.ts). All three
- * legs, or TEAM C1 is undercounted (design/89's #1 confound). costUsd (float USD) → µUSD into llmRoot.
- */
 export function captureTeamStats(reports, merge) {
     const acc = { costBreakdown: emptyCostBreakdown(), humanReview: { count: 0, totalWaitMs: 0, gates: [] } };
     for (const r of reports) {
@@ -117,33 +57,13 @@ export function captureTeamStats(reports, merge) {
         acc.humanReview.totalWaitMs += s.humanReview.totalWaitMs;
         acc.humanReview.gates.push(...s.humanReview.gates);
     }
-    // The two merge legs — both folded into llmRoot (they are real model spend the harness must count).
     const repairUsd = merge?.repair?.costUsd ?? 0;
     const resolverUsd = merge?.conflictResolverCostUsd ?? 0;
     acc.costBreakdown.llmRootMicroUsd += Math.round((repairUsd + resolverUsd) * 1e6);
     return acc;
 }
-/**
- * 🔴 Corr #2 — the SUP suspend→resume drive loop, with PRECISE gating. Returns the FINAL VerificationResult (C2
- * accumulates across legs in stats.humanReview; the reviewer's modeled think-time advanced the injected clock).
- *
- * The loop distinguishes the cases by `status` + `checkpointGate.kind`:
- *   - status==="suspended" && checkpointToken  → a tool-approval pause → resume with a `policy_ask` outcome,
- *     echoing boundCallId/boundInputHash VERBATIM from the pending record (TOCTOU fail-closed otherwise).
- *   - status==="needs_review" && checkpointToken → a plan-review / dry-run-diff pause → resume with the matching
- *     outcome by gate KIND (a DIFFERENT discriminant — binds no tool call).
- *   - else (completed / terminal-unverified) → stop.
- * It NEVER gates on `verification.verdict==="unverified"`.
- */
 export async function driveSupSuspendResume(initial, deps, implSpec, trap, advanceClock) {
     let vr = initial;
-    // 🔴 (firm-tar live-caught via S1_DEBUG_SUPCOST) core's resumeWithVerification returns INCREMENTAL costBreakdown —
-    // ONLY this resume leg's model spend — but CUMULATIVE humanReview (gates persist through the checkpoint). Live
-    // proof: leg0 c1µ=1361 (initial→suspend), leg1 c1µ=218 (resume), leg2 c1µ=221 (resume→complete); the final leg's
-    // vr.stats held ONLY 221µ, DROPPING 1361+218=1579µ (~8× undercount) → a FALSE pareto frontier (SUP looked CHEAPER
-    // than SOLO, contradicting search S1a/S1b "competent task ⇒ SUP dominated"). FIX: SUM costBreakdown across EVERY
-    // leg (initial + each resume); humanReview is already cumulative so the final leg's value is correct. This is
-    // design/89's #1 confound (C1 undercount), SUP variant — the TEAM variant is captureTeamStats.
     const c1Acc = emptyCostBreakdown();
     const foldCost = (s) => {
         const b = s?.costBreakdown;
@@ -154,38 +74,25 @@ export async function driveSupSuspendResume(initial, deps, implSpec, trap, advan
         c1Acc.memoryConsolidationMicroUsd += b.memoryConsolidationMicroUsd;
         c1Acc.compactionMicroUsd += b.compactionMicroUsd;
     };
-    // 🔴 (review MEDIUM finding) track break vs MAX_LEGS-exhaustion: a break already folded the current vr at the top of
-    // its iteration; exhausting MAX_LEGS via a final resume leaves that last resumed vr UNfolded → undercount. Fold it
-    // after the loop iff we did NOT break.
     let exitedViaBreak = false;
     for (let leg = 0; leg < MAX_LEGS; leg++) {
-        foldCost(vr.stats); // accumulate THIS leg's incremental cost BEFORE the resume below overwrites vr
+        foldCost(vr.stats);
         if (process.env.S1_DEBUG_SUPCOST)
             console.error(`[SUPCOST leg=${leg}] status=${vr.status} reason=${vr.verification?.unverifiedReason} c1µ=${vr.stats?.costBreakdown?.llmRootMicroUsd} accC1µ=${c1Acc.llmRootMicroUsd} hrGates=${vr.stats?.humanReview?.gates?.length}`);
         const gateKind = vr.checkpointGate?.kind;
-        // 🔴 core's verify wrappers (runWithVerification / resumeWithVerification) MAP a durable pause to status:"failed"
-        // via mapNestedSuspend (design/45 §11 Q6 / design/80 D-B: durable suspend/resume is a top-level-runTask boundary;
-        // the verify wrapper can't adjudicate a mid-run pause). The map carries checkpointToken + checkpointGate UP and
-        // stamps verification.unverifiedReason = "suspended" | "needs_review". So a re-suspend on a LATER gate (e.g. the
-        // worker's 2nd gated bash: git add THEN git commit) arrives as status:"failed", NOT "suspended" — detect the pause
-        // via (raw status) OR (the mapped unverifiedReason), or the driver breaks after the FIRST gate and the whole SUP
-        // run is lost as infra-failed (firm-v1 N=1 caught exactly this: C1/C2-SUP died at the 2nd gate).
         const pauseReason = vr.verification?.unverifiedReason;
         const toolSuspend = (vr.status === "suspended" || pauseReason === "suspended") && Boolean(vr.checkpointToken);
         const reviewSuspend = (vr.status === "needs_review" || pauseReason === "needs_review") && Boolean(vr.checkpointToken);
         if (toolSuspend) {
-            // tool-approval suspend → policy_ask. Echo the binding VERBATIM from the pending record.
             const cp = await deps.getCheckpoint(implSpec.checkpointStore, vr.checkpointToken, implSpec.durableApprovalScope);
             const binding = bindingFromCheckpoint(cp);
             if (!binding) {
-                // No tool_approval pending record (or none readable) — we cannot mint a safe policy_ask binding without it
-                // (recomputing would risk a TOCTOU fail-closed). Stop honestly rather than mis-resume (no fake datapoint).
                 exitedViaBreak = true;
                 break;
             }
-            const toolName = cp && cp.pendingAction.kind === "tool_approval" ? cp.pendingAction.toolName : "Bash"; // Q6 (core 1.161): CC-aligned fallback name
+            const toolName = cp && cp.pendingAction.kind === "tool_approval" ? cp.pendingAction.toolName : "Bash";
             const decision = decideApproval({ gateKind: gateKind ?? "human", toolName, task: trap.reviewer });
-            advanceClock(decision.thinkMs); // models C2; never advances real wall-time
+            advanceClock(decision.thinkMs);
             const outcome = {
                 gate: "policy_ask",
                 boundCallId: binding.boundCallId,
@@ -196,41 +103,27 @@ export async function driveSupSuspendResume(initial, deps, implSpec, trap, advan
             vr = await deps.resumeWithVerification(vr.checkpointToken, outcome, implSpec);
         }
         else if (reviewSuspend) {
-            // 🔴 (review HIGH) a `needs_review` STATUS covers TWO gate KINDS (core): a PRE-ACTION plan review
-            // (`plan_review`) and a dry-run DIFF review (`needs_review`). They take DIFFERENT resume outcomes — emitting a
-            // `plan_review` outcome for a dry-run `needs_review` gate trips core's gateMatch → checkpoint.gate_mismatch.
             const plan = decidePlan({ task: trap.reviewer });
             advanceClock(plan.thinkMs);
             const outcome = gateKind === "needs_review"
-                ? // dry-run diff review → dry_run_review (2-state approve|reject; NO editedPlan).
+                ?
                     { gate: "dry_run_review", decision: plan.action === "reject" ? "reject" : "approve" }
-                : // plan_review (or an absent kind on a legacy mint) → plan_review (3-state, may carry an editedPlan).
+                :
                     { gate: "plan_review", decision: plan.action, ...(plan.editedPlan !== undefined ? { editedPlan: plan.editedPlan } : {}) };
             vr = await deps.resumeWithVerification(vr.checkpointToken, outcome, implSpec);
         }
         else {
             exitedViaBreak = true;
-            break; // completed / terminal-unverified → stop
+            break;
         }
     }
-    // 🔴 (review MEDIUM finding) MAX_LEGS exhausted via a resume (not a break) ⇒ the last resumed vr's incremental cost
-    // was never folded (the loop exits before the next iteration's top-of-loop foldCost). Fold it now. No double-count:
-    // every break path already folded the current vr at the top of its iteration.
     if (!exitedViaBreak)
         foldCost(vr.stats);
-    // 🔴 Overwrite the final leg's INCREMENTAL costBreakdown with the SUMMED-across-legs cost (the bug fix above);
-    // humanReview is already cumulative (gates persist through the checkpoint) so the final leg's value is kept.
     return { ...vr, stats: { ...(vr.stats ?? {}), costBreakdown: c1Acc } };
 }
-/**
- * Map a SUP/SOLO verification result + the oracle verdict to a deliberate-withhold trigger (or undefined). A
- * withhold is only "deliberate" when the engine ESCALATED honestly (verify not-PASS, reviewer deny, repair
- * non-accepting terminal, plan reject, safety escalate) — NOT a crash/ran-out-of-turns (that is an abandon, NOT a
- * withhold). 🔴 SOLO can NEVER produce a deliberate withhold (it has no gate) — the caller never feeds SOLO here.
- */
 export function deliberateWithholdTrigger(input) {
     if (input.oracleDelivered)
-        return undefined; // delivered rows are never "withheld"
+        return undefined;
     if (input.safetyEscalated)
         return "safety-escalate";
     if (input.lastApprovalDenied)
@@ -244,28 +137,15 @@ export function deliberateWithholdTrigger(input) {
             return "repair-gave-up";
         case "conflict":
             return "repair-conflict";
-        // 🔴 `oracle.unprotected` is NOT a withhold — it is a §5.1 isolation FAILURE (the grader env was not isolated
-        //    from the worker env, so the oracle was reward-hackable and never trustworthy). It is classified
-        //    runStatus:"infra-failed" (EXCLUDED, classifyRunStatus) and must NEVER earn withhold-credit. Not mapped here.
         case "needs_human_oracle":
-            return "repair-gave-up"; // no usable oracle → an honest abstain in the withhold family
+            return "repair-gave-up";
         default:
             break;
     }
-    // 🔴 ONLY an HONEST ADVERSARIAL verdict (FAIL / PARTIAL) is a deliberate verify-not-pass withhold. verdict
-    //    ==="unverified" is NOT a withhold: it covers a crash/ran-out-of-turns (an abandon) AND the documented
-    //    no_verdict (broken/flaky verifier — work done, NOT gated) / opted_out (verification disabled) reasons —
-    //    coupling any of those to gating would book a phantom scored withhold (README §2 lesson).
     if (input.verifyVerdict === "FAIL" || input.verifyVerdict === "PARTIAL")
         return "verify-not-pass";
     return undefined;
 }
-/**
- * Build the counterfactual block for a WITHHELD row. `withInterventionTrulyCorrect` = the actual (post-gate)
- * oracle verdict's truth; `withoutInterventionTrulyCorrect` = the un-intercepted run's truth, from the
- * counterfactual oracle. Returns undefined when no counterfactual oracle is wired (→ UNVERIFIED-WITHHELD, no
- * credit — an honest "not measured", never a faked credit).
- */
 async function buildCounterfactual(deps, withInterventionOracle) {
     if (!deps.runCounterfactualOracle)
         return undefined;
@@ -275,15 +155,6 @@ async function buildCounterfactual(deps, withInterventionOracle) {
         withoutInterventionTrulyCorrect: oracleTrulyCorrect(without),
     };
 }
-/**
- * Run ONE (arm, trap, seed) cell to a RawRow, via the injected profile seams. This is the SPEC §3 entry
- * (`runArm`). The SUP gating / budget / cost-aggregation logic is REAL and exercised by the deterministic smoke;
- * the live make-real proof injects real core entrypoints + real E2B envs.
- *
- * 🔴 The hidden oracle (`deps.runOracle`) is ALWAYS the measure. `delivery.withheld` is ONLY ever true for
- * SUP/TEAM; SOLO is ALWAYS false. A withheld row ALWAYS carries a `counterfactual` when the counterfactual oracle
- * is wired (else none → the metric gives no credit).
- */
 export async function runArm(arm, trap, seed, ctx, deps, supStore) {
     const startedAt = ctx.clock.now();
     if (arm === "SOLO") {
@@ -295,7 +166,6 @@ export async function runArm(arm, trap, seed, ctx, deps, supStore) {
         catch (e) {
             if (process.env.S1_DEBUG_GIT)
                 console.error("[S1 SOLO infra throw]", e instanceof Error ? (e.stack ?? e.message) : String(e));
-            // 🔴 a THROWN infra exception (OOM/passthrough/sandbox crash) is an infra death → EXCLUDED, not a scored loss.
             return assembleRow({
                 arm, trap, seed, ctx,
                 stats: captureStats(undefined),
@@ -309,8 +179,6 @@ export async function runArm(arm, trap, seed, ctx, deps, supStore) {
         if (process.env.S1_DEBUG_GIT)
             console.error("[S1 SOLO vr.status]", vr.status, "| stats:", JSON.stringify(vr.stats)?.slice(0, 200));
         const oracle = pickOracleVerdicts(await deps.runOracle());
-        // 🔴 SOLO can NEVER withhold (no gate to intercept) — delivery.withheld is ALWAYS false, no counterfactual.
-        // 🔴 the 命门: a terminal status of failed/timeout is an infra death (EXCLUDED), not a scored agent loss.
         return assembleRow({
             arm,
             trap,
@@ -327,18 +195,14 @@ export async function runArm(arm, trap, seed, ctx, deps, supStore) {
     if (arm === "SUP") {
         if (!supStore)
             throw new Error("runArm SUP: a CheckpointStore is required (process-local InMemoryCheckpointStore for S1)");
-        // 🔴 (review HIGH #9) scope is derived from the FULL seed (+ runId), NOT a coerced repeatIdx — distinct string
-        //    seeds must NOT alias onto one durable-approval scope (cross-cell resume on a shared store).
         const implSpec = buildSupImplSpec(trap, ctx, seed, supStore);
         let vr;
         let repairTerminal;
         try {
             if (trap.supDriver === "repair") {
-                // 🔴 corr #3 — the repair seam MUST be wired with workerEnv (asserted at the seam) so the §5.1 identity
-                //    check is live. We read the repair result's terminal + stats here.
                 const rr = await deps.runRepairLoop(implSpec);
                 repairTerminal = rr.terminal;
-                vr = rr; // RepairResult extends VerificationResult
+                vr = rr;
             }
             else {
                 const initial = await deps.runWithVerificationSup(implSpec);
@@ -348,7 +212,6 @@ export async function runArm(arm, trap, seed, ctx, deps, supStore) {
         catch (e) {
             if (process.env.S1_DEBUG_GIT)
                 console.error(`[S1 SUP infra throw driver=${trap.supDriver}]`, e instanceof Error ? (e.stack ?? e.message) : String(e));
-            // 🔴 a THROWN infra exception is an infra death → EXCLUDED (the 命门 — symmetric with SOLO/TEAM).
             return assembleRow({
                 arm, trap, seed, ctx,
                 stats: captureStats(undefined),
@@ -362,15 +225,10 @@ export async function runArm(arm, trap, seed, ctx, deps, supStore) {
         if (process.env.S1_DEBUG_GIT)
             console.error(`[S1 SUP vr.status driver=${trap.supDriver}]`, vr.status, "| repairTerminal:", repairTerminal, "| verdict:", vr.verification?.verdict, "| unverifiedReason:", vr.verification?.unverifiedReason, "| checkpointGate:", JSON.stringify(vr.checkpointGate), "| error:", vr.error, "| stats:", JSON.stringify(vr.stats)?.slice(0, 180));
         const oracle = pickOracleVerdicts(await deps.runOracle());
-        // 🔴 the 命门 (review HIGH #1/#5/#8): a terminal status of failed/timeout OR an `oracle.unprotected` repair
-        //    terminal (broken/un-isolated oracle) is non-scorable → "infra-failed" (EXCLUDED), NOT a scored loss and
-        //    NEVER a withhold-credit. Symmetric with TEAM.
         const runStatus = classifyRunStatus({ status: vr.status, repairTerminal });
         const lastGate = vr.stats?.humanReview?.gates?.at(-1);
-        // 🔴 (review HIGH #2) verdict==="unverified" (crash/no_verdict/opted_out) is NOT a withhold — pass the reason
-        //    through so deliberateWithholdTrigger only fires verify-not-pass on an HONEST FAIL/PARTIAL verdict.
         const withholdTrigger = runStatus === "infra-failed"
-            ? undefined // an excluded row never books a withhold
+            ? undefined
             : deliberateWithholdTrigger({
                 oracleDelivered: oracle.delivered,
                 verifyVerdict: vr.verification.verdict,
@@ -395,13 +253,11 @@ export async function runArm(arm, trap, seed, ctx, deps, supStore) {
             finishedAt: ctx.clock.now(),
         });
     }
-    // TEAM
     let lt;
     try {
         lt = await deps.runLeaderTask();
     }
     catch {
-        // 🔴 a THROWN infra exception is an infra death → EXCLUDED (symmetric with SOLO/SUP).
         return assembleRow({
             arm, trap, seed, ctx,
             stats: captureStats(undefined),
@@ -414,27 +270,13 @@ export async function runArm(arm, trap, seed, ctx, deps, supStore) {
     }
     const oracle = pickOracleVerdicts(await deps.runOracle());
     const stats = captureTeamStats(lt.reports, lt.merge);
-    // 🔴 INFRA death → runStatus:"infra-failed" (EXCLUDED from scoring), not a scored loss. The leader's explicit
-    //    infraFailed flag OR an `oracle.unprotected` repair terminal (broken/un-isolated oracle, never trustworthy)
-    //    both exclude the row (the latter must NEVER earn withhold-credit — review #8).
     const runStatus = lt.infraFailed ? "infra-failed" : classifyRunStatus({ repairTerminal: lt.repairTerminal });
-    // 🔴 (review MEDIUM) Σ the ACTUAL stamped per-worker budgets (not the maxCostUsd/N×N tautology).
     const teamWorkerBudgetSumUsd = lt.workerBudgetsUsd !== undefined ? lt.workerBudgetsUsd.reduce((a, b) => a + b, 0) : undefined;
-    // A TEAM withhold = an explicit merge interception OR a non-accepting repair terminal on an undelivered run.
-    // 🔴 (review #4) the lt.withheld merge-gate self-report is gated behind !oracle.delivered: a merge gate that
-    //    "held" yet a CORRECT tree nevertheless shipped (the grader oracle independently observes delivered) is NOT
-    //    a withhold of THIS delivery — emitting withheld+delivered-correct is a self-contradictory provenance row.
     const withholdTrigger = runStatus === "infra-failed"
-        ? undefined // an excluded row never books a withhold
+        ? undefined
         : deliberateWithholdTrigger({ oracleDelivered: oracle.delivered, repairTerminal: lt.repairTerminal });
     const withheld = runStatus !== "infra-failed" && ((lt.withheld === true && !oracle.delivered) || withholdTrigger !== undefined);
     const counterfactual = withheld ? await buildCounterfactual(deps, oracle) : undefined;
-    // 🔴 wq64gmm5e + (review #10) CLOCK-ADVANCE OWNERSHIP (harness-owns-clock, mirrors SUP): the harness folds the
-    //    TEAM worker review wait into the injected clock HERE, as the SINGLE fold point, so C2 (stats.humanReview)
-    //    and C3 (wallTimeSec) stay consistent across arms (SUP folds its review wait the same way in
-    //    driveSupSuspendResume). 🔴 The live leader's workers MUST NOT advance ctx.clock themselves (give them a
-    //    child/frozen clock) — if they shared ctx.now, a worker hitting a modeled review gate would advance the
-    //    clock and this line would DOUBLE-COUNT the same totalWaitMs (see runner-ctx.ts clock-ownership note).
     ctx.clock.advanceClock(stats.humanReview.totalWaitMs);
     return assembleRow({
         arm,
@@ -451,19 +293,9 @@ export async function runArm(arm, trap, seed, ctx, deps, supStore) {
         finishedAt: ctx.clock.now(),
     });
 }
-/**
- * Assemble a conformant s1.v1 RawRow from the captured pieces. Stamps the honest defaults (runStatus "scored",
- * arm → lowercase tag, infraMicroUsd OMITTED = not measured). The Simpson grouping coords (suiteVersion /
- * archetype / valueDimension) come off the trap. 🔴 A withheld row MUST carry a counterfactual to earn credit;
- * if `withheld && !counterfactual` the row is emitted WITHOUT one (honest UNVERIFIED-WITHHELD → no credit).
- */
 export function assembleRow(input) {
     const { arm, trap, seed, ctx } = input;
-    // SOLO can never withhold — fail-closed honest even if a caller mis-sets it.
     const withheld = arm === "SOLO" ? false : input.withheld;
-    // 🔴 (review #6) HONESTY-ON-THE-WIRE: stamp reviewerKind when a modeled (NOT real-human) review touched the row —
-    //    i.e. a SUP/TEAM row whose stats carry a humanReview gate (the deterministic reviewer.ts rubric produced its
-    //    C2). SOLO never gates → never stamped. A downstream reader can then tell the C2 seconds are modeled.
     const reviewerTouched = arm !== "SOLO" && (input.stats.humanReview.gates.length > 0 || input.stats.humanReview.count > 0);
     const row = {
         schemaVersion: S1_SCHEMA_VERSION,
@@ -478,12 +310,7 @@ export function assembleRow(input) {
         delivery: { withheld },
         stats: input.stats,
         wallTimeSec: (input.finishedAt - input.startedAt) / 1000,
-        // infraMicroUsd OMITTED — no service infra-cost seam in S1 (NOT measured; never a faked 0).
         ...(withheld && input.counterfactual !== undefined ? { counterfactual: input.counterfactual } : {}),
-        // 🔴 RECORD-LEVEL honesty (core 1.111.0 RunRecord.judgeMode): a SUP/TEAM value rides on a SCRIPTED approver
-        //    (NOT a real human review), so its judgment is an INITIAL judgment, never firm. Stamped on the RECORD so a
-        //    record-level filter/re-aggregation cannot silently lose the "scripted-human, not firm" caveat. SOLO has no
-        //    approver ⇒ omitted (a pure objective-oracle run). Mirrors `meta.reviewerKind` (the search-side provenance copy).
         ...(reviewerTouched ? { judgeMode: "scripted-human-initjudge" } : {}),
         meta: {
             startedAt: input.startedAt,
@@ -494,8 +321,6 @@ export function assembleRow(input) {
             ...(reviewerTouched ? { reviewerKind: "scripted-human-rubric" } : {}),
         },
     };
-    // teamWorkerBudgetSumUsd is the bigger-pie guard input — kept on meta so assertBudgetMatch can read it (it is
-    // NOT a RunRecord scoring field). Stamped only for TEAM when the leader reported the real stamped split.
     if (arm === "TEAM" && input.teamWorkerBudgetSumUsd !== undefined && row.meta) {
         row.meta.teamWorkerBudgetSumUsd = input.teamWorkerBudgetSumUsd;
     }