opencode-longrun-harness 1.2.22

package/harness/test/memory.test.mjs

@@ -0,0 +1,145 @@
+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 M from "../src/memory.mjs";
+
+const mk = (...p) => { const d = path.join(...p); fs.mkdirSync(d, { recursive: true }); return d; };
+const tmp = (p = "mem") => fs.mkdtempSync(path.join(os.tmpdir(), p + "-"));
+const write = (p, s) => { fs.mkdirSync(path.dirname(p), { recursive: true }); fs.writeFileSync(p, s); };
+
+// ---- tiny repo -> root only (do not create unnecessary hierarchy) --------------------------
+test("tiny repo: init-deep creates ONLY the root AGENTS.md", () => {
+  const d = tmp();
+  write(path.join(d, "main.cjs"), "module.exports=1;");
+  const sel = M.selectTargets(M.scanTree(d));
+  assert.deepEqual(sel.filter((t) => t.selected).map((t) => t.rel), [""], "only root selected");
+  const r = M.initDeep(d, { harnessVersion: "1.2.0" });
+  assert.deepEqual(r.created.map((c) => c.rel).sort(), [""], "only root written");
+  assert.ok(fs.existsSync(path.join(d, "AGENTS.md")));
+});
+
+// ---- monorepo -> appropriate nested memory --------------------------------------------------
+test("monorepo: high-complexity package gets a child AGENTS.md", () => {
+  const d = tmp("mono");
+  for (let i = 0; i < 14; i++) write(path.join(d, "packages", "core", "f" + i + ".ts"), "export const v" + i + " = 1;\n// NEVER inline secrets\n");
+  write(path.join(d, "packages", "core", "index.ts"), "export * from './f0';\n");
+  write(path.join(d, "packages", "core", "core.test.ts"), "//test\n");
+  write(path.join(d, "packages", "core", "package.json"), JSON.stringify({ name: "core" }));
+  write(path.join(d, "package.json"), JSON.stringify({ name: "mono", scripts: { test: "node --test" } }));
+  const created = M.initDeep(d, {}).created.map((c) => c.rel).sort();
+  assert.ok(created.includes(""), "root present");
+  assert.ok(created.includes("packages/core"), "packages/core got child memory");
+});
+
+// ---- child must NOT merely repeat parent ----------------------------------------------------
+test("child memory does not repeat parent content and contains no generic advice", () => {
+  const d = tmp("dedup");
+  // root has a broad structure section; child should not echo it verbatim, no generic advice.
+  write(path.join(d, "AGENTS.md"), "## STRUCTURE\n- top: layout of everything at the repo root for overview purposes\n");
+  for (let i = 0; i < 8; i++) write(path.join(d, "svc", "f" + i + ".ts"), "export const q = 1;");
+  write(path.join(d, "svc", "package.json"), JSON.stringify({ name: "svc" }));
+  const r = M.initDeep(d, { regenerate: true }); // regenerate so the child gets generated
+  const childPath = path.join(d, "svc", "AGENTS.md");
+  const child = fs.readFileSync(childPath, "utf8");
+  assert.ok(!/generic|write clean code|follow best practices|keep it simple/i.test(child), "no generic advice in child");
+  assert.ok(!child.includes("layout of everything at the repo root for overview purposes"), "child does not copy the parent's overview line");
+  assert.ok(r.created.some((c) => c.rel === "svc"));
+});
+
+// ---- high selected, low skipped -------------------------------------------------------------
+test("high-complexity dir selected; low-complexity dir skipped (parent sufficient)", () => {
+  const d = tmp("tier");
+  for (let i = 0; i < 20; i++) write(path.join(d, "big", "f" + i + ".ts"), "export const v=1;\n// ALWAYS validate\n");
+  write(path.join(d, "big", "package.json"), JSON.stringify({ name: "big" }));
+  write(path.join(d, "big", "index.ts"), "//entry");
+  write(path.join(d, "big", "a.test.ts"), "//t");
+  write(path.join(d, "tiny", "single.ts"), "x=1;");
+  const sel = Object.fromEntries(M.selectTargets(M.scanTree(d)).filter((t) => t.rel && !t.rel.includes("/")).map((t) => [t.rel, { s: t.selected, tier: t.tier }]));
+  assert.equal(sel.big.s, true, "big selected"); assert.equal(sel.big.tier, "high");
+  assert.equal(sel.tiny.s, false, "tiny skipped"); assert.equal(sel.tiny.tier, "low");
+});
+
+// ---- existing human AGENTS.md preserved -----------------------------------------------------
+test("existing human-written AGENTS.md (no managed markers) is preserved, not overwritten", () => {
+  const d = tmp("preserve");
+  for (let i = 0; i < 12; i++) write(path.join(d, "a" + i + ".ts"), "export const v=1;");
+  write(path.join(d, "AGENTS.md"), "# My hand-written notes\nIMPORTANT: never edit generated files.\n");
+  const r = M.initDeep(d, {});
+  const content = fs.readFileSync(path.join(d, "AGENTS.md"), "utf8");
+  assert.match(content, /My hand-written notes/, "human content preserved");
+  assert.ok(r.preserved.some((p) => p.rel === ""), "reported as preserved");
+  assert.ok(!r.created.some((c) => c.rel === ""), "not recreated");
+});
+
+// ---- managed-section refresh (incremental, not wholesale) ------------------------------------
+test("incremental refresh updates the managed block but keeps human prose outside it", () => {
+  const d = tmp("refresh");
+  for (let i = 0; i < 12; i++) write(path.join(d, "a" + i + ".ts"), "export const v=1;");
+  write(path.join(d, "AGENTS.md"), "Human preamble: talk to alice before changing.\n" + M.MANAGED_BEGIN + "\nstale content\n" + M.MANAGED_END + "\nHuman epilogue: run make fmt.\n");
+  const r = M.initDeep(d, {});
+  const content = fs.readFileSync(path.join(d, "AGENTS.md"), "utf8");
+  assert.match(content, /talk to alice before changing/, "human preamble kept");
+  assert.match(content, /run make fmt/, "human epilogue kept");
+  assert.ok(!content.includes("stale content"), "stale managed block replaced");
+  assert.equal(r.updated.find((c) => c.rel === "").action, "updated");
+});
+
+// ---- staleness: ordinary source edit does not stale all memory ------------------------------
+test("ordinary body edit does not mark all memory stale", () => {
+  const d = tmp("fresh");
+  for (let i = 0; i < 10; i++) write(path.join(d, "src", "f" + i + ".ts"), "export const v=1;");
+  write(path.join(d, "index.ts"), "export * from './src/f0';");
+  write(path.join(d, "package.json"), JSON.stringify({ name: "x", scripts: { test: "node --test" } }));
+  M.initDeep(d, {});
+  const idx = M.readMemoryIndex(d);
+  fs.writeFileSync(path.join(d, "src", "f3.ts"), "export const v=changed-but-same-shape;");
+  fs.writeFileSync(path.join(d, "src", "f4.ts"), "export const v=changed-too;");
+  const s = M.assessStaleness(d, idx);
+  assert.ok(s.status === "FRESH" || s.status === "POSSIBLY_STALE", "not full STALE: " + JSON.stringify(s));
+  assert.notEqual(s.status, "STALE", "a body edit is not a structural change");
+});
+
+// ---- staleness: structural changes ARE detected ---------------------------------------------
+test("structural change (new package + manifest edit) is reported STALE with reasons", () => {
+  const d = tmp("stale");
+  for (let i = 0; i < 10; i++) write(path.join(d, "packages", "a", "f" + i + ".ts"), "export const v=1;");
+  write(path.join(d, "packages", "a", "package.json"), JSON.stringify({ name: "a" }));
+  write(path.join(d, "package.json"), JSON.stringify({ name: "root", scripts: { test: "node --test" } }));
+  M.initDeep(d, {});
+  const idx = M.readMemoryIndex(d);
+  // add a new package + change root manifest (add a build command)
+  for (let i = 0; i < 8; i++) write(path.join(d, "packages", "b", "g" + i + ".ts"), "export const v=1;");
+  write(path.join(d, "packages", "b", "package.json"), JSON.stringify({ name: "b" }));
+  write(path.join(d, "package.json"), JSON.stringify({ name: "root", scripts: { test: "node --test", build: "tsc" } }));
+  const s = M.assessStaleness(d, idx);
+  assert.equal(s.status, "STALE");
+  assert.ok(s.reasons.length >= 1, "reasons present");
+});
+
+// ---- dry-run does not modify files ----------------------------------------------------------
+test("dry-run lists proposed locations but writes nothing", () => {
+  const d = tmp("dry");
+  for (let i = 0; i < 12; i++) write(path.join(d, "pkg", "f" + i + ".ts"), "export const v=1;");
+  write(path.join(d, "pkg", "package.json"), JSON.stringify({ name: "pkg" }));
+  const before = fs.readdirSync(d, { recursive: true }).slice().sort();
+  const r = M.initDeep(d, { dryRun: true });
+  const after = fs.readdirSync(d, { recursive: true }).slice().sort();
+  assert.deepEqual(after, before, "no files created/removed on dry-run");
+  assert.ok(!fs.existsSync(path.join(d, M.MEMORY_PATH)), "no memory index written on dry-run");
+  assert.ok(r.willWrite.length > 0, "dry-run still reports proposed locations");
+});
+
+// ---- memory index carries staleness inputs --------------------------------------------------
+test("memory-index.json records schema version, commit, node scores + manifest fingerprints", () => {
+  const d = tmp("idx");
+  for (let i = 0; i < 12; i++) write(path.join(d, "pkg", "f" + i + ".ts"), "export const v=1;");
+  write(path.join(d, "pkg", "package.json"), JSON.stringify({ name: "pkg" }));
+  const r = M.initDeep(d, {});
+  const idx = M.readMemoryIndex(d);
+  assert.equal(idx.schemaVersion, 1);
+  assert.ok(typeof idx.structuralKey === "string" && idx.structuralKey.length === 64);
+  assert.ok(idx.nodes.some((n) => n.selected && n.signature.manifests && Object.keys(n.signature.manifests).length), "manifest fingerprint recorded for a package node");
+  assert.ok(idx.nodes.every((n) => typeof n.tier === "string"), "tiers recorded (score/reason kept in index, not prose)");
+});

