@avee1234/selfpatch 0.1.0

package/src/verify.js

@@ -0,0 +1,103 @@
+// selfpatch — `verify` (v0.1). The reward-hacking tripwire.
+//
+// Turn a self-patch's `eval_contract` into a list of checks and run each check
+// twice — once for the **before** (baseline) world and once for the **after**
+// (candidate) world — through an injected `runCheck(command, phase)`, then
+// report `{ passed, regressed, checks }`. `passed` = candidate green now;
+// `regressed` = was green before, red after. A self-edit that games its visible
+// signal but breaks the held-out check fails here, by construction.
+//
+// Pure and synchronous: the core does NO process, filesystem, or network I/O of
+// its own. `runCheck` is the only side-effecting seam, so the tripwire logic is
+// fully unit-testable with a fake executor. This module must never
+// `import node:child_process` — all execution lives in the CLI.
+
+// Thrown when handed a patch that cannot be verified: a missing/non-function
+// `runCheck`, or an `eval_contract` that yields no runnable command. Fail
+// closed — an unverifiable self-patch is blocked, not silently "passed".
+// Named/exported per the #3 spec (mirrors `ProposeError` from #2) so callers
+// can rely on the type.
+export class VerifyError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "VerifyError";
+  }
+}
+
+// Normalize an `eval_contract` into a list of `{ kind, command }` checks. v0.1:
+// a single `{ kind: "command", command }` ⇒ a one-element array. Shaped as an
+// array so a future multi-command contract slots in without changing the return
+// shape. Throws `VerifyError` if no non-empty command string is present or the
+// kind is unsupported.
+function normalizeChecks(evalContract) {
+  if (evalContract === null || typeof evalContract !== "object" || Array.isArray(evalContract)) {
+    throw new VerifyError(
+      "verifySelfPatch: `eval_contract` must be an object with a runnable command"
+    );
+  }
+  const { kind, command } = evalContract;
+  if (kind !== "command") {
+    throw new VerifyError(
+      `verifySelfPatch: unsupported eval_contract.kind ${JSON.stringify(kind)} (v0.1 supports "command")`
+    );
+  }
+  if (typeof command !== "string" || command.trim().length === 0) {
+    throw new VerifyError(
+      "verifySelfPatch: eval_contract.command must be a non-empty string"
+    );
+  }
+  return [{ kind, command }];
+}
+
+// A check is green iff its result exists and exited 0. Everything else —
+// nonzero, `null` (timeout/signal), a missing result — is red. Fail closed.
+function isGreen(result) {
+  return result != null && result.exitCode === 0;
+}
+
+/**
+ * Run a self-patch's held-out check in two worlds and report the verdict.
+ *
+ * @param {object} patch  A self-patch object (as produced by `propose`, valid
+ *   per #1). Only its `eval_contract` is read; nothing is applied.
+ * @param {object} opts
+ * @param {(command: string, phase: "before"|"after") => object} opts.runCheck
+ *   Injected executor. `phase` is `"before"` (baseline) or `"after"`
+ *   (candidate). It returns a result whose `exitCode` (number, or `null` for
+ *   timeout/signal) decides green (`0`) vs red (anything else); any extra fields
+ *   (`stdout`, `stderr`, `durationMs`, `timedOut`, …) pass through into the
+ *   report unchanged. May be called with the same world for both phases (no
+ *   distinct baseline) — then `regressed` can never fire, the safe default.
+ * @returns {{ passed: boolean, regressed: boolean, checks: Array<object> }}
+ *   `passed` = every check green after; `regressed` = any check green before and
+ *   red after. Each `checks[i]` carries `{ command, kind, before, after,
+ *   passed, regressed }`.
+ * @throws {VerifyError} If `runCheck` is missing/not a function, or the
+ *   `eval_contract` yields no runnable command / an unsupported kind.
+ */
+export function verifySelfPatch(patch, { runCheck } = {}) {
+  if (typeof runCheck !== "function") {
+    throw new VerifyError("verifySelfPatch: `runCheck` must be a function");
+  }
+  const patchObj = patch !== null && typeof patch === "object" ? patch : {};
+  const checks = normalizeChecks(patchObj.eval_contract);
+
+  const results = checks.map(({ kind, command }) => {
+    const before = runCheck(command, "before");
+    const after = runCheck(command, "after");
+    return {
+      command,
+      kind,
+      before,
+      after,
+      passed: isGreen(after),
+      regressed: isGreen(before) && !isGreen(after),
+    };
+  });
+
+  return {
+    passed: results.every((c) => c.passed),
+    regressed: results.some((c) => c.regressed),
+    checks: results,
+  };
+}