@tachikomagundam/abathur 0.2.3 → 0.2.5

package/dist/test/selfmode-literal.test.js

@@ -0,0 +1,153 @@
+// Campaign-1 defect pins (historian evidence task-07, live symptom rc=2):
+// a `${VAR}` env-literal repoPath is a PATH-INJECTION convenience, NOT an
+// engine-self marker. run-loop.ts routed selfMode on isEnvRepoLiteral — ANY
+// literal — so the historian genome (`${ABATHUR_HISTORIAN_REPO}`) was forced
+// into the tsc-build/toy-replay snapshot-overlay bench and died fail-closed
+// demanding `selfbench/expected.json`. selfMode must mean
+// `envRepoName(repoPath) === "ABATHUR_SELF_REPO"`. Secondary pin: the dry-run
+// plan must display the RESOLVED repo path, never the raw literal joined to
+// cwd (run-plan.ts printed `/…/historian/${ABATHUR_HISTORIAN_REPO}`).
+// Harness mirrors run-loop.test.ts: toy genome + stub mutator, no model calls.
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync } from "node:fs";
+import { mkdtemp } from "node:fs/promises";
+import * as os from "node:os";
+import path from "node:path";
+import test, {} from "node:test";
+import { ExitSignal } from "../exit.js";
+import { registerGenome, requireGenomesByLabel } from "../core/genome.js";
+import { Ledger } from "../core/ledger.js";
+import { prepareToyGenome } from "../bench/toy.js";
+import { runEvolution } from "../core/evolve/run-loop.js";
+// Same three-candidate stub script as run-loop.test.ts (annotate-add seals,
+// touch-kernel path-rejected, fix-add nominated).
+const ADD_ANCHOR = "return a - b; // seeded bug: must be `return a + b;`";
+const STUB_SOURCE = `#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+const args = process.argv.slice(2);
+const opt = (n) => { const i = args.indexOf(n); return i >= 0 ? args[i + 1] : undefined; };
+const mode = opt("--mode");
+const dir = opt("--dir");
+const read = (f) => readFileSync(dir + "/" + f, "utf8");
+function lineDiff(file, anchor, replacement) {
+  const lines = read(file).split("\\n");
+  const i = lines.findIndex((l) => l.includes(anchor));
+  if (i < 0) { process.stderr.write("stub: no anchor in " + file + "\\n"); process.exit(1); }
+  const changed = lines[i].replace(anchor, replacement);
+  return "--- a/" + file + "\\n+++ b/" + file + "\\n@@ -" + String(i + 1) + ",1 +" + String(i + 1) + ",1 @@\\n-" + lines[i] + "\\n+" + changed + "\\n";
+}
+const FIX = ${JSON.stringify(ADD_ANCHOR)};
+const out = (candidates) => process.stdout.write(JSON.stringify({ candidates }) + "\\n");
+if (mode === "three") {
+  out([
+    { id: "annotate-add", rationale: "annotate add()", diffs: [lineDiff("units/add.mjs", "export function add(", "export function add /* patched */(")] },
+    { id: "touch-kernel", rationale: "subvert grading", diffs: [lineDiff("grader.mjs", "model-free", "model-free-ish")] },
+    { id: "fix-add", rationale: "fix add(): subtraction to addition", diffs: [lineDiff("units/add.mjs", FIX, "return a + b;")] },
+  ]);
+} else {
+  process.stderr.write("stub: unknown mode\\n");
+  process.exit(2);
+}
+`;
+/**
+ * Toy genome registered with repoPath stored as the UNRESOLVED literal
+ * `${<envName>}` (the self-seed trick, pointed at the toy repo itself), env
+ * var set for the duration of the test. Fresh configDir per test.
+ */
+async function literalFixture(t, envName) {
+    const root = await mkdtemp(path.join(os.tmpdir(), "abathur-selfmode-"));
+    t.after(() => {
+        // trusted snapshots are chmod-protected read-only: restore writability first.
+        spawnSync("chmod", ["-R", "u+rwX", root], { encoding: "utf8" });
+        spawnSync("rm", ["-rf", root], { encoding: "utf8" });
+    });
+    const configDir = path.join(root, "config");
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(path.join(configDir, "config.jsonc"), '{ "opencodeBin": null }\n', "utf8");
+    const repo = await prepareToyGenome(path.join(root, "genome"));
+    const specPath = path.join(repo, "genome.jsonc");
+    const doc = JSON.parse(readFileSync(specPath, "utf8"));
+    doc.repoPath = `\${${envName}}`;
+    writeFileSync(specPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+    const saved = process.env[envName];
+    process.env[envName] = repo;
+    t.after(() => {
+        if (saved === undefined)
+            delete process.env[envName];
+        else
+            process.env[envName] = saved;
+    });
+    registerGenome(configDir, specPath);
+    const entry = requireGenomesByLabel(configDir, "toy-smoke").entries[0];
+    if (entry === undefined)
+        throw new Error("fixture: toy-smoke registration vanished");
+    const stub = path.join(root, "stub.mjs");
+    writeFileSync(stub, STUB_SOURCE, "utf8");
+    chmodSync(stub, 0o755);
+    return {
+        root,
+        configDir,
+        repo,
+        entry,
+        mutatorCommand: `node ${stub} --mode three --dir {worktree} --brief {brief}`,
+        env: { XDG_CACHE_HOME: path.join(root, "xdg-cache"), HOME: path.join(root, "home") },
+        sandboxRoot: path.join(root, "sandboxes"),
+    };
+}
+function generationRowCount(f) {
+    return Ledger.open(f.repo)
+        .readAll()
+        .filter((r) => r.kind === "generation_complete").length;
+}
+// ------------------------------------------------- non-self literal: normal bench
+test("campaign-1 defect: a non-self env-literal repoPath must NOT enter the self-bench overlay", async (t) => {
+    const f = await literalFixture(t, "ABATHUR_HISTORIAN_REPO");
+    const out = await runEvolution({
+        entry: f.entry,
+        configDir: f.configDir,
+        mutatorCommand: f.mutatorCommand,
+        env: f.env,
+        sandboxRoot: f.sandboxRoot,
+    });
+    const plan = out.lines.join("\n");
+    assert.equal(out.exitCode, 0, `expected exit 0, lines: ${plan}`);
+    assert.ok(!/selfbench|self-snapshot|self-bench|overlay/i.test(plan), `non-self literal must never touch the self-bench machinery: ${plan}`);
+    assert.ok(generationRowCount(f) >= 2, "incumbent + candidate rows benched through the NORMAL toy path");
+    assert.equal(existsSync(path.join(f.root, "selfbench")), false);
+});
+// ------------------------------------- self literal: overlay path preserved
+test("regression pin: the ${ABATHUR_SELF_REPO} literal still routes into the self-bench path", async (t) => {
+    // The toy repo carries no selfbench/expected.json, so entering the overlay
+    // bench FAILS CLOSED with exactly that demand — the observable proof that
+    // selfMode is still true for the engine-self literal (live symptom shape).
+    const f = await literalFixture(t, "ABATHUR_SELF_REPO");
+    await assert.rejects(runEvolution({
+        entry: f.entry,
+        configDir: f.configDir,
+        mutatorCommand: f.mutatorCommand,
+        env: f.env,
+        sandboxRoot: f.sandboxRoot,
+    }), (cause) => {
+        assert.ok(cause instanceof ExitSignal, `expected ExitSignal, got ${String(cause)}`);
+        assert.equal(cause.code, 2);
+        assert.match(cause.message, /self-snapshot: trusted selfbench\/expected\.json missing/);
+        return true;
+    });
+});
+// ----------------------------------------------------- dry-run plan display
+test("--dry-run plan displays the RESOLVED repo path, never the literal against cwd", async (t) => {
+    const f = await literalFixture(t, "ABATHUR_HISTORIAN_REPO");
+    const out = await runEvolution({
+        entry: f.entry,
+        configDir: f.configDir,
+        mutatorCommand: f.mutatorCommand,
+        dryRun: true,
+        env: f.env,
+        sandboxRoot: f.sandboxRoot,
+    });
+    assert.equal(out.exitCode, 0, out.lines.join("\n"));
+    const plan = out.lines.join("\n");
+    assert.ok(plan.includes(`repo: ${f.repo}`), `plan must show the resolved path:\n${plan}`);
+    assert.ok(!plan.includes("${"), `plan must never echo the raw literal (resolved against cwd garbage):\n${plan}`);
+});

package/dist/test/stats.test.js

@@ -234,6 +234,24 @@ describe("evaluate: n=1 ⇒ indeterminate, never nominated", () => {
         assert.ok(v.failures.some((f) => f.includes("variance undefined")));
         assert.notEqual(v.exitCode, 0);
     });
+    it("campaign-6 regression: incumbent train unit n=0 ⇒ indeterminate, never a bogus negative gain", () => {
+        const v = evaluate({
+            candidate: candidate("g-c6", [
+                { unitId: "u-train", split: "train", scores: [0.8333333, 0.8333333] },
+                { unitId: "u-val", split: "val", scores: [1, 1] },
+            ]),
+            incumbent: { units: [
+                    { unitId: "u-train", split: "train", scores: [] },
+                    { unitId: "u-val", split: "val", scores: [0.875, 1] },
+                ] },
+            stats: STATS,
+            budgetCaps: CAPS,
+            nPairs: 1,
+        });
+        assert.equal(v.verdict, "indeterminate", summaryOf(v));
+        assert.ok(v.failures.some((f) => f.includes("baseline variance undefined")));
+        assert.equal(v.gain, null);
+    });
     it("candidate missing an incumbent val unit entirely ⇒ indeterminate", () => {
         const v = evaluate({
             candidate: candidate("g-miss", [unit("u-train", "train", 0.85, 0.001)]),

package/dist/test/status-repo.test.js

@@ -0,0 +1,72 @@
+// S4 engine seam (deliverable f) — `abathur status` must resolve the stored
+// repoPath through effectiveRepoPath (the run/genome/kernel/self-eval pattern,
+// run-loop.ts:142) before touching ANY filesystem seam. Pre-fix, status passed
+// the STORED UNRESOLVED `${VAR}` literal as the git cwd; Node reports a missing
+// cwd as the misleading `spawn git ENOENT` (task-09 evidence §C). Pins:
+//  (1) env-literal genome + env exported ⇒ status exits 0 (real git + ledger
+//      seam on the resolved tree — never an ENOENT);
+//  (2) env-literal genome + env UNSET ⇒ clean exit 2 NAMING the variable, and
+//      the misleading spawn-ENOENT string is gone;
+//  (3) concrete repoPath keeps working unchanged (regression guard).
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdtempSync, rmSync } from "node:fs";
+import * as os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { test } from "node:test";
+import { registerGenome } from "../core/genome.js";
+import { prepareToyGenome } from "../bench/toy.js";
+const CLI = fileURLToPath(new URL("../../dist/cli.js", import.meta.url));
+const LIT_VAR = "ABATHUR_SEAM_STATUS_REPO";
+async function fixture(t, label) {
+    const root = mkdtempSync(path.join(os.tmpdir(), "seam-status-"));
+    t.after(() => rmSync(root, { recursive: true, force: true }));
+    const configDir = path.join(root, "config");
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(path.join(configDir, "config.jsonc"), '{ "opencodeBin": null }\n', "utf8");
+    const repo = await prepareToyGenome(path.join(root, "genome"));
+    // Register under the exported env (add resolves the same way run does),
+    // storing the spec with the UNRESOLVED literal (0.2.x convention).
+    const doc = JSON.parse(readFileSync(path.join(repo, "genome.jsonc"), "utf8"));
+    doc["label"] = label;
+    doc["repoPath"] = `\${${LIT_VAR}}`;
+    const specFile = path.join(root, "private.jsonc");
+    writeFileSync(specFile, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+    process.env[LIT_VAR] = repo;
+    try {
+        registerGenome(configDir, specFile);
+    }
+    finally {
+        delete process.env[LIT_VAR];
+    }
+    return { root, configDir, repo };
+}
+function cli(f, label, env) {
+    return spawnSync(process.execPath, [CLI, "status", label], {
+        encoding: "utf8",
+        cwd: f.root,
+        env: {
+            ...process.env,
+            ABATHUR_CONFIG: path.join(f.configDir, "config.jsonc"),
+            HOME: path.join(f.root, "home"),
+            XDG_CACHE_HOME: path.join(f.root, "xdg-cache"),
+            ...env,
+        },
+    });
+}
+test("status resolves an env-literal repoPath via effectiveRepoPath: exported ⇒ exit 0", async (t) => {
+    const f = await fixture(t, "seam-self");
+    const r = cli(f, "seam-self", { [LIT_VAR]: f.repo });
+    assert.equal(r.status, 0, `stdout: ${r.stdout}\nstderr: ${r.stderr}`);
+    assert.match(r.stdout, /genome: seam-self/);
+    assert.ok(!r.stderr.includes("ENOENT"), "the misleading spawn-ENOENT string must be gone");
+});
+test("status on an env-literal repoPath with the env UNSET: clean exit 2 naming the variable", async (t) => {
+    const f = await fixture(t, "seam-unset");
+    const r = cli(f, "seam-unset", { [LIT_VAR]: undefined });
+    assert.equal(r.status, 2);
+    assert.match(r.stderr, new RegExp(`requires env var ${LIT_VAR}`));
+    assert.ok(!r.stderr.includes("ENOENT"), `misleading ENOENT returned: ${r.stderr}`);
+});

package/graders/historian/grader-core.d.mts

@@ -1,10 +1,14 @@
 // Type declarations for grader-core.mjs — the plan-185 scoring engine.
 // Runtime lives in the .mjs; this file is the compile-time contract.
 
+import type { ToolEvent } from "./grader-support.mjs";
+
 export type DimKey = "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H";
 export type Bit = 0 | 1;
 export type FullDims = Readonly<Record<DimKey, Bit>>;
 export type WorthDims = Readonly<{ G: Bit; H: Bit; J: Bit }>;
+export type IntegrityDims = Readonly<{ I: Bit; J: Bit }>;
+export type IntegrityNote = string;
 
 export interface CreatedPage {
   readonly path: string;
@@ -13,6 +17,26 @@ export interface CreatedPage {
   readonly content: string;
 }
 
+/** Post-run sandbox row + seed captures the I/J checkers diff evidence against.
+ *  Twin-row units (scenario-13: one path, en+zh rows; scenario-15: the created
+ *  archive twin) key the locale-aware maps `rowIdByLocalePath`/
+ *  `seedRowIdByLocalePath` by `path + "\u0000" + locale`; scenario-14/15 seeds
+ *  are EN-only but ride the same locale-keyed lookups. */
+export interface IntegrityState {
+  readonly sandboxRows: ReadonlyArray<{ readonly path: string; readonly id: string; readonly description: string; readonly locale?: string | undefined }>;
+  readonly content: Readonly<Record<string, string>>;
+  readonly rowIdByPath: ReadonlyMap<string, string>;
+  readonly rowIdByLocalePath?: ReadonlyMap<string, string> | undefined;
+  readonly descByPath: ReadonlyMap<string, string>;
+  readonly seedDescByPath: ReadonlyMap<string, string>;
+  readonly seedRowIdByLocalePath?: ReadonlyMap<string, string> | undefined;
+  readonly seedContent: Readonly<Record<string, string>>;
+  /** scenario-17 only: the parsed `.bench/judge-verdicts.json` instrument output
+   *  (judge-bench blind double runs + B4 §4 arbitration rows). undefined = the
+   *  file is absent (the 蜂判 legs fail CLOSED); {parseError} = unparseable. */
+  readonly judgeVerdicts?: unknown;
+}
+
 export interface Observation {
   readonly scenarioNo: number;
   readonly created: readonly CreatedPage[];
@@ -31,6 +55,10 @@ export interface Observation {
   readonly backlinkBodies: ReadonlyArray<{ readonly path: string; readonly locale: string; readonly content: string }>;
   readonly finalMessage: string;
   readonly urlChecks: readonly { readonly url: string; readonly status: number }[];
+  /** Required for integrity units (scenario-10/11/12): transcript tool events. */
+  readonly tools?: readonly ToolEvent[] | undefined;
+  /** Required for integrity units: seed-state-derived wiki context. */
+  readonly integrity?: IntegrityState | undefined;
 }
 
 export interface UnitScore {
@@ -47,7 +75,100 @@ export type ScoredUnit = UnitScore & {
 
 export const WEIGHTS: Readonly<Record<DimKey, number>>;
 
+export const S10_PATH: string;
+export const S10_DECOY: string;
+export const S11_CARD: string;
+export const S11_SUPERSEDE: string;
+export const S11_SEED_DATE: string;
+export const VERIFY_TOKEN: string;
+export const S12_JUNK: readonly string[];
+export const S12_DECOY: readonly string[];
+export const S13_RUNBOOK: string;
+export const S13_DECOY: string;
+export const S13_FAB_STAMP: string;
+export const S13_FAB_MIGRATE: string;
+export const S14_HUB: string;
+export const S14_OPS: string;
+export const S14_DUP_A: string;
+export const S14_DUP_B: string;
+export const S14_ORPHAN: string;
+export const S14_DECOY: string;
+export const S14_GHOST_A: string;
+export const S14_GHOST_B: string;
+export const S15_HUB: string;
+export const S15_LEGACY: string;
+export const S15_INCIDENT: string;
+export const S15_DORMANT: string;
+export const S15_ARCHIVE: string;
+export const S15_TOKEN: string;
+export const S16_HUB: string;
+export const S16_EXEMPLAR: string;
+export const S16_BAIT: string;
+export const S16_PAGE: string;
+export const S17_HUB: string;
+export const S17_SOURCE: string;
+export const S17_BAIT: string;
+export const S17_PAGE: string;
+export const S17_JUDGE_RUBRICS: readonly string[];
+export const S17_JUDGE_LOCALES: readonly string[];
+export const APPLICABLE: Readonly<Record<number, Readonly<Record<string, number>>>>;
+
+/** Doctrine machine-line verdict (scenario-16): deterministic check result. */
+export interface DoctrineCheck {
+  readonly ok: boolean;
+  readonly why?: string | undefined;
+  readonly exempt?: boolean | undefined;
+}
+
+export interface DoctrineSignature {
+  readonly h: number;
+  readonly t: number;
+  readonly c: number;
+  readonly b: number;
+}
+
+/** (A) R1 形态门 — S1 stamp-form closed set, pre-first-H2 block, cap-5 tail. */
+export function s16R1FormGate(content: string): DoctrineCheck;
+/** (B) R2 — cell ≤120 chars, rendered row ≤120 cols, >20 rows need a grouping row. */
+export function s16R2Tables(content: string): DoctrineCheck;
+/** (C) R3 — emphasis spans per 2000 narrative non-ws chars, en ≤22 / zh ≤35. */
+export function s16R3Emphasis(content: string, locale: string): DoctrineCheck;
+/** (D) R9 — trailer dangling / normalized long-line repeat / placeholder closed set. */
+export function s16R9Hygiene(content: string, region?: "page" | "trailer"): DoctrineCheck;
+/** (E) R5 — twin structure signature (h, t, c, b), per-axis deviation cap. */
+export function s16Signature(content: string): DoctrineSignature;
+export function s16R5TwinParity(enBody: string, zhBody: string): DoctrineCheck;
+
+export interface StatusTokens {
+  readonly header: string | null;
+  readonly rows: readonly string[];
+}
+
+/** Deterministic fold over `.bench/judge-verdicts.json` (scenario-17 蜂判 lines).
+ *  coverageOk = the expected (rubric × locale) key set is fully double-run covered
+ *  (2 ok reps, rep3 when the two disagree), malformed rows excluded-with-count;
+ *  allOne = every expected key resolves to a majority 1. Absent/unparseable input
+ *  fails both closed. Pure — no LLM, no IO. */
+export interface JudgeFold {
+  readonly coverageOk: boolean;
+  readonly allOne: boolean;
+  readonly coverageNotes: readonly string[];
+  readonly foldNotes: readonly string[];
+  readonly majority: ReadonlyMap<string, 0 | 1>;
+}
+export function s17FoldJudgeVerdicts(verdicts: unknown, page?: string): JudgeFold;
+
+export interface IntegrityResult extends IntegrityDims {
+  readonly notes: readonly IntegrityNote[];
+}
+
 export function computeDims(obs: Observation): FullDims;
 export function judgment(scenarioNo: number, created: readonly CreatedPage[], finalMessage: string): Bit;
 export function scoreFromDims(scenarioNo: number, dims: FullDims | WorthDims): UnitScore;
 export function scoreUnit(obs: Observation): ScoredUnit;
+export function statusTokens(content: string): StatusTokens;
+/** Parse a tool event's output as JSON, following opencode's >45KB externalization
+ *  stubs (`Full output saved to: <ref>`) to the ref file. Fail-closed: undefined
+ *  when neither the inline output nor the referenced file parses. */
+export function resolveToolJson(event: ToolEvent): unknown;
+export function integrityDims(scenarioNo: number, obs: Observation, tools: readonly ToolEvent[], integrity: IntegrityState): IntegrityResult;