opencode-longrun-harness 1.2.22

package/harness/test/v1222-default-evidence-class.test.mjs

@@ -0,0 +1,75 @@
+// v1.2.22 — a declared check that is mapped from a criterion with an evidenceClass should not
+// silently lose its evidence class when the model omits the optional per-call argument.
+//
+// Reproduced twice on real runs (annotations lr-00000000a1b2 and another run lr-00000000c3d4): the final
+// whole-suite round called longrun_verify without evidenceClass, every receipt became classless, and
+// status reported loss 1 / required_unverified / UNKNOWN_CLASS even though all six checks PASSED.
+//
+// Fix: when args.evidenceClass is absent, derive the receipt class from the run's OWN contract when
+// exactly one required criterion that maps this check declares an evidenceClass. Explicit arguments
+// always win, and ambiguous mappings must NOT guess.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import * as C from '../src/controller.js';
+import { F } from './helper.mjs';
+process.env.LONGRUN_CONTROLLER_FILE = path.resolve(import.meta.dirname, '../src/controller.js');
+
+async function fixture(t, criteria) {
+  const base = fs.mkdtempSync(path.join(os.tmpdir(), 'lr1222-'));
+  t.after(() => fs.rmSync(base, { recursive: true, force: true }));
+  const dir = path.join(base, 'project'); fs.mkdirSync(dir); fs.writeFileSync(path.join(dir, 'value.txt'), 'valid');
+  process.env.LONGRUN_STATE_DIR = path.join(base, 'state');
+  const hooks = await F('../plugin/longrun.js', { client: null, directory: dir, worktree: dir });
+  const ctx = { sessionID: 'evidence-class-fixture', directory: dir, worktree: dir };
+  const command = [process.execPath, '-e', "require('node:assert/strict').match(require('node:fs').readFileSync('value.txt','utf8'),/^valid/)"];
+  const start = JSON.parse(await hooks.tool.longrun.execute({ action: 'start', request: 'Isolated evidence-class regression', criteria, checkCatalogue: { check: { command, kind: 'cmd' }, gate: { command, kind: 'cmd', gate: true } } }, ctx));
+  assert.ok(start.runId, JSON.stringify(start));
+  const store = new C.Store(process.env.LONGRUN_STATE_DIR), key = C.stateKey(C.projectIdentity(dir), start.runId);
+  const read = () => { const r = store.readRun(key); assert.equal(r.error, undefined, JSON.stringify(r)); return r.run; };
+  const verify = async (args = {}) => JSON.parse(await hooks.tool.longrun_verify.execute({ runId: start.runId, checkId: 'check', ...args }, ctx));
+  return { dir, hooks, ctx, start, store, key, read, verify };
+}
+
+test('an omitted evidenceClass is derived from the criterion that maps the check', async t => {
+  const s = await fixture(t, [{ id: 'c', checks: ['check'], evidenceClass: 'BROWSER' }]);
+  const res = await s.verify();
+  assert.equal(res.status, 'PASS', JSON.stringify(res));
+  const receipt = s.read().receipts.at(-1);
+  assert.equal(receipt.evidenceClass, 'BROWSER', 'derived class recorded on the receipt');
+  const view = C.deriveRunView(s.read(), { currentFingerprint: s.read().sourceFingerprint });
+  assert.equal(view.criterionStates.find(c => c.id === 'c').satisfied, true, 'criterion satisfied without a per-call argument');
+});
+
+test('an explicit evidenceClass still overrides the derived default', async t => {
+  const s = await fixture(t, [{ id: 'c', checks: ['check'], evidenceClass: 'BROWSER' }]);
+  const res = await s.verify({ evidenceClass: 'UNIT' });
+  assert.equal(res.status, 'PASS', JSON.stringify(res));
+  assert.equal(s.read().receipts.at(-1).evidenceClass, 'UNIT', 'explicit argument wins');
+  const view = C.deriveRunView(s.read(), { currentFingerprint: s.read().sourceFingerprint });
+  assert.equal(view.criterionStates.find(c => c.id === 'c').satisfied, false, 'a weaker explicit class does not satisfy a BROWSER criterion');
+});
+
+test('an ambiguous mapping is not guessed', async t => {
+  const s = await fixture(t, [
+    { id: 'c1', checks: ['check'], evidenceClass: 'BROWSER' },
+    { id: 'c2', checks: ['check'], evidenceClass: 'UNIT' },
+  ]);
+  const res = await s.verify();
+  assert.equal(res.status, 'PASS', JSON.stringify(res));
+  assert.equal(s.read().receipts.at(-1).evidenceClass ?? null, null, 'ambiguous criteria must not auto-assign a class');
+});
+
+test('defaultEvidenceClass unit behaviour', () => {
+  const run = { contract: { criteria: [
+    { id: 'a', checks: ['x'], evidenceClass: 'INTEGRATION' },
+    { id: 'b', checks: ['y'], evidenceClass: 'BROWSER' },
+  ] } };
+  assert.equal(C.defaultEvidenceClass(run, 'x'), 'INTEGRATION');
+  assert.equal(C.defaultEvidenceClass(run, 'y'), 'BROWSER');
+  assert.equal(C.defaultEvidenceClass(run, 'z'), null, 'unmapped check has no default');
+  assert.equal(C.defaultEvidenceClass({ contract: { criteria: [{ id: 'a', checks: ['x'], evidenceClass: 'UNIT' }, { id: 'b', checks: ['x'], evidenceClass: 'BROWSER' }] } }, 'x'), null, 'conflicting classes are ambiguous');
+  assert.equal(C.defaultEvidenceClass(run, 'x', 'SYSTEM'), 'SYSTEM', 'explicit argument wins');
+});

package/harness/test/v123-plugin-e2e.test.mjs

