@tachikomagundam/abathur 0.2.4 → 0.2.5

package/dist/test/historian-grader-io.test.js

@@ -215,6 +215,7 @@ function integrityFixturesReady() {
     return (existsSync(path.join(FIXDIR, "scenario-10", "state-donothing.json")) &&
         existsSync(path.join(FIXDIR, "scenario-11", "state-fabricate.json")) &&
         existsSync(path.join(FIXDIR, "scenario-12", "seed-state.json")) &&
+        existsSync(path.join(FIXDIR, "scenario-13", "seed-state.json")) &&
         existsSync(path.join(HISTORIAN_REPO, "scenarios", "10-status-contradiction-audit.md")));
 }
 const integritySkip = integrityFixturesReady()
@@ -232,6 +233,9 @@ const INTEGRITY_CASES = [
     { unit: "scenario-12", scenarioRel: "scenarios/12-desc-junk-detection.md", shape: "pass", score: 1, pass: true, total: 6, weight: 6, dims: { G: 1, H: 1, I: 1, J: 1 } },
     { unit: "scenario-12", scenarioRel: "scenarios/12-desc-junk-detection.md", shape: "fail", score: 2 / 6, pass: false, total: 2, weight: 6, dims: { G: 1, H: 1, I: 0, J: 0 } },
     { unit: "scenario-12", scenarioRel: "scenarios/12-desc-junk-detection.md", shape: "donothing", score: 2 / 6, pass: false, total: 2, weight: 6, dims: { G: 1, H: 1, I: 0, J: 0 } },
+    { unit: "scenario-13", scenarioRel: "scenarios/13-translation-honesty-audit.md", shape: "pass", score: 1, pass: true, total: 8, weight: 8, dims: { D: 1, G: 1, H: 1, I: 1, J: 1 } },
+    { unit: "scenario-13", scenarioRel: "scenarios/13-translation-honesty-audit.md", shape: "fail", score: 0, pass: false, total: 0, weight: 8, dims: { D: 0, G: 0, H: 0, I: 0, J: 0 } },
+    { unit: "scenario-13", scenarioRel: "scenarios/13-translation-honesty-audit.md", shape: "donothing", score: 3 / 8, pass: false, total: 3, weight: 8, dims: { D: 1, G: 1, H: 0, I: 0, J: 0 } },
 ];
 function integritySandbox(unit, shape) {
     const fix = path.join(FIXDIR, unit);

package/dist/test/historian-run-scenario.test.js

@@ -42,6 +42,9 @@ const STUB_OPENCODE = `#!/usr/bin/env node
 // transcript on stdout (run-scenario.sh redirects it to $ABATHUR_TRANSCRIPT).
 // The finalMessage is the prompt echoed back — so a planted instruction in the
 // brief provably flows into the transcript.
+// STUB_BANNER=1 / STUB_JUNK=1 reproduce campaign-1's channel contamination:
+// a plugin startup banner / an arbitrary non-JSON line printed to stdout
+// BEFORE the JSONL. Default off ⇒ clean output stays byte-identical.
 import { writeFileSync } from "node:fs";
 const args = process.argv.slice(2);
 const i = args.indexOf("--message");
@@ -51,6 +54,9 @@ if (capture !== undefined && capture.length > 0) writeFileSync(capture, message,
 const argvCapture = process.env.STUB_ARGV_FILE;
 if (argvCapture !== undefined && argvCapture.length > 0) writeFileSync(argvCapture, args.join("\\n") + "\\n", "utf8");
 const out = (doc) => process.stdout.write(JSON.stringify(doc) + "\\n");
+if (process.env.STUB_BANNER === "1") out0("[persistence-watchdog] tier=R armed grace=2500ms minOutput=100 alerts=/tmp/abathur-test-alerts.log");
+if (process.env.STUB_JUNK === "1") out0("this line is not json at all");
+function out0(line) { process.stdout.write(line + "\\n"); }
 out({ type: "step_start", part: { type: "step-start" } });
 out({ type: "step_finish", part: { type: "step-finish", reason: "stop", tokens: { total: 42 } } });
 out({ type: "text", part: { type: "text", text: message } });
@@ -182,12 +188,12 @@ test("model pin: ABATHUR_AGENT_MODEL set ⇒ argv carries --model <value>, brief
     const argvFile = path.join(path.dirname(h.promptFile), "argv-pinned.txt");
     await runScenario(h, {
         argvFile,
-        env: { ABATHUR_AGENT_MODEL: "testprov/testmodel" },
+        env: { ABATHUR_AGENT_MODEL: "fake-provider/fake-model" },
     });
     const tokens = argvTokens(argvFile);
     const i = tokens.indexOf("--model");
     assert.notEqual(i, -1, `--model missing from argv: ${JSON.stringify(tokens)}`);
-    assert.equal(tokens[i + 1], "testprov/testmodel");
+    assert.equal(tokens[i + 1], "fake-provider/fake-model");
     assert.equal(tokens.at(-2), "--message", "pin must not disturb the brief channel");
     assert.equal(prompt(h), BRIEF_TEXT);
 });
@@ -203,3 +209,37 @@ test("model pin: ABATHUR_AGENT_MODEL empty string ⇒ treated as unset (same arg
     await runScenario(h, { argvFile, env: { ABATHUR_AGENT_MODEL: "" } });
     assert.deepEqual(argvTokens(argvFile), BASELINE_ARGV);
 });
+// Channel contamination (campaign-1 root cause, historian evidence
+// task-07-launch-blockers.md): the user's global persistence-watchdog plugin
+// prints `[persistence-watchdog] tier=R armed …` to the agent's STDOUT — into
+// the captured transcript — contaminating 6/8 candidate transcripts while the
+// incumbent bench (pre-plugin) stayed clean. Contract of the fix: strip ONLY
+// that known banner line; keep a verbatim `.raw` audit copy; unknown non-JSON
+// lines must SURVIVE (the grader's corruption fail-closed stays honest); and a
+// clean stream must pass through byte-identical (F1 invariant).
+test("banner-strip: watchdog banner removed from transcript, .raw keeps it verbatim, grader-view parses", async (t) => {
+    const h = harness(t);
+    await runScenario(h, { env: { STUB_BANNER: "1" } });
+    const text = readFileSync(h.transcript, "utf8");
+    assert.ok(!text.includes("[persistence-watchdog]"), "banner must not reach the grader-facing transcript");
+    for (const line of text.split("\n")) {
+        if (line.length > 0)
+            assert.doesNotThrow(() => JSON.parse(line), `grader-facing line is not JSON: ${line}`);
+    }
+    const raw = readFileSync(`${h.transcript}.raw`, "utf8");
+    assert.ok(raw.startsWith("[persistence-watchdog] tier=R armed"), "raw audit copy preserves the banner verbatim");
+    const meta = parseTranscript(text);
+    assert.equal(meta.finalMessage, BRIEF_TEXT, "the stripped transcript must still yield the delivery truth");
+});
+test("banner-strip: clean stream ⇒ transcript byte-identical to raw (F1 invariant)", async (t) => {
+    const h = harness(t);
+    await runScenario(h);
+    assert.equal(readFileSync(h.transcript, "utf8"), readFileSync(`${h.transcript}.raw`, "utf8"));
+});
+test("banner-strip: UNKNOWN non-JSON lines are NOT stripped (grader fail-closed preserved)", async (t) => {
+    const h = harness(t);
+    await runScenario(h, { env: { STUB_JUNK: "1" } });
+    const text = readFileSync(h.transcript, "utf8");
+    assert.ok(text.includes("this line is not json at all"), "never silently launder unknown corruption");
+    assert.throws(() => parseTranscript(text), /transcript line is not JSON/);
+});

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/graders/historian/grader-core.d.mts

@@ -17,14 +17,24 @@ export interface CreatedPage {
   readonly content: string;
 }
 
-/** Post-run sandbox row + seed captures the I/J checkers diff evidence against. */
+/** 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 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 {
@@ -73,13 +83,81 @@ 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[];
 }