package/harness/test/negative-control.test.mjs

@@ -0,0 +1,91 @@
+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";
+
+const CONTROLLER = path.resolve(import.meta.dirname, "..", "src", "controller.js");
+process.env.LONGRUN_CONTROLLER_FILE = CONTROLLER;
+const PLUG_URL = "../plugin/longrun.js";
+const { F } = await import("./helper.mjs");
+
+function freshState() { const d = fs.mkdtempSync(path.join(os.tmpdir(), "lrnc-st-")); process.env.LONGRUN_STATE_DIR = d; return d; }
+
+// A read-only protected runner: it only READS ./app.mjs (never writes anything).
+const RUNNER = `
+import { Widget } from "./app.mjs";
+let fail = 0;
+try { const w = new Widget(); if (!w.render().includes("hero")) { fail++; } } catch { fail++; }
+console.log("RESULT " + (fail === 0 ? "PASS" : "FAIL"));
+process.exit(fail === 0 ? 0 : 1);
+`;
+const APP_FIXED = `export class Widget { render(){ return "hero + scene"; } }`;
+const APP_BROKEN = `export class Widget { render(){ return "nothing attached"; } }`; // hero missing => runner fails
+
+function fixture(app) { const d = fs.mkdtempSync(path.join(os.tmpdir(), "fixture-")); fs.writeFileSync(path.join(d, "app.mjs"), app); fs.writeFileSync(path.join(d, "run_acceptance.mjs"), RUNNER); return d; }
+function project(app) { const d = fixture(app); return d; } // project layout identical to a fixture
+
+function safeRuns(dir) { try { return JSON.parse(fs.readFileSync(path.join(dir, "runs.json"), "utf8")); } catch { return {}; } }
+
+async function seededRun({ app, check = { command: ["node", "run_acceptance.mjs"], kind: "test", integration: true, gate: true, negativeControl: true } }) {
+  freshState();
+  const dir = project(app);
+  const h = await F(PLUG_URL, { client: null });
+  const id = C.projectIdentity(dir);
+  const key = C.stateKey(id, "run1");
+  const store = new C.Store(process.env.LONGRUN_STATE_DIR);
+  const run = C.startRun({ request: "t", contract: { criteria: [{ id: "c1", required: true, checks: ["acc"], status: "FAIL", visual: true }], gates: [{ id: "render-gate", required: true, status: "FAIL" }], lossTarget: 0 }, budgets: C.defaultBudget(), sourceFingerprint: C.sourceFingerprint(dir).hash, directory: dir, checkCatalogue: { acc: check } }).run;
+  store.writeJSON(key, "run.json", run);
+  const runs = safeRuns(process.env.LONGRUN_STATE_DIR);
+  runs["sess-1"] = { runKey: key, directory: dir, checkCatalogue: { acc: check } };
+  fs.writeFileSync(path.join(process.env.LONGRUN_STATE_DIR, "runs.json"), JSON.stringify(runs));
+  return { h, dir, key, store };
+}
+const CTX = (dir) => ({ sessionID: "sess-1", agent: "longrun", directory: dir, worktree: dir });
+
+// ---- a known-broken fixture makes the protected verifier FAIL (live verifier) --------------
+test("negative control: a known-broken fixture causes the protected verifier to fail", async () => {
+  const { h, dir } = await seededRun({ app: APP_FIXED });
+  const brokenFixture = fixture(APP_BROKEN); // isolated temp copy of the BROKEN implementation
+  const res = JSON.parse(await h.tool.longrun_verify.execute({ checkId: "acc", mode: "negative", fixture: brokenFixture }, CTX(dir)));
+  assert.equal(res.kind, "negative_control");
+  assert.equal(res.ok, true, "verifier correctly failed on the broken fixture (proving it is live)");
+});
+
+// ---- a negative run must NOT be satisfied by the healthy app, and cannot touch production --
+test("a negative control against the HEALTHY app is not a valid negative + never mutates production", async () => {
+  const { h, dir } = await seededRun({ app: APP_FIXED });
+  const fpBefore = C.sourceFingerprint(dir).hash;
+  const res = JSON.parse(await h.tool.longrun_verify.execute({ checkId: "acc", mode: "negative", fixture: project(APP_FIXED) }, CTX(dir)));
+  assert.equal(res.kind, "negative_control");
+  assert.equal(res.ok, false, "the verifier passed a healthy fixture => NOT a valid negative control (warning)");
+  // production state must be byte-identical afterwards (isolated fixture cwd only)
+  assert.equal(C.sourceFingerprint(dir).hash, fpBefore, "negative run must not mutate the active project");
+});
+
+// ---- a negative control without an isolated fixture is refused (no destructive path) -------
+test("negative control without a fixture is refused (never edits the active source)", async () => {
+  const { h, dir } = await seededRun({ app: APP_FIXED });
+  const res = JSON.parse(await h.tool.longrun_verify.execute({ checkId: "acc", mode: "negative" }, CTX(dir)));
+  assert.equal(res.error, "no_fixture");
+});
+
+// ---- restored (healthy) app passes the normal verifier -------------------------------------
+test("the restored/healthy implementation passes the normal verifier (positive control)", async () => {
+  freshState();
+  const dir = project(APP_FIXED); // project contains the FIXED app + runner
+  const h = await F(PLUG_URL, { client: null });
+  const id = C.projectIdentity(dir);
+  const key = C.stateKey(id, "run1");
+  const store = new C.Store(process.env.LONGRUN_STATE_DIR);
+  // baseline fingerprint differs from the live source -> this eval is an evaluated CHANGED state
+  const run = C.startRun({ request: "t", contract: { criteria: [{ id: "c1", required: true, checks: ["acc"], status: "FAIL" }], gates: [], lossTarget: 0 }, budgets: C.defaultBudget(), sourceFingerprint: "baseline-before-edit", directory: dir, checkCatalogue: { acc: { command: ["node", "run_acceptance.mjs"], kind: "cmd" } } }).run;
+  store.writeJSON(key, "run.json", run);
+  const runs = safeRuns(process.env.LONGRUN_STATE_DIR);
+  runs["sess-1"] = { runKey: key, directory: dir, checkCatalogue: { acc: { command: ["node", "run_acceptance.mjs"], kind: "cmd" } } };
+  fs.writeFileSync(path.join(process.env.LONGRUN_STATE_DIR, "runs.json"), JSON.stringify(runs));
+  const res = JSON.parse(await h.tool.longrun_verify.execute({ checkId: "acc" }, CTX(dir)));
+  assert.equal(res.status, "PASS", "healthy app passes; candidateCounted should follow a real eval");
+  assert.equal(res.candidateCounted, true);
+});