@@ -0,0 +1,120 @@
+import { reviewProjectFixture } from "./helper.mjs";
+// v1.2.3 end-to-end reproduction through the REAL plugin tool factory + controller (LONGRUN_TEST
+// armed; isolated state dir). Reproduces the class of failure at the tool surface:
+// a hard gate must be decided by its own CURRENT evidence, a negative control against a copied
+// fixture must not become a project failure, and a passing build must let the run complete.
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import * as C from "../src/controller.js";
+
+process.env.LONGRUN_CONTROLLER_FILE = path.resolve(import.meta.dirname, "..", "src", "controller.js");
+const PLUG_URL = "../plugin/longrun.js";
+const { F } = await import("./helper.mjs");
+
+function freshState() { const d = fs.mkdtempSync(path.join(os.tmpdir(), "lr123-st-")); process.env.LONGRUN_STATE_DIR = d; return d; }
+
+const VERIFY_ALL = `
+import fs from "node:fs";
+const src = fs.readFileSync("./app.txt", "utf8");
+console.log("checks run: 3");
+process.exit(src.includes("BROKEN") ? 1 : 0);
+`;
+function project(good = true) {
+  const d = fs.mkdtempSync(path.join(os.tmpdir(), "lr123-proj-"));
+  fs.writeFileSync(path.join(d, "app.txt"), good ? "GOOD hero scene" : "BROKEN nothing");
+  fs.writeFileSync(path.join(d, "typecheck.mjs"), "process.exit(0);\n");
+  fs.writeFileSync(path.join(d, "build.mjs"), "process.exit(0);\n");
+  fs.writeFileSync(path.join(d, "verify-all.mjs"), VERIFY_ALL);
+  return d;
+}
+const CAT = {
+  "c-typecheck": { command: ["node", "typecheck.mjs"], kind: "cmd", gate: true },
+  "c-build": { command: ["node", "build.mjs"], kind: "cmd", gate: true },
+  "c-verify-all": { command: ["node", "verify-all.mjs"], kind: "cmd", gate: true, negativeControl: true },
+};
+// ENG is class-agnostic (no evidenceClass) so the criterion is satisfied by ANY clean receipt and
+// the ONLY thing under test is the hard-gate recomputation. Criteria supplied as a JSON STRING to
+// prove the single MTPLX-input normalizer; the gate checks are all NON-test (kind cmd).
+const START = {
+  action: "start", request: "Verify the v1.2.3 build/gate reliability release",
+  criteria: JSON.stringify([{ id: "ENG", required: true, weight: 1, checks: ["c-typecheck", "c-build", "c-verify-all"] }]),
+  hardGates: JSON.stringify(["c-typecheck", "c-build", "c-verify-all"]),
+  checkCatalogue: JSON.stringify(CAT),
+};
+const CTX = (d) => ({ sessionID: "s123", agent: "longrun", directory: d, worktree: d });
+
+async function tools() { freshState(); return (await F(PLUG_URL, { client: null })).tool; }
+const gateRow = (st, id) => st.gates.find((g) => g.id === id);
+
+test("start accepts JSON-string criteria/hardGates/checkCatalogue and creates a real run", async () => {
+  const t = await tools(); const d = project(); const c = CTX(d);
+  const start = JSON.parse(await t.longrun.execute({ ...START }, c));
+  assert.ok(start.runId, "run created from stringified structured params");
+  assert.equal(start.initialLoss, 1);
+  const st = JSON.parse(await t.longrun.execute({ action: "status" }, c));
+  assert.equal(st.runId, start.runId, "the stringified catalogue bound correctly (status resolves the run)");
+  assert.equal(st.gates.length, 3, "the three hard gates are surfaced in the status readout");
+});
+
+test("SABOTAGE (isolated fixture) records a negative control, NOT a project failure", async () => {
+  const t = await tools(); const d = project(true); const c = CTX(d);
+  const start = JSON.parse(await t.longrun.execute({ ...START }, c));
+  const RUN = start.runId;
+  const fx = fs.mkdtempSync(path.join(os.tmpdir(), "lr123-fx-"));
+  fs.writeFileSync(path.join(fx, "app.txt"), "BROKEN nothing");
+  fs.writeFileSync(path.join(fx, "verify-all.mjs"), VERIFY_ALL);
+  const neg = JSON.parse(await t.longrun_verify.execute({ checkId: "c-verify-all", mode: "negative", fixture: fx, runId: RUN }, c));
+  assert.equal(neg.kind, "negative_control", "the sabotage ran through the dedicated negative-control channel");
+  assert.equal(neg.ok, true, "the broken fixture correctly failed the verifier");
+  const run = new C.Store(process.env.LONGRUN_STATE_DIR).readJSON(C.stateKey(C.projectIdentity(d), RUN), "run.json");
+  assert.equal((run.receipts || []).filter((r) => r.checkId === "c-verify-all").length, 0, "no positive receipt was made from the sabotage");
+  assert.ok((run.evidence || []).some((e) => e.kind === "negative_control" && e.checkId === "c-verify-all"), "negative control lives in its own channel");
+});
+
+test("passing build + restored verify-all complete a gate-bound run (the reported failure is fixed)", async () => {
+  const t = await tools(); const d = project(true); const c = CTX(d);
+  const start = JSON.parse(await t.longrun.execute({ ...START }, c));
+  const RUN = start.runId;
+  const fx = fs.mkdtempSync(path.join(os.tmpdir(), "lr123-fx-"));
+  fs.writeFileSync(path.join(fx, "app.txt"), "BROKEN nothing"); fs.writeFileSync(path.join(fx, "verify-all.mjs"), VERIFY_ALL);
+  await t.longrun_verify.execute({ checkId: "c-verify-all", mode: "negative", fixture: fx, runId: RUN }, c); // sabotage first
+  for (const id of ["c-typecheck", "c-build", "c-verify-all"]) {
+    const v = JSON.parse(await t.longrun_verify.execute({ checkId: id, runId: RUN }, c));
+    assert.equal(v.status, "PASS", `${id} passes as a non-test gate (no test receipt required)`);
+    assert.equal(v.fpScope, "project", "a project-run receipt is recorded against the project scope");
+  }
+  const st = JSON.parse(await t.longrun.execute({ action: "status" }, c));
+  assert.deepEqual(st.gates.filter((g) => !g.satisfied).map((g) => g.id), [], "all hard gates now read satisfied");
+  reviewProjectFixture(d, RUN);
+  const done = JSON.parse(await t.longrun.execute({ action: "complete" }, c));
+  assert.equal(done.complete, true, "a passing build/tests gate the run -> completion, no longer stuck FAIL");
+});
+
+test("REGRESSION GUARD: a genuinely newer failure is not masked by an earlier PASS", async () => {
+  const t = await tools(); const d = project(true); const c = CTX(d);
+  const start = JSON.parse(await t.longrun.execute({ ...START }, c));
+  const RUN = start.runId;
+  for (const id of ["c-typecheck", "c-build"]) await t.longrun_verify.execute({ checkId: id, runId: RUN }, c);
+  await t.longrun_verify.execute({ checkId: "c-verify-all", runId: RUN }, c); // PASS on the healthy source
+  fs.writeFileSync(path.join(d, "app.txt"), "BROKEN nothing"); // regress, WITHOUT completing
+  const fail = JSON.parse(await t.longrun_verify.execute({ checkId: "c-verify-all", runId: RUN }, c));
+  assert.equal(fail.status, "FAIL", "the re-run honestly fails on the broken source");
+  const st = JSON.parse(await t.longrun.execute({ action: "status" }, c));
+  assert.equal(gateRow(st, "c-verify-all").status, "FAIL", "the gate reads the newest FAIL, not the older PASS");
+  const done = JSON.parse(await t.longrun.execute({ action: "complete" }, c));
+  assert.equal(done.complete, false, "completion re-blocks; the older PASS does not mask the regression");
+});
+
+test("STALE GUARD: an old PASS does not survive a source change (blocked until re-verified)", async () => {
+  const t = await tools(); const d = project(true); const c = CTX(d);
+  const start = JSON.parse(await t.longrun.execute({ ...START }, c));
+  const RUN = start.runId;
+  for (const id of ["c-typecheck", "c-build", "c-verify-all"]) await t.longrun_verify.execute({ checkId: id, runId: RUN }, c);
+  fs.writeFileSync(path.join(d, "extra.txt"), "changed"); // unrelated source edit changes the fingerprint
+  const done = JSON.parse(await t.longrun.execute({ action: "complete" }, c));
+  assert.equal(done.complete, false, "after the source changed the earlier gate passes are stale");
+  assert.equal(done.reason, "stale_evidence", "reported distinctly as stale evidence, not a silent pass");
+});

package/harness/test/v123-receipt-model.test.mjs

@@ -0,0 +1,185 @@
+import { approveFixtureReview } from "./helper.mjs";
+// v1.2.3 reliability regression: the authoritative effective-receipt model + hard-gate recomputation.
+// Reproduces the class of the live failure (a passing build/typecheck/tests still
+// reported ENG incomplete / hard_gates_failed) using COPIED run/receipt state, then shows the
+// upgraded logic completes. Nothing here touches production source, OpenCode config, or any live run.
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import * as C from "../src/controller.js";
+
+const CUR = "curnt"; // the current, correct project fingerprint
+function rc(checkId, status, fp, finishedAt, extra = {}) {
+  return C.makeReceipt({
+    checkId, command: "x", exitCode: status === "PASS" ? 0 : 1, output: "",
+    requirementKind: extra.kind || "cmd", sourceFingerprint: fp,
+    startedAt: finishedAt - 1, finishedAt, fpScope: extra.scope || "project", evidenceClass: extra.ec,
+  });
+}
+function mkRun({ criteria, gates, receipts }) {
+  return { status: "VERIFYING", sourceFingerprint: CUR, faults: [], contract: { criteria, gates, lossTarget: 0 }, receipts, state: {} };
+}
+
+// ---- anti-masking: a NEWER project failure is not hidden behind an older PASS ----------------
+test("effective receipt: a newer FAIL masks an older PASS (real regression)", () => {
+  const run = mkRun({ criteria: [{ id: "ENG", required: true, checks: ["c-build"], status: "PASS" }], gates: [], receipts: [rc("c-build", "PASS", CUR, 10), rc("c-build", "FAIL", CUR, 20)] });
+  assert.equal(C.effectiveStatus(run, "c-build", CUR), "FAIL", "the most recent result governs, not 'any PASS'");
+});
+test("effective receipt: a restore PASS supersedes an earlier FAIL (sabotage then repair)", () => {
+  const run = mkRun({ criteria: [{ id: "ENG", required: true, checks: ["c-build"], status: "PASS" }], gates: [], receipts: [rc("c-build", "FAIL", CUR, 10), rc("c-build", "PASS", CUR, 20)] });
+  assert.equal(C.effectiveStatus(run, "c-build", CUR), "PASS", "the repaired (most recent) state governs");
+});
+
+// ---- fingerprint authority: fixture/copy results never decide a project check ------------------
+test("a copied/fixture FAIL does not invalidate a current project PASS", () => {
+  const run = mkRun({
+    criteria: [{ id: "ENG", required: true, checks: ["c-verify-all"], status: "PASS" }], gates: [],
+    receipts: [rc("c-verify-all", "PASS", CUR, 10, { ec: "INTEGRATION" }), rc("c-verify-all", "FAIL", "copiesab", 20, { scope: "copy" })],
+  });
+  assert.equal(C.effectiveStatus(run, "c-verify-all", CUR), "PASS", "the copied sabotage is not project evidence and cannot turn it red");
+});
+test("an OLD project PASS is STALE on changed source, never trusted", () => {
+  const run = mkRun({ criteria: [{ id: "ENG", required: true, checks: ["c-build"], status: "PASS" }], gates: [], receipts: [rc("c-build", "PASS", "oldfp", 10)] });
+  assert.equal(C.effectiveStatus(run, "c-build", CUR), "STALE", "a pass from a different source state is not a current pass");
+});
+
+// ---- hard-gate readout / completion: independent of test count, recomputed from evidence ------
+test("a build (non-test) hard gate completes on its own clean cmd receipt, no test receipt needed", () => {
+  const run = mkRun({
+    criteria: [{ id: "ENG", required: true, checks: ["c-typecheck", "c-build"], status: "PASS" }],
+    gates: [{ id: "c-typecheck", required: true, status: "FAIL" }, { id: "c-build", required: true, status: "FAIL" }],
+    receipts: [rc("c-typecheck", "PASS", CUR, 1), rc("c-build", "PASS", CUR, 2)],
+  });
+  approveFixtureReview(run, CUR);
+  const cc = C.canComplete(run, { currentFingerprint: CUR });
+  assert.equal(cc.complete, true, "both gates now read PASS from current evidence, despite a cached FAIL status");
+});
+test("a gate whose only evidence is a STALE pass blocks as stale_evidence (not trusting old PASS)", () => {
+  const run = mkRun({
+    criteria: [{ id: "ENG", required: true, checks: ["c-build"], status: "PASS" }],
+    gates: [{ id: "c-build", required: true, status: "FAIL" }],
+    receipts: [rc("c-build", "PASS", "oldfp", 1)], // stale: recorded on a different source state
+  });
+  const cc = C.canComplete(run, { currentFingerprint: CUR });
+  assert.equal(cc.complete, false);
+  assert.equal(cc.reason, "stale_evidence", "stale evidence is reported distinctly, not as a plain pass");
+});
+test("a gate with no project evidence is unverified (a copy sabotage is not a green light either)", () => {
+  const run = mkRun({
+    criteria: [{ id: "ENG", required: true, checks: ["c-verify-all"], status: "PASS" }],
+    gates: [{ id: "c-verify-all", required: true, status: "FAIL" }],
+    receipts: [rc("c-verify-all", "FAIL", "copiesab", 1, { scope: "copy" })], // only a copied-data failure, no project run
+  });
+  const cc = C.canComplete(run, { currentFingerprint: CUR });
+  assert.equal(cc.complete, false);
+  assert.match(cc.reason, /hard_gates_failed/, "no real project verification => the gate stays failed");
+});
+
+test("a multi-check criterion is not pinned 'unverified' by a stale marker when its checks pass", () => {
+  // Mirrors the 2nd-verify STALE flip: the criterion status is STALE but every mapped check has a
+  // current PASS. Completion must read the evidence, not the marker (the live 'ENG incomplete'
+  // symptom that sat alongside a passing build).
+  const run = mkRun({
+    criteria: [{ id: "ENG", required: true, checks: ["c-typecheck", "c-build"], evidenceClass: null, status: "STALE" }],
+    gates: [],
+    receipts: [rc("c-typecheck", "PASS", CUR, 1), rc("c-build", "PASS", CUR, 2)],
+  });
+  assert.deepEqual(C.effectiveRemaining(run, CUR), [], "criterion reports satisfied from current evidence");
+  approveFixtureReview(run, CUR);
+  assert.equal(C.canComplete(run, { currentFingerprint: CUR }).complete, true, "completion follows evidence, not the stale marker");
+});
+test("class awareness is preserved: a UNIT-only proof cannot satisfy a BROWSER criterion", () => {
+  const run = mkRun({
+    criteria: [{ id: "VIS", required: true, checks: ["c-vis"], evidenceClass: "BROWSER", status: "FAIL" }],
+    gates: [],
+    receipts: [rc("c-vis", "PASS", CUR, 1, { ec: "UNIT" })], // class too weak for a BROWSER requirement
+  });
+  const cc = C.canComplete(run, { currentFingerprint: CUR });
+  assert.equal(cc.complete, false);
+  assert.equal(cc.reason, "required_unverified", "a weak proof is an evidence gap, not a completion");
+});
+
+// ---- THE REPRODUCTION: a faithful copy of the run shape -------------------------
+// Gates c-typecheck / c-build / c-verify-all are cached FAIL; every underlying check has a PASS on
+// current source; a build sabotage was recorded against COPIED data (a negative control). The OLD
+// logic (trust cached gate FAIL, or "any PASS") would keep ENG incomplete / hard_gates_failed; the
+// v1.2.3 logic reads the effective receipt and completes.
+function exampleRun() {
+  const receipts = [
+    rc("c-fog-unit", "PASS", CUR, 1, { ec: "UNIT" }),
+    rc("c-detect-unit", "PASS", CUR, 2, { ec: "UNIT" }),
+    rc("c-ui-e2e", "PASS", CUR, 3, { ec: "SYSTEM" }),
+    rc("c-verify-all", "FAIL", "copsab", 4, { scope: "copy" }), // sabotage against a copied workspace
+    rc("c-typecheck", "PASS", CUR, 5),
+    rc("c-build", "PASS", CUR, 6),
+    rc("c-verify-all", "PASS", CUR, 7, { ec: "INTEGRATION" }), // restore, on current source
+  ];
+  const gates = ["c-typecheck", "c-build", "c-verify-all"].map((id) => ({ id, required: true, status: "FAIL" }));
+  const criteria = [
+    { id: "DETERM", required: true, checks: ["c-fog-unit", "c-detect-unit"], evidenceClass: null, status: "PASS" },
+    { id: "ENG", required: true, checks: ["c-typecheck", "c-build", "c-verify-all"], evidenceClass: "INTEGRATION", status: "PASS" },
+  ];
+  return mkRun({ criteria, gates, receipts });
+}
+
+test("REPRODUCE + FIX: passing build/tests no longer pin the hard gates shut", () => {
+  const run = exampleRun();
+  // (old behaviour) a cached FAIL that nothing ever recomputed => permanent block:
+  const oldBlock = run.contract.gates.some((g) => g.required && g.status !== "PASS");
+  assert.equal(oldBlock, true, "the run still carries stale cached gate FAIL values (the reported symptom)");
+  // the sabotage must not be counted as the project's c-verify-all state:
+  assert.equal(C.effectiveStatus(run, "c-verify-all", CUR), "PASS", "copied sabotage excluded; restore PASS governs");
+  for (const id of ["c-typecheck", "c-build", "c-verify-all"]) assert.equal(C.effectiveStatus(run, id, CUR), "PASS", `${id} reads PASS on current source`);
+  assert.deepEqual(C.gateStatuses(run, CUR).filter((g) => !g.satisfied).map((g) => g.id), [], "no hard gate stays stuck FAIL");
+  // (new behaviour) completion follows the effective receipt:
+  approveFixtureReview(run, CUR);
+  const cc = C.canComplete(run, { currentFingerprint: CUR });
+  assert.equal(cc.complete, true, "all hard gates + criteria evaluate PASS from current evidence -> completion allowed");
+});
+
+test("SABOTAGE ISOLATION: a copied failure alone does not make a previously-good gate passable", () => {
+  // If the ONLY evidence for a gate check is the copied sabotage, there is no real project proof.
+  const run = mkRun({
+    criteria: [{ id: "ENG", required: true, checks: ["c-verify-all"], status: "PASS" }],
+    gates: [{ id: "c-verify-all", required: true, status: "FAIL" }],
+    receipts: [rc("c-verify-all", "FAIL", "copiesab", 1, { scope: "copy" })],
+  });
+  const readout = C.gateStatuses(run, CUR);
+  assert.equal(readout[0].status, "NOT_RUN", "a copied result is not project evidence; the gate shows no project proof");
+});
+
+// ---- parseTestCounts: discover real counts; zero is a coverage gap ----------------------------
+test("parseTestCounts discovers vitest/playwright/node:test counts and treats zero as a gap", () => {
+  assert.equal(C.parseTestCounts("Tests  12 passed (12)"), 12);
+  assert.equal(C.parseTestCounts("18 passed (18)"), 18);
+  assert.equal(C.parseTestCounts("ℹ tests 5\nℹ pass 5"), 5);
+  assert.equal(C.parseTestCounts("RESULT pass=4 fail=0 total=4"), 4);
+  assert.equal(C.parseTestCounts("Tests  1 failed (1)\nTests  0 passed"), 0);
+});
+test("a NON-test hard gate (kind cmd) is never forced into NOT_RUN by the zero-test rule", () => {
+  const build = C.makeReceipt({ checkId: "c-build", command: "npm run build", exitCode: 0, testCount: undefined, requirementKind: "cmd", sourceFingerprint: CUR, startedAt: 1, finishedAt: 2 });
+  assert.equal(build.status, "PASS", "build/typecheck pass on exit code; a test receipt is not required");
+});
+
+// ---- normalizeStartArgs: stringified structured params + string budgets/booleans -------------
+test("normalizeStartArgs parses JSON-string criteria/catalogue/hardGates and numeric/bool params", () => {
+  const raw = {
+    request: "x",
+    criteria: '[{"id":"ENG","checks":["c-build"]}]',
+    checkCatalogue: '{"c-build":{"command":["npm","run","build"],"kind":"cmd"}}',
+    hardGates: '["c-build"]',
+    candidateBudget: "6", timeBudgetHours: "0.5", autoContinue: "false",
+  };
+  const n = C.normalizeStartArgs(raw);
+  assert.ok(Array.isArray(n.criteria) && n.criteria[0].id === "ENG", "criteria stringified array parsed");
+  assert.ok(!Array.isArray(n.checkCatalogue) && n.checkCatalogue["c-build"], "catalogue object parsed");
+  assert.deepEqual(n.hardGates, ["c-build"], "hardGates string parsed");
+  assert.equal(n.candidateBudget, 6, "budget coerced to number");
+  assert.equal(n.timeBudgetHours, 0.5);
+  assert.equal(n.autoContinue, false, "string 'false' is not truthy");
+});
+test("normalizeStartArgs never fabricates: malformed JSON -> empty, real arrays untouched", () => {
+  const n = C.normalizeStartArgs({ criteria: "not-json", checkCatalogue: "{bad", candidateBudget: "abc" });
+  assert.deepEqual(n.criteria, [], "malformed criteria becomes empty (=> start refuses, no fake run)");
+  assert.deepEqual(n.checkCatalogue, {}, "malformed catalogue becomes empty");
+  assert.equal(n.candidateBudget, undefined, "non-numeric budget dropped to a safe default");
+});