package/harness/test/plugin.test.mjs

@@ -0,0 +1,169 @@
+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";
+
+// Point the plugin at the shared controller + an isolated state dir BEFORE import.
+const CONTROLLER = path.resolve(import.meta.dirname, "..", "src", "controller.js");
+process.env.LONGRUN_CONTROLLER_FILE = CONTROLLER;
+const STATE = fs.mkdtempSync(path.join(os.tmpdir(), "lrplug-"));
+process.env.LONGRUN_STATE_DIR = STATE;
+
+// The plugin entrypoint now exposes ONE export (the async factory). Tests use it via helper.F.
+const PLUG_URL = "../plugin/longrun.js";
+const SRC_PLUG = await import(PLUG_URL);
+const { F, readRuns, writeRuns } = await import("./helper.mjs");
+const { install } = await import("../src/install.mjs");
+const C = await import("../src/controller.js");
+
+// ---- 1) ARTIFACT-LEVEL LOADER CONTRACT (the real bug: a non-function / non-plugin export made
+// the desktop loader throw "Plugin export is not a function" and skip the whole plugin).
+// Faithful re-implementation of the backend loader: EVERY module export must be a server plugin —
+// a callable function OR a strict `{ id, server }` descriptor whose server is callable — or throw.
+const isServerPlugin = (v) => typeof v === "function" || (v !== null && typeof v === "object" && typeof v.server === "function");
+function loaderCollect(mod) { const seen = new Set(); const out = []; for (const e of Object.values(mod)) { if (seen.has(e)) continue; seen.add(e); if (!isServerPlugin(e)) throw new TypeError("Plugin export is not a function"); out.push(typeof e === "function" ? e : e.server); } return out; }
+
+function assertLoaderInvariant(mod, label) {
+  const keys = Object.keys(mod);
+  assert.deepEqual(keys, ["default"], `${label}: exactly ONE module export (default) — found: ${keys.join(",") || "(none)"}`);
+  assert.equal(typeof mod.default, "object", `${label}: default must be the V1 { id, server } descriptor`);
+  assert.equal(mod.default.id, "longrun", `${label}: descriptor id must be "longrun"`);
+  assert.equal(typeof mod.default.server, "function", `${label}: descriptor server must be callable`);
+  assert.doesNotThrow(() => loaderCollect(mod), `${label}: desktop loader must accept every export`);
+}
+test("LOADER CONTRACT: bad module shapes throw (negative control)", () => {
+  assert.throws(() => loaderCollect({ default: { hooks: {} } }), TypeError, "object export without callable server");
+  assert.throws(() => loaderCollect({ default: { id: "x" } }), TypeError, "descriptor without callable server");
+  assert.throws(() => loaderCollect({ helper: 42 }), TypeError, "non-plugin value");
+});
+test("ARTIFACT invariant: SOURCE plugin exposes exactly one function export", async () => {
+  assertLoaderInvariant(SRC_PLUG, "source");
+});
+test("ARTIFACT invariant: INSTALLER-COPIED plugin passes the same loader contract", async () => {
+  const cfg = fs.mkdtempSync(path.join(os.tmpdir(), "install-"));
+  fs.mkdirSync(path.join(cfg, "plugins"), { recursive: true });
+  const rep = install({ configDir: cfg }); // run the ACTUAL installer -> generates the copied artifact
+  const built = path.join(cfg, "plugins", "longrun.js");
+  assert.ok(fs.existsSync(built), "installer produced plugins/longrun.js");
+  assert.ok(!rep.conflicts.some((c) => c.rel.includes("longrun.js")));
+  const BUILT = await import("file://" + built); // import the GENERATED artifact, not the source
+  assertLoaderInvariant(BUILT, "built/copy");
+  // the baked controller must resolve, and the built factory must build real hooks
+  const hooks = await BUILT.default.server({ client: { app: { log: () => {} } } });
+  assert.ok(hooks.tool && hooks.tool.longrun && hooks.tool.longrun_verify, "built plugin still exposes both tools");
+});
+
+// ---- v1.1.2: evidence discipline — an import is not a load; probes cannot fabricate. ----
+const { spawnSync } = await import("node:child_process");
+const PLUG_FILE = path.resolve(import.meta.dirname, "..", "plugin", "longrun.js").split(path.sep).join("/");
+// Isolated probe children: state dir IS set, and the test context is explicitly disarmed.
+// OPENCODE_CLIENT is stripped too — the harness runs inside a desktop backend whose env would
+// otherwise make any inherited child process look like a host. A genuine probe is NOT a host.
+const CHILD_ENV = (state) => { const e = { ...process.env, LONGRUN_STATE_DIR: state }; delete e.LONGRUN_TEST; delete e.NODE_TEST_CONTEXT; delete e.OPENCODE_CLIENT; return e; }
+test("importing the plugin writes NO live evidence (import != load)", () => {
+  const state = fs.mkdtempSync(path.join(os.tmpdir(), "noev-"));
+  const r = spawnSync(process.execPath, ["--input-type=module", "-e", `await import("file://${PLUG_FILE}");`], { env: CHILD_ENV(state) });
+  assert.equal(r.status, 0, "child import ran: " + r.stderr);
+  assert.deepEqual(fs.readdirSync(state), [], "module import must not create any state");
+});
+test("a plain-node probe calling server() creates no live evidence (isolated state)", () => {
+  const state = fs.mkdtempSync(path.join(os.tmpdir(), "noev2-"));
+  const code = `const m = await import("file://${PLUG_FILE}"); await m.default.server({ client: null });`;
+  const r = spawnSync(process.execPath, ["--input-type=module", "-e", code], { env: CHILD_ENV(state) });
+  assert.equal(r.status, 0, "child factory ran: " + r.stderr);
+  assert.deepEqual(fs.readdirSync(state), [], "probe factory call must write nothing, even with state dir set");
+});
+
+function setupRun({ checkCatalogue, status = "IMPLEMENTING", extra = {} }) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "lrproj-"));
+  fs.writeFileSync(path.join(dir, "a.js"), "x");
+  const id = C.projectIdentity(dir);
+  const key = C.stateKey(id, "default");
+  const store = new C.Store(STATE);
+  const run = {
+    status,
+    originalRequest: "do the thing",
+    contract: { criteria: [{ id: "c1", required: true, checks: ["pass"], status: "FAIL", weight: 1 }], gates: [], lossTarget: 0 },
+    state: {}, budget: C.defaultBudget(),
+  };
+  store.writeJSON(key, "run.json", run);
+  const runs = readRuns();
+  runs["sess-1"] = { runKey: key, directory: dir, checkCatalogue, ...extra };
+  writeRuns(runs);
+  return { dir, key, store };
+}
+const CTX = (dir) => ({ sessionID: "sess-1", agent: "longrun", directory: dir, worktree: dir });
+
+// 6 + 4: verification must come from the declared catalogue; no arbitrary shell bypass.
+test("longrun_verify refuses an undeclared check (no shell bypass)", async () => {
+  const { dir } = setupRun({ checkCatalogue: { pass: { command: ["node", "-e", "process.exit(0)"], kind: "cmd" } } });
+  const tools = (await F(PLUG_URL, { client: null })).tool;
+  const res = JSON.parse(await tools.longrun_verify.execute({ checkId: "rm -rf /" }, CTX(dir)));
+  assert.equal(res.error, "undeclared_check", "arbitrary command rejected");
+});
+
+test("longrun_verify runs a declared check and records PASS", async () => {
+  const { dir } = setupRun({ checkCatalogue: { pass: { command: ["node", "-e", "process.exit(0)"], kind: "cmd" } } });
+  const tools = (await F(PLUG_URL, { client: null })).tool;
+  const res = JSON.parse(await tools.longrun_verify.execute({ checkId: "pass" }, CTX(dir)));
+  assert.equal(res.status, "PASS");
+});
+test("longrun_verify reports FAIL from exit code, not console text", async () => {
+  const { dir } = setupRun({ checkCatalogue: { fail: { command: ["node", "-e", "console.log('ALL PASSED');process.exit(1)"], kind: "cmd" } } });
+  const tools = (await F(PLUG_URL, { client: null })).tool;
+  const res = JSON.parse(await tools.longrun_verify.execute({ checkId: "fail" }, CTX(dir)));
+  assert.equal(res.status, "FAIL", "optimistic text ignored");
+});
+
+// 9: compaction supplements (does not replace) the default prompt with a bounded packet.
+test("compacting hook appends a recovery packet to context", async () => {
+  const { dir } = setupRun({ checkCatalogue: {} });
+  const hooks = await F(PLUG_URL, { client: null });
+  const out = { context: [], prompt: undefined };
+  await hooks["experimental.session.compacting"]({ sessionID: "sess-1" }, out);
+  assert.ok(out.context.some((c) => c.includes("Long-run recovery")), "packet appended");
+  assert.equal(out.prompt, undefined, "default compaction prompt NOT replaced");
+});
+test("compacting hook is a no-op for inactive sessions", async () => {
+  const hooks = await F(PLUG_URL, { client: null });
+  const out = { context: [] };
+  await hooks["experimental.session.compacting"]({ sessionID: "nope" }, out);
+  assert.equal(out.context.length, 0, "inactive -> nothing");
+});
+
+// 8 + 10: paused/cancelled session suppresses synthetic auto-continue.
+test("autocontinue requires an authorized legacy rebind and stays disabled for a paused run", async () => {
+  const { dir } = setupRun({ checkCatalogue: {} });
+  const hooks = await F(PLUG_URL, { client: null });
+  const legacy = { enabled: true };
+  await hooks["experimental.compaction.autocontinue"]({ sessionID: "sess-1" }, legacy);
+  assert.equal(legacy.enabled, false, "a legacy routing flag alone cannot authorize continuation");
+  assert.equal(JSON.parse(await hooks.tool.longrun.execute({ action: "resume" }, CTX(dir))).resumed, true);
+  const a = { enabled: true };
+  await hooks["experimental.compaction.autocontinue"]({ sessionID: "sess-1" }, a);
+  assert.equal(a.enabled, true, "active run keeps default");
+  // now pause it (paused is still recognised, unlike fully-disabled)
+  await hooks.tool.longrun.execute({ action: "pause" }, CTX(dir));
+  const b = { enabled: true };
+  await hooks["experimental.compaction.autocontinue"]({ sessionID: "sess-1" }, b);
+  assert.equal(b.enabled, false, "paused/cancelled suppresses auto-continue");
+  // a fully-inactive session leaves the default untouched
+  const c = { enabled: true };
+  await hooks["experimental.compaction.autocontinue"]({ sessionID: "ghost" }, c);
+  assert.equal(c.enabled, true, "inactive -> no change");
+});
+
+// 9 + 10: session.compacted flips RECOVERY_REQUIRED, not a loop, only inside a run.
+test("session.compacted sets RECOVERY_REQUIRED inside a run", async () => {
+  const { dir, key, store } = setupRun({ checkCatalogue: {} });
+  const hooks = await F(PLUG_URL, { client: null });
+  await hooks.event({ event: { type: "session.compacted", properties: { sessionID: "sess-1" } } });
+  assert.equal(store.readJSON(key, "run.json").status, "RECOVERY_REQUIRED");
+});
+test("session.compacted is a no-op for inactive sessions", async () => {
+  const hooks = await F(PLUG_URL, { client: null });
+  // must not throw and must not touch any state
+  await hooks.event({ event: { type: "session.compacted", properties: { sessionID: "ghost" } } });
+  assert.ok(true);
+});