package/harness/test/v124-canonical.test.mjs

@@ -0,0 +1,147 @@
+import { reviewProjectFixture } from "./helper.mjs";
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import * as C from '../src/controller.js';
+process.env.LONGRUN_TEST = '1';
+process.env.LONGRUN_STATE_DIR = fs.mkdtempSync(path.join(os.tmpdir(),'lr124-state-'));
+process.env.LONGRUN_CONTROLLER_FILE = path.resolve(import.meta.dirname,'../src/controller.js');
+const plugin = await import('../plugin/longrun.js');
+const temp = () => fs.mkdtempSync(path.join(os.tmpdir(),'lr124-project-'));
+const write = (d,p,s) => { fs.mkdirSync(path.dirname(path.join(d,p)),{recursive:true}); fs.writeFileSync(path.join(d,p),s); };
+const rc = (id, fp, exitCode=0, extra={}) => C.makeReceipt({checkId:id,command:'assertions',sourceFingerprint:fp,exitCode,startedAt:1,finishedAt:2,...extra});
+const run = () => ({runId:'fixture',status:'VERIFYING',sourceFingerprint:'a',receipts:[],state:{},contract:{criteria:['one','two'].map(id=>({id,required:true,checks:[id]})),gates:[],lossTarget:0}});
+
+test('canonical loss replays 1 -> .5 -> 0 -> .5; cached best/current cannot manufacture zero',()=>{
+ const r=run();
+ assert.equal(C.deriveRunView(r).currentLoss,1);
+ C.applyVerification(r,{receipt:rc('one','a')}); assert.equal(C.deriveRunView(r).currentLoss,.5);
+ C.applyVerification(r,{receipt:rc('two','a')}); assert.equal(C.deriveRunView(r).bestLoss,0);
+ C.applyVerification(r,{receipt:rc('two','a',1,{finishedAt:3})});
+ const v=C.deriveRunView(r); assert.equal(v.currentLoss,.5);assert.equal(v.bestLoss,0);
+ r.state.best={loss:-100};r.state.current={loss:-100};assert.equal(C.deriveRunView(r).bestLoss,0);
+ const missing=run();missing.state.best={loss:0};assert.equal(C.deriveRunView(missing).bestLoss,1);
+});
+test('hard gate only can block with weighted loss zero',()=>{
+ const r=run();r.receipts=[rc('one','a'),rc('two','a')];r.contract.gates=[{id:'build',checks:['build'],required:true}];
+ const v=C.deriveRunView(r);assert.equal(v.currentLoss,0);assert.equal(v.completionBlocked,true);assert.deepEqual(v.hardGateBlockers.map(g=>g.id),['build']);
+});
+test('missing legacy fingerprint is retained, labelled, and genuinely superseded',()=>{
+ const r=run();r.receipts=[rc('one',undefined)];const before=JSON.stringify(r.receipts);
+ let v=C.deriveRunView(r);const d=v.checks.find(c=>c.checkId==='one');
+ assert.equal(d.staleReason,'LEGACY_STALE_MISSING_FINGERPRINT');assert.equal(d.effectiveReceipt,null);assert.equal(d.historicalReceipts[0].missingField,'sourceFingerprint');
+ assert.equal(JSON.stringify(r.receipts),before);
+ C.applyVerification(r,{receipt:rc('one','a',0,{finishedAt:3})});v=C.deriveRunView(r);
+ assert.equal(v.checks[0].effectiveStatus,'PASS');assert.equal(v.checks[0].historicalReceiptCount,2);assert.equal(JSON.stringify(r.receipts.slice(0,1)),before);
+});
+test('contract/evaluator mismatch and negative controls cannot supply current PASS',()=>{
+ const r=run();r.contractHash='contract';r.evaluatorHash='evaluator';
+ r.receipts=[rc('one','a',0,{contractHash:'old'})];assert.equal(C.deriveRunView(r).checks[0].staleReason,'CONTRACT_MISMATCH');
+ r.receipts=[rc('one','a',0,{contractHash:'contract',evaluatorHash:'old'})];assert.equal(C.deriveRunView(r).checks[0].staleReason,'EVALUATOR_MISMATCH');
+ r.receipts=[rc('one','a',0,{contractHash:'contract',evaluatorHash:'evaluator'}),{...rc('one','a',1,{finishedAt:3}),mode:'negative'}];assert.equal(C.deriveRunView(r).checks[0].effectiveStatus,'PASS');
+});
+test('fingerprints exclude generated evidence/checkpoints/harness outputs but include app/test/config edits',()=>{
+ const d=temp();write(d,'src/app.ts','export const a=1');write(d,'package.json','{}');
+ const base=C.sourceFingerprint(d);
+ for(const p of ['.longrun/events.log','docs/CHECKPOINT.md','artifacts/screen.png','artifacts/receipt.json','test-results/x.json','packages/web/dist/index.html','longrun-harness/releases/x/controller.js'])write(d,p,'generated');
+ assert.equal(C.sourceFingerprint(d).hash,base.hash);assert.notEqual(C.sourceFingerprint(d).legacyHash,base.legacyHash);
+ for(const p of ['src/app.ts','test/app.test.ts','package.json']){const old=C.sourceFingerprint(d).hash;write(d,p,'changed');assert.notEqual(C.sourceFingerprint(d).hash,old);}
+});
+test('fingerprint policy migration recognizes only observed legacy identity; revisiting a candidate is not new',()=>{
+ const r=run();r.state.lastEvalFingerprint='old';
+ const receipt=rc('one','new',0,{fingerprintSchemaVersion:2});
+ const a=C.applyVerification(r,{receipt,currentFingerprint:{hash:'new',legacyHash:'old'}});assert.equal(a.counted,false);
+ assert.equal(C.applyVerification(r,{receipt:rc('one','new',0,{fingerprintSchemaVersion:2}),currentFingerprint:{hash:'new',legacyHash:'metadata-changed'}}).counted,false);
+ C.applyVerification(r,{receipt:rc('one','b')});C.applyVerification(r,{receipt:rc('one','c')});
+ const n=C.candidateCount(r);C.applyVerification(r,{receipt:rc('one','b')});assert.equal(C.candidateCount(r),n);
+});
+test('memory generator upgrade stays fresh; ordinary edit stays fresh; precise entry change and refresh',()=>{
+ const d=temp();write(d,'package.json','{}');write(d,'src/index.ts','export const x=1');write(d,'src/body.ts','export const b=1');
+ C.memory.initDeep(d,{harnessVersion:'1.2.2'});const index=C.memory.readMemoryIndex(d);index.harnessVersion='1.2.2';
+ assert.equal(C.memory.assessStaleness(d,index).status,'FRESH');write(d,'src/body.ts','export const b=2');assert.equal(C.memory.assessStaleness(d,index).status,'FRESH');
+ write(d,'src/index.ts','export const x=2');const v=C.memory.assessStaleness(d,index);assert.equal(v.status,'STALE');assert.ok(v.changedDependencies.some(x=>x.path==='src/index.ts' && x.previousFingerprint!==x.currentFingerprint));
+ C.memory.initDeep(d,{harnessVersion:'1.2.4'});assert.equal(C.memory.assessStaleness(d,C.memory.readMemoryIndex(d)).status,'FRESH');
+});
+test('old memory digest mismatch is honest about absent path history and schema mismatch',()=>{
+ const d=temp();write(d,'package.json','{}');C.memory.initDeep(d,{harnessVersion:'1.2.2'});const index=C.memory.readMemoryIndex(d);delete index.structuralDependencies;
+ write(d,'package.json','{"scripts":{"test":"node --test"}}');let v=C.memory.assessStaleness(d,index);
+ assert.ok(v.changedDependencies.some(x=>x.reason==='LEGACY_STRUCTURAL_DIGEST_CHANGED' && x.exactPathsKnown===false));
+ index.memorySchemaVersion=99;v=C.memory.assessStaleness(d,index);assert.ok(v.changedDependencies.some(x=>x.reason==='MEMORY_SCHEMA_INCOMPATIBLE'));
+});
+async function seed(r,d) {
+ const sd=fs.mkdtempSync(path.join(os.tmpdir(),'lr124-store-'));process.env.LONGRUN_STATE_DIR=sd;
+ const key=C.stateKey(C.projectIdentity(d),r.runId);r.directory=d;const store=new C.Store(sd);store.writeJSON(key,'run.json',r);
+ fs.writeFileSync(path.join(sd,'runs.json'),JSON.stringify({offline:{runKey:key,directory:d,runId:r.runId,checkCatalogue:r.checkCatalogue}}));
+ const hooks=await plugin.default.server({client:null});
+ const t=hooks.tool,ctx={sessionID:'offline',directory:d,worktree:d};
+ const call=async action=>{const text=await t.longrun.execute({action,runId:r.runId},ctx);try{return JSON.parse(text)}catch{return text}};
+ return {t,ctx,call,store,key,hooks};
+}
+test('compaction recovery matches explicit recovery after source and memory dependencies change',async(testContext)=>{
+ const d=temp();write(d,'src/index.ts','export const value=1');write(d,'package.json','{}');
+ C.memory.initDeep(d,{harnessVersion:'1.2.4'});
+ const r=run();r.checkCatalogue={one:{kind:'cmd',command:[process.execPath,'-e',"require('node:assert/strict').equal(require('node:fs').readFileSync('src/index.ts','utf8'),'export const value=1')"]}};
+ const {t,ctx,call,store,key,hooks}=await seed(r,d);
+ assert.equal(JSON.parse(await t.longrun_verify.execute({checkId:'one',runId:r.runId},ctx)).status,'PASS');
+ write(d,'src/index.ts','export const value=2');
+ const before=store.readJSON(key,'run.json');
+ const observedAt=Date.now();testContext.mock.method(Date,'now',()=>observedAt); // compare the same observation, including live deadline timing
+ const packet=await call('resume-context');
+ assert.match(packet,/CURRENT LOSS: 1/);assert.match(packet,/MEMORY STATUS: STALE/);
+ const output={context:['existing host context']};
+ await hooks['experimental.session.compacting']({sessionID:'offline'},output);
+ assert.equal(output.context.length,2);
+ assert.equal(output.context[0],'existing host context');
+ assert.match(output.context[1],/^## Long-run recovery\nPRE-COMPACTION SNAPSHOT:/);
+ assert.ok(output.context[1].endsWith(packet));
+ assert.deepEqual(store.readJSON(key,'run.json'),before,'compaction must not rewrite ledger or fingerprints');
+});
+test('real recorded receipt fixture: 18 stale plus 4 absent, 36 retained, 13 candidates and contract untouched across tool projections',async(t)=>{
+ const r=JSON.parse(fs.readFileSync(new URL('./fixtures/example-app-run.json',import.meta.url)));const original=JSON.stringify(r.contract), receipts=JSON.stringify(r.receipts),budget=JSON.stringify(r.budget);
+ assert.equal(r.receipts.length,36);assert.ok(r.receipts.every(x=>x.sourceFingerprint));
+ const d=temp();write(d,'app.ts','isolated fixture');const {call,store,key}=await seed(r,d);
+ const observedAt=Date.now();t.mock.method(Date,'now',()=>observedAt); // stable clock for exact projection equality
+ const status=await call('status'),verify=await call('verify'),complete=await call('complete');
+ for(const k of ['currentLoss','bestLoss','targetLoss','memoryStatus','candidateCount','budgets','criterionStates','hardGateBlockers','evidenceGaps','completionBlocked']){assert.deepEqual(status[k],verify[k]);assert.deepEqual(status[k],complete[k]);}
+ assert.equal(status.candidateCount,13);assert.equal(status.currentLoss,1);assert.equal(status.staleEvidence.length,18);assert.equal(status.historicalReceiptCount,36);assert.equal(status.completionBlocked,true);
+ assert.deepEqual(status.checks.filter(x=>x.blockingReason==='NO_RECEIPT').map(x=>x.checkId), ['c-detect-e2e','c-sec-e2e','c-ai-e2e','c-mission-e2e']);
+ assert.ok(status.staleEvidence.every(x=>x.staleReason==='SOURCE_FINGERPRINT_MISMATCH'));
+ for(const a of ['next','resume-context']){const packet=await call(a);assert.match(packet,/CURRENT LOSS: 1/);assert.match(packet,/HISTORICAL RECEIPTS: 36/);assert.ok(packet.includes(`BEST LOSS: ${status.bestLoss}`));}
+ assert.equal((await call('memory_status')).status,status.memoryStatus);
+ await call('checkpoint');assert.deepEqual(C.summarizeRunView(store.readJSON(key,'checkpoint.json').view),status);
+ const after=store.readJSON(key,'run.json');assert.equal(JSON.stringify(after.contract),original);assert.equal(JSON.stringify(after.receipts),receipts);assert.equal(JSON.stringify(after.budget),budget);
+});
+test('actual declared assertion receipt clears a legacy block without contract changes; current failure reblocks',async()=>{
+ const d=temp();write(d,'app.txt','valid');
+ const r=run();r.contract.criteria=[{id:'one',required:true,checks:['one']}];r.contract.gates=[{id:'one',required:true}];
+ r.checkCatalogue={one:{kind:'cmd',command:['node','-e',"require('node:assert/strict').equal(require('node:fs').readFileSync('app.txt','utf8'),'valid')"]}};
+ r.receipts=[rc('one',undefined)];const original=JSON.stringify(r.contract);const {call,t,ctx,store,key}=await seed(r,d);
+ assert.equal((await call('complete')).complete,false);
+ const v=JSON.parse(await t.longrun_verify.execute({checkId:'one',runId:r.runId},ctx));assert.equal(v.status,'PASS');assert.equal((await call('status')).currentLoss,0);
+ write(d,'app.txt','broken');assert.equal(JSON.parse(await t.longrun_verify.execute({checkId:'one',runId:r.runId},ctx)).status,'FAIL');assert.equal((await call('complete')).complete,false);
+ write(d,'app.txt','valid');await t.longrun_verify.execute({checkId:'one',runId:r.runId},ctx);reviewProjectFixture(d,r.runId);assert.equal((await call('complete')).complete,true);
+ const saved=store.readJSON(key,'run.json');assert.equal(JSON.stringify(saved.contract),original);assert.equal(saved.receipts.length,4);
+});
+
+test('source changed during verifier execution cannot generate a current PASS',async()=>{
+ const d=temp();write(d,'app.txt','valid');const r=run();r.checkCatalogue={one:{kind:'cmd',command:['node','-e',"require('node:fs').writeFileSync('app.txt','changed')"]}};
+ const {t,ctx,call}=await seed(r,d);
+ const result=JSON.parse(await t.longrun_verify.execute({checkId:'one',runId:r.runId},ctx));assert.equal(result.status,'STALE');
+ assert.equal((await call('complete')).complete,false);
+});
+test('missing receipts never inherit cached PASS, including gate-only checks',()=>{
+ const r=run();r.contract.criteria.forEach(c=>c.status='PASS');r.checkCatalogue={build:{command:['node','build.js']}};r.contract.gates=[{id:'build',required:true,status:'PASS'}];
+ const v=C.deriveRunView(r);assert.equal(v.currentLoss,1);assert.equal(v.gates[0].status,'NOT_RUN');assert.equal(v.completionBlocked,true);
+});
+test('schema migration cannot invent a fingerprint for a legacy PASS',()=>{
+ const r=run();r.receipts=[rc('one','old-hash')];
+ const diag=C.checkDiagnostics(r,'one',{hash:'new-hash',legacyHash:'old-hash',schemaVersion:2});assert.equal(diag.effectiveStatus,'PASS');assert.equal(diag.receiptFingerprint,'old-hash');
+ assert.equal(C.checkDiagnostics(r,'one',{hash:'new-hash',legacyHash:'different'}).effectiveStatus,'STALE');
+});
+test('explicit unknown control-plane run cannot complete or pause the current run',async()=>{
+ const d=temp(),r=run();const {t,ctx,store,key}=await seed(r,d);
+ for(const action of ['status','complete','pause'])assert.equal(JSON.parse(await t.longrun.execute({action,runId:'wrong'},ctx)).state,'NO_RUN');
+ assert.equal(store.readJSON(key,'run.json').status,'VERIFYING');
+});

package/harness/test/v124-installed.test.mjs

@@ -0,0 +1,48 @@
+import { test } from 'node:test';import assert from 'node:assert/strict';import fs from 'node:fs';import os from 'node:os';import path from 'node:path';import { spawnSync } from 'node:child_process';import { pathToFileURL } from 'node:url';
+import { install,VERSION } from '../src/install.mjs';
+process.env.LONGRUN_TEST='1';
+process.env.LONGRUN_STATE_DIR=fs.mkdtempSync(path.join(os.tmpdir(),'lr124-installed-state-'));
+delete process.env.LONGRUN_CONTROLLER_FILE;
+test('installed artifact executes canonical v1.2.4 independently of source and preserves unrelated JSONC',async(t)=>{
+ const config=fs.mkdtempSync(path.join(os.tmpdir(),'lr124-config-')),project=fs.mkdtempSync(path.join(os.tmpdir(),'lr124-installed-project-'));
+ fs.writeFileSync(path.join(project,'value.txt'),'tested');
+ const jsonc='// keep comments\n{"model":"unchanged/provider","permission":"ask"}\n';fs.writeFileSync(path.join(config,'opencode.jsonc'),jsonc);fs.mkdirSync(path.join(config,'plugins'));fs.writeFileSync(path.join(config,'plugins/unrelated.js'),'// unrelated\n');
+ assert.equal(install({configDir:config}).conflicts.length,0);
+ assert.equal(fs.readFileSync(path.join(config,'opencode.jsonc'),'utf8'),jsonc);
+ const pluginPath=path.join(config,'plugins/longrun.js'),module=await import(pathToFileURL(pluginPath));assert.deepEqual(Object.keys(module),['default']);assert.equal(module.default.id,'longrun');
+ assert.ok(fs.readFileSync(pluginPath,'utf8').includes(`/releases/${VERSION}/lib/controller.js`));
+ const hooks=await module.default.server({client:null});
+ const tools=hooks.tool,ctx={sessionID:'isolated',directory:project,worktree:project};
+ const call=async args=>JSON.parse(await tools.longrun.execute(args,ctx));
+ assert.equal((await call({action:'help'})).harnessVersion,VERSION);
+ const command=['node','-e',"require('node:assert/strict').equal(require('node:fs').readFileSync('value.txt','utf8'),'tested')"];
+ const start=await call({action:'start',request:'Verify installed assertion',criteria:[{id:'assertion',checks:['assertion']}],checkCatalogue:{assertion:{command,kind:'cmd'}}});
+ assert.ok(start.runId,JSON.stringify(start));
+ const saved=await call({action:'checkpoint',runId:start.runId,progress:{currentSlice:'installed recovery',nextAction:'execute declared assertion'}});
+ assert.equal(saved.checkpointed,true);
+ assert.match(await tools.longrun.execute({action:'resume-context',runId:start.runId},ctx),/NEXT ACTION: execute declared assertion/);
+ assert.equal(JSON.parse(await tools.longrun_verify.execute({runId:start.runId,checkId:'assertion'},ctx)).status,'PASS');
+ assert.equal((await call({action:'complete'})).blockReason,'completion_review_required');
+ await tools.longrun.execute({action:'pause',runId:start.runId},ctx);
+ const pending=await call({action:'status'});
+ const reasonFile=path.join(config,'review-reason.txt');fs.writeFileSync(reasonFile,'Independent isolated installed-artifact review.');
+ const env={...process.env,OPENCODE_CONFIG_DIR:config};delete env.LONGRUN_CONTROLLER_FILE;delete env.NODE_TEST_CONTEXT;
+ const review=spawnSync(path.join(config,'longrun-harness/longrun'),['review','--project',project,'--run',start.runId,'--verdict','accept','--expected-basis',pending.completionReview.basis,'--review-id','installed-review','--reason-file',reasonFile,'--json'],{cwd:os.tmpdir(),env,encoding:'utf8'});
+ assert.equal(review.status,0,review.stdout+review.stderr);assert.equal(JSON.parse(review.stdout).completionReview.status,'ACCEPTED');
+ const status=await call({action:'status'}),verify=await call({action:'verify'}),complete=await call({action:'complete'});
+ for(const key of ['currentLoss','bestLoss','targetLoss','candidateCount','memoryStatus','completionBlocked','hardGateBlockers','evidenceGaps']){assert.deepEqual(verify[key],status[key]);assert.deepEqual(complete[key],status[key]);}
+ assert.equal(complete.complete,true);
+
+ const doctor=spawnSync(path.join(config,'longrun-harness/longrun'),['doctor','--json'],{cwd:project,env,encoding:'utf8'});
+ assert.equal(doctor.status,0,doctor.stdout+doctor.stderr);const report=JSON.parse(doctor.stdout);assert.equal(report.installedVersion,VERSION);assert.equal(report.ok,true);assert.equal(report.executedControllerVersion,VERSION);
+ const cli=spawnSync(path.join(config,'longrun-harness/longrun'),['status','--project',project,'--run',start.runId,'--json'],{cwd:project,env,encoding:'utf8'});
+ assert.equal(cli.status,0,cli.stdout+cli.stderr);const cliView=JSON.parse(cli.stdout);assert.equal(cliView.currentLoss,status.currentLoss);assert.equal(cliView.bestLoss,status.bestLoss);assert.equal(cliView.memoryStatus,status.memoryStatus);
+ fs.writeFileSync(path.join(project,'value.txt'),'changed after verification');
+ const observedAt=Date.now();t.mock.method(Date,'now',()=>observedAt); // both recovery paths observe the same deadline instant
+ const packet=await tools.longrun.execute({action:'resume-context',runId:start.runId},ctx);
+ assert.match(packet,/CURRENT LOSS: 1/);
+ const output={context:[]};await hooks['experimental.session.compacting']({sessionID:'isolated'},output);
+ assert.equal(output.context.length,1);
+ assert.match(output.context[0],/^## Long-run recovery\nPRE-COMPACTION SNAPSHOT:/);
+ assert.ok(output.context[0].endsWith(packet));
+});