opencode-longrun-harness 1.2.22

package/harness/test/v122-lifecycle-resolver.test.mjs

@@ -0,0 +1,218 @@
+import { reviewProjectFixture } from "./helper.mjs";
+// v1.2.2 commissioning regression: the canonical run resolver + verify contract + resume rebind +
+// cancel, driven through the REAL plugin tool factory + the REAL controller (LONGRUN_TEST armed so
+// nothing can ever be written into a production state dir; nothing here touches production source,
+// OpenCode config, model/sampler/context, permissions, compaction or continuation).
+//
+// It specifically reproduces the LIVE v1.2.1 failure: status/resume could see an IMPLEMENTING run
+// but longrun_verify returned a generic `no_active_run`. The verifier must now resolve the SAME
+// authoritative run as the control plane, and lifecycle verification must not inflate candidates.
+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 state(d) { process.env.LONGRUN_STATE_DIR = d; return d; }
+function freshState() { return state(fs.mkdtempSync(path.join(os.tmpdir(), "lr122-st-"))); }
+function proj(file = "x") { const d = fs.mkdtempSync(path.join(os.tmpdir(), "lr122-proj-")); fs.writeFileSync(path.join(path.join(d, "a.js")), file); return d; }
+function keyFor(dir, runId) { return C.stateKey(C.projectIdentity(dir), runId); }
+function store() { return new C.Store(process.env.LONGRUN_STATE_DIR); }
+function ctx(sessionID, dir) { return { sessionID, agent: "longrun", directory: dir, worktree: dir }; }
+async function tools() { const h = await F(PLUG_URL, { client: null }); return h.tool; } // fresh factory + state
+
+const STATIC_CAT = { "c1": { command: ["node", "-e", "process.exit(0)"], kind: "cmd", timeoutMs: 15000 } };
+function seededRun(dir, runId, status, extra = {}) {
+  const s = store();
+  const run = C.startRun({
+    request: "commissioning lifecycle",
+    contract: { criteria: [{ id: "LC-001", required: true, weight: 1, checks: ["c1"], evidenceClass: "STATIC", status: "FAIL" }], gates: [], lossTarget: 0 },
+    budgets: { iterations: 3, activeSeconds: 900, deadlineSeconds: 28800, sameFailureLimit: 2, noProgressLimit: 2, autoDispatchCap: 6, toolActionCap: 200 },
+    sourceFingerprint: C.sourceFingerprint(dir).hash,
+    continuation: false, directory: dir, checkCatalogue: STATIC_CAT,
+  }).run;
+  run.runId = runId; run.status = status;
+  s.writeJSON(keyFor(dir, runId), "run.json", run);
+  // register the run on the canonical project identity so a NEW conversation can resolve it
+  const pk = (() => { const id = C.projectIdentity(dir); return C.stateKey(id, "proj-marker").slice(0, 24); })();
+  const projPath = path.join(process.env.LONGRUN_STATE_DIR, "projects.json");
+  let proj = {}; try { proj = JSON.parse(fs.readFileSync(projPath, "utf8")); } catch {}
+  const ck = require_keyOf(id_key(dir));
+  const p = proj[ck] || { runs: [] }; if (!p.runs.includes(keyFor(dir, runId))) p.runs.push(keyFor(dir, runId)); proj[ck] = p;
+  fs.writeFileSync(projPath, JSON.stringify(proj));
+  return { run, key: keyFor(dir, runId) };
+}
+// projectKey used by the plugin: sha256(identity.id) sliced to 24 (mirrors plugin keyOf)
+function id_key(dir) { return C.projectIdentity(dir).id; }
+import crypto from "node:crypto";
+function require_keyOf(v) { return crypto.createHash("sha256").update(String(v)).digest("hex").slice(0, 24); }
+
+// ---- A. same-session flow with an EXPLICIT runId ----
+test("A: start -> status -> verify(explicit runId) -> loss 0 -> complete (same session)", async () => {
+  freshState(); const t = await tools(); const d = proj();
+  const c = ctx("sessA", d);
+  const start = JSON.parse(await t.longrun.execute({ action: "start", request: "r", criteria: [{ id: "LC-001", required: true, evidenceClass: "STATIC", checks: ["c1"] }], checkCatalogue: STATIC_CAT }, c));
+  assert.ok(start.runId, "start returned a runId");
+  const RUN = start.runId;
+  assert.equal(JSON.parse(await t.longrun.execute({ action: "status", runId: RUN }, c)).state, "IMPLEMENTING");
+  const v = JSON.parse(await t.longrun_verify.execute({ checkId: "c1", evidenceClass: "STATIC", runId: RUN }, c));
+  assert.equal(v.status, "PASS", "explicit runId resolves the active run and records a real PASS");
+  assert.equal(v.candidateCount, 0, "lifecycle verify on unchanged source creates NO candidate");
+  const s = JSON.parse(await t.longrun.execute({ action: "status", runId: RUN }, c));
+  assert.deepEqual(s.remaining, [], "criterion satisfied by the receipt");
+  assert.equal(s.candidates.split("/")[0], "0", "candidate count still 0 (never inflated by verify)");
+  reviewProjectFixture(d, RUN);
+  assert.equal(JSON.parse(await t.longrun.execute({ action: "complete", runId: RUN }, c)).complete, true);
+});
+
+// ---- B. pause/resume: verify is RUN_PAUSED while paused, succeeds after resume ----
+test("B: pause -> verify=RUN_PAUSED -> resume -> verify(runId) succeeds -> loss 0 -> complete", async () => {
+  freshState(); const t = await tools(); const d = proj();
+  const c = ctx("sessB", d);
+  const RUN = "lr-paused01";
+  seededRun(d, RUN, "PAUSED");
+  // bound to this session for the auto-resolution path
+  fs.writeFileSync(path.join(process.env.LONGRUN_STATE_DIR, "runs.json"), JSON.stringify({ sessB: { runKey: keyFor(d, RUN), directory: d, checkCatalogue: STATIC_CAT } }));
+  const paused = JSON.parse(await t.longrun_verify.execute({ checkId: "c1", evidenceClass: "STATIC", runId: RUN }, c));
+  assert.equal(paused.error, "RUN_PAUSED", "a paused run is resolvable but not eligible for verification");
+  const rs = JSON.parse(await t.longrun.execute({ action: "resume", runId: RUN }, c));
+  assert.equal(rs.resumed, true); assert.equal(rs.state, "IMPLEMENTING");
+  const v = JSON.parse(await t.longrun_verify.execute({ checkId: "c1", evidenceClass: "STATIC", runId: RUN }, c));
+  assert.equal(v.status, "PASS", "after resume the same run verifies normally");
+  reviewProjectFixture(d, RUN);
+  assert.equal(JSON.parse(await t.longrun.execute({ action: "complete", runId: RUN }, c)).complete, true);
+});
+
+// ---- C. cross-session: session A primes the run; a NEW session (no binding) resumes + verifies ----
+test("C: session A -> new session B resumes by runId + verifies (run/budgets persist)", async () => {
+  freshState();
+  // Session A
+  const tA = await tools(); const d = proj(); const A = ctx("sessA", d);
+  const start = JSON.parse(await tA.longrun.execute({ action: "start", request: "r", criteria: [{ id: "LC-001", required: true, evidenceClass: "STATIC", checks: ["c1"] }], checkCatalogue: STATIC_CAT }, A));
+  const RUN = start.runId;
+  await tA.longrun.execute({ action: "checkpoint", runId: RUN }, A);
+  assert.equal(await tA.longrun.execute({ action: "pause", runId: RUN }, A), "paused");
+  // Session B: brand-new sessionID, same project/worktree, NO session binding seeded
+  const tB = await tools(); const B = ctx("sessB-brand-new", d);
+  const sBefore = JSON.parse(await tB.longrun.execute({ action: "status", runId: RUN }, B));
+  assert.equal(sBefore.state, "PAUSED", "a new conversation re-attaches to the same run via project identity");
+  assert.equal(sBefore.runId, RUN, "same run ID across the session boundary");
+  const rs = JSON.parse(await tB.longrun.execute({ action: "resume", runId: RUN }, B));
+  assert.equal(rs.rebound, true, "resume re-binds the current session + worktree");
+  const v = JSON.parse(await tB.longrun_verify.execute({ checkId: "c1", evidenceClass: "STATIC", runId: RUN }, B));
+  assert.equal(v.status, "PASS", "the new conversation can verify the same authoritative run");
+  const sDone = JSON.parse(await tB.longrun.execute({ action: "status", runId: RUN }, B));
+  assert.equal(sDone.candidates.split("/")[0], "0", "candidate count unchanged across the boundary");
+  reviewProjectFixture(d, RUN);
+  assert.equal(JSON.parse(await tB.longrun.execute({ action: "complete", runId: RUN }, B)).complete, true);
+});
+
+// ---- D. explicit-ID isolation: verify(runId=A) verifies ONLY A; no cross-project contamination ----
+test("D: explicit runId verifies only the named run; a foreign-project runId is NO_RUN", async () => {
+  freshState(); const t = await tools();
+  const p1 = proj(), p2 = proj();
+  const A = "lr-runA", B = "lr-runB";
+  seededRun(p1, A, "IMPLEMENTING");
+  seededRun(p2, B, "IMPLEMENTING");
+  // from project P2, runId A is NOT resolvable here -> NO_RUN (never cross-project)
+  const foreign = JSON.parse(await t.longrun_verify.execute({ checkId: "c1", evidenceClass: "STATIC", runId: A }, ctx("s", p2)));
+  assert.equal(foreign.error, "NO_RUN", "an explicit id outside this project does NOT resolve here");
+  // verify B only; A's record must be byte-unchanged (no cross-run contamination)
+  const beforeA = JSON.stringify(store().readJSON(keyFor(p1, A), "run.json"));
+  const vB = JSON.parse(await t.longrun_verify.execute({ checkId: "c1", evidenceClass: "STATIC", runId: B }, ctx("s", p2)));
+  assert.equal(vB.status, "PASS", "the named run verifies");
+  assert.equal(vB.runId, B);
+  assert.equal(JSON.stringify(store().readJSON(keyFor(p1, A), "run.json")), beforeA, "run A was not touched");
+});
+
+// ---- E. ambiguity: no runId + multiple eligible runs -> AMBIGUOUS_RUN, never a guess ----
+test("E: omitted runId with multiple eligible runs returns AMBIGUOUS_RUN; explicit id resolves one", async () => {
+  freshState(); const t = await tools(); const d = proj();
+  const A = "lr-dup1", B = "lr-dup2";
+  seededRun(d, A, "IMPLEMENTING");
+  seededRun(d, B, "IMPLEMENTING");
+  const amb = JSON.parse(await t.longrun_verify.execute({ checkId: "c1", evidenceClass: "STATIC" }, ctx("s", d)));
+  assert.equal(amb.error, "AMBIGUOUS_RUN", "never guesses between multiple runs");
+  assert.deepEqual(amb.ids.sort(), [A, B].sort());
+  const one = JSON.parse(await t.longrun_verify.execute({ checkId: "c1", evidenceClass: "STATIC", runId: A }, ctx("s", d)));
+  assert.equal(one.status, "PASS", "explicit runId disambiguates and verifies exactly one");
+});
+
+// ---- F. cancel lifecycle: terminal CANCELLED, verify rejected, continuation impossible, new start allowed + different id ----
+test("F: start -> pause -> cancel -> status CANCELLED -> verify rejected -> new start gets a different id", async () => {
+  freshState(); const t = await tools(); const d = proj(); const c = ctx("sessF", d);
+  const start = JSON.parse(await t.longrun.execute({ action: "start", request: "r", criteria: [{ id: "LC-001", required: true, evidenceClass: "STATIC", checks: ["c1"] }], checkCatalogue: STATIC_CAT }, c));
+  const RUN = start.runId;
+  assert.equal(await t.longrun.execute({ action: "pause", runId: RUN }, c), "paused");
+  const cancel = JSON.parse(await t.longrun.execute({ action: "cancel", runId: RUN, reason: "abandoned" }, c));
+  assert.equal(cancel.cancelled, true); assert.equal(cancel.state, "CANCELLED");
+  const st = JSON.parse(await t.longrun.execute({ action: "status", runId: RUN }, c));
+  assert.equal(st.state, "CANCELLED", "status reports the terminal CANCELLED state (not deleted, not COMPLETE)");
+  const v = JSON.parse(await t.longrun_verify.execute({ checkId: "c1", evidenceClass: "STATIC", runId: RUN }, c));
+  assert.equal(v.error, "RUN_CANCELLED", "a cancelled run rejects further verification");
+  // continuation impossible: autocontinue hook suppresses on a cancelled/disabled run
+  const hooks = await F(PLUG_URL, { client: {} });
+  const out = { enabled: true };
+  await hooks["experimental.compaction.autocontinue"]({ sessionID: "sessF" }, out);
+  assert.equal(out.enabled, false, "a cancelled run cannot be auto-revived");
+  // a NEW run is allowed for the same project and receives a DIFFERENT run id
+  const again = JSON.parse(await t.longrun.execute({ action: "start", request: "r2", criteria: [{ id: "LC-002", required: true, evidenceClass: "STATIC", checks: ["c2"] }], checkCatalogue: { c2: STATIC_CAT.c1 } }, c));
+  assert.ok(again.runId, "a cancelled (terminal) run does not block a new run");
+  assert.notEqual(again.runId, RUN, "the new run has a different run id");
+});
+
+// ---- G. restart persistence: serialize, then FRESH controller/tool instances resolve + verify ----
+test("G: fresh controller/tool instances resolve the run from disk (no in-memory-only run state)", async () => {
+  freshState();
+  const d = proj(); const RUN = "lr-restart01";
+  // "before restart": one factory records a PASS against a CHANGED-source candidate? No — keep 0
+  // candidates; instead just prove the fresh instance resolves + verifies + completes.
+  seededRun(d, RUN, "IMPLEMENTING");
+  // "restart": a brand-new controller module + fresh tool factory, same serialized state dir.
+  const CTRL2 = await import("../src/controller.js?r=" + Math.random());
+  const plug2 = await import("../plugin/longrun.js?r=" + Math.random());
+  const hooks = await plug2.default.server({ client: { app: { log: () => {} } } });
+  const t = hooks.tool;
+  const s0 = JSON.parse(await t.longrun.execute({ action: "status", runId: RUN }, ctx("sessG", d)));
+  assert.equal(s0.state, "IMPLEMENTING", "a fresh controller resolves the same authoritative run from disk");
+  assert.equal(s0.candidates, "0/3", "candidate ledger persisted (not reset by a new process)");
+  const v = JSON.parse(await t.longrun_verify.execute({ checkId: "c1", evidenceClass: "STATIC", runId: RUN }, ctx("sessG", d)));
+  assert.equal(v.status, "PASS");
+  reviewProjectFixture(d, RUN);
+  assert.equal(CTRL2.canComplete(store().readJSON(keyFor(d, RUN), "run.json")).complete, true, "loss reached 0 and completion is now allowed");
+  assert.equal(JSON.parse(await t.longrun.execute({ action: "complete", runId: RUN }, ctx("sessG", d))).complete, true);
+});
+
+// ---- the deterministic COMMISSIONING fixture: the full lifecycle end to end, real factory+controller ----
+test("COMMISSIONING: memory -> start -> status -> checkpoint -> pause -> new session -> resume -> verify(runId) -> loss0 -> complete -> new run -> cancel", async () => {
+  freshState();
+  const d = proj();
+  // session A
+  const tA = await tools(); const A = ctx("cs-A", d);
+  assert.equal(JSON.parse(await tA.longrun.execute({ action: "memory_status" }, A)).status, "NO_MEMORY");
+  const start = JSON.parse(await tA.longrun.execute({ action: "start", request: "Verify the v1.2.2 lifecycle", criteria: [{ id: "LC-001", required: true, evidenceClass: "STATIC", checks: ["c1"] }], checkCatalogue: STATIC_CAT }, A));
+  const RUN = start.runId; assert.ok(RUN, "non-null runId");
+  assert.equal(JSON.parse(await tA.longrun.execute({ action: "status", runId: RUN }, A)).state, "IMPLEMENTING");
+  await tA.longrun.execute({ action: "checkpoint", runId: RUN }, A);
+  assert.equal(await tA.longrun.execute({ action: "pause", runId: RUN }, A), "paused");
+  // session B (new conversation / restart-equivalent)
+  const tB = await tools(); const B = ctx("cs-B", d);
+  assert.equal(JSON.parse(await tB.longrun.execute({ action: "status", runId: RUN }, B)).state, "PAUSED");
+  assert.equal(JSON.parse(await tB.longrun.execute({ action: "resume", runId: RUN }, B)).state, "IMPLEMENTING");
+  const v = JSON.parse(await tB.longrun_verify.execute({ checkId: "c1", evidenceClass: "STATIC", runId: RUN }, B));
+  assert.equal(v.status, "PASS"); assert.equal(v.candidateCount, 0, "lifecycle-only: 0 candidates");
+  assert.equal(JSON.parse(await tB.longrun.execute({ action: "status", runId: RUN }, B)).remaining.length, 0);
+  reviewProjectFixture(d, RUN);
+  assert.equal(JSON.parse(await tB.longrun.execute({ action: "complete", runId: RUN }, B)).complete, true);
+  assert.equal(JSON.parse(await tB.longrun.execute({ action: "status", runId: RUN }, B)).state, "COMPLETE");
+  // second run + cancel
+  const start2 = JSON.parse(await tB.longrun.execute({ action: "start", request: "second", criteria: [{ id: "LC-002", required: true, evidenceClass: "STATIC", checks: ["c1"] }], checkCatalogue: STATIC_CAT }, B));
+  assert.ok(start2.runId && start2.runId !== RUN, "a second run starts after the first completed");
+  assert.equal(JSON.parse(await tB.longrun.execute({ action: "cancel", runId: start2.runId }, B)).cancelled, true);
+  assert.equal(JSON.parse(await tB.longrun_verify.execute({ checkId: "c1", evidenceClass: "STATIC", runId: start2.runId }, B)).error, "RUN_CANCELLED");
+});

package/harness/test/v1220-budget-amendment.test.mjs

@@ -0,0 +1,343 @@
+// v1.2.20 — audited operator-only budget amendment (finite candidate allowance + new absolute
+// deadline). Reproduced BEFORE implementation: every test below uses the amendment API that did
+// not exist yet, so the pre-change run failed rather than silently passing.
+//
+// Trust boundary: the amendment is reachable ONLY through the installed maintenance CLI, never
+// through the native model tool surface (RUN_ACTIONS/ACTION_PARAMS). Like the completion review it
+// is an auditable workflow boundary, not an OS sandbox against arbitrary state-file access.
+//
+// These are offline deterministic tests. They are NOT native OpenCode host evidence and they never
+// touch production source, config, model routing, permissions or the protected run.
+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 * as C from '../src/controller.js';
+import { install, VERSION } from '../src/install.mjs';
+import { approveStoredFixtureReview, F } from './helper.mjs';
+process.env.LONGRUN_CONTROLLER_FILE = path.resolve(import.meta.dirname, '../src/controller.js');
+
+// The grant that was actually applied to the annotations run used the absolute deadline below. It is
+// kept here for the historical record, but the tests must not depend on wall-clock time: a fixture
+// run's own deadline is computed from the moment it is created, so once real time passed the real
+// grant's deadline the amendment correctly reported AMENDMENT_DEADLINE_NOT_EXTENDING and these tests
+// failed for a reason that had nothing to do with the code under test. The deadline exercised below
+// is therefore a fixed date far in the future, so "a grant extends the deadline and becomes the
+// effective one" stays deterministic whenever the suite runs. Every assertion is unchanged.
+const GRANT_DEADLINE_AS_APPLIED = Date.parse('2026-09-22T23:30:00.000Z'); // historical, not used for timing
+const TEST_GRANT_DEADLINE = Date.parse('2099-01-01T00:00:00.000Z');
+
+const GRANT = {
+  amendmentId: 'grant-example-20260921-01',
+  additionalCandidates: 12,
+  newDeadlineAt: TEST_GRANT_DEADLINE,
+  authorization: 'User authorized 12 additional candidates (cumulative 36) and a new absolute deadline for the same paused annotations run.',
+  reason: 'The original 24-candidate allowance was exhausted and its original deadline had already expired; the remaining reviewed full scope needs a finite, audited extension.',
+};
+const ORIGINAL_DEADLINE = Date.parse('2026-09-21T03:59:32.883Z');
+
+async function fixture(t, budget = {}) {
+  const base = fs.mkdtempSync(path.join(os.tmpdir(), 'lr1220-'));
+  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'), 'baseline');
+  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: 'amendment-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 operator-amendment regression', criteria: [{ id: 'c', checks: ['check'] }], checkCatalogue: { check: { command, kind: 'cmd', gate: true } }, ...budget }, 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));
+  const amend = (args) => C.operatorBudgetAmendment(store, key, { directory: dir, runId: start.runId, ...args });
+  const bytes = () => fs.readFileSync(store._file(key, 'run.json'));
+  return { base, dir, hooks, ctx, start, store, key, read, verify, amend, bytes };
+}
+const basisOf = run => C.completionReviewBasis(run, run.sourceFingerprint);
+const grantArgs = run => ({ ...GRANT, expectedRevision: run.controlGeneration || 0, expectedBasis: basisOf(run) });
+
+// Drive a run to the real v1.2.19 stop: one counted candidate, then a NEW source refused at the cap.
+async function exhaust(t) {
+  const s = await fixture(t, { candidateBudget: 1 });
+  fs.writeFileSync(path.join(s.dir, 'value.txt'), 'valid-one');
+  assert.equal((await s.verify()).status, 'PASS');
+  fs.writeFileSync(path.join(s.dir, 'value.txt'), 'valid-two');
+  const refused = await s.verify();
+  assert.equal(refused.error, 'BUDGET_EXHAUSTED');
+  assert.equal(refused.spent.candidates, true);
+  assert.equal(s.read().status, 'PAUSED');
+  return s;
+}
+
+test('pre-amendment: cap and expired deadline refuse, and the native model tool surface cannot amend', async t => {
+  const s = await exhaust(t);
+  assert.ok(!C.RUN_ACTIONS.includes('amend'), 'no native amend action exists');
+  assert.ok(!Object.keys(C.ACTION_PARAMS).some(a => /amend|allowance|grant/i.test(a)), 'no native amendment parameters');
+  const native = JSON.parse(await s.hooks.tool.longrun.execute({ action: 'amend', runId: s.start.runId }, s.ctx));
+  assert.equal(native.error, 'unknown_action');
+
+  const d = await fixture(t);
+  const run = d.read();
+  run.createdAt = ORIGINAL_DEADLINE - run.budget.deadlineSeconds * 1000; // deadline already passed
+  d.store.writeJSON(d.key, 'run.json', run);
+  const expired = await d.verify();
+  assert.equal(expired.error, 'BUDGET_EXHAUSTED');
+  assert.equal(expired.spent.deadline, true);
+});
+
+test('operator amendment preserves original budget and history and exposes original vs effective limits', async t => {
+  const s = await exhaust(t);
+  const before = s.read();
+  const frozen = { budget: JSON.parse(JSON.stringify(before.budget)), receipts: before.receipts.length,
+    candidateCount: C.candidateCount(before), createdAt: before.createdAt, contractHash: before.contractHash,
+    verificationMs: before.execution?.verificationMs };
+
+  const result = await s.amend(grantArgs(before));
+  assert.equal(result.ok, true, JSON.stringify(result));
+  assert.equal(result.state, 'PAUSED', 'a grant never resumes a run');
+  assert.ok(!result.alreadyApplied);
+
+  const after = s.read();
+  assert.deepEqual(after.budget, frozen.budget, 'original budget fields are untouched');
+  assert.equal(after.receipts.length, frozen.receipts, 'receipt history retained');
+  assert.equal(C.candidateCount(after), frozen.candidateCount, 'usage counters never reset');
+  assert.equal(after.createdAt, frozen.createdAt, 'creation timestamp never rewritten');
+  assert.equal(after.contractHash, frozen.contractHash, 'contract untouched');
+  assert.equal(after.execution?.verificationMs, frozen.verificationMs, 'measured usage untouched');
+  assert.equal(after.status, 'PAUSED'); assert.equal(after.autoEnabled, false);
+  assert.equal(after.controlGeneration, (before.controlGeneration || 0) + 1, 'audited mutation advances generation');
+
+  assert.equal(after.budgetAmendments.length, 1);
+  const rec = after.budgetAmendments[0];
+  assert.equal(rec.schemaVersion, C.AMENDMENT_SCHEMA_VERSION);
+  assert.equal(rec.id, GRANT.amendmentId); assert.equal(rec.source, 'operator_cli');
+  assert.equal(rec.additionalCandidates, 12); assert.equal(rec.newDeadlineAt, GRANT.newDeadlineAt);
+  assert.equal(rec.authorization, GRANT.authorization.trim(), 'authorization recorded verbatim');
+  assert.equal(rec.reason, GRANT.reason.trim());
+  assert.equal(rec.originalDeadlineAt, after.createdAt + after.budget.deadlineSeconds * 1000);
+  assert.equal(rec.previousEffectiveCandidates, 1);
+  assert.match(rec.priorRunHash, /^[a-f0-9]{64}$/);
+
+  const view = C.deriveRunView(after, { currentFingerprint: after.sourceFingerprint });
+  assert.equal(view.candidates, `${frozen.candidateCount}/13`, 'effective candidate limit shown');
+  assert.equal(view.budgetLimit.original.iterations, 1, 'original limit reported separately');
+  assert.equal(view.budgetLimit.additionalCandidates, 12);
+  assert.equal(view.budgetLimit.effective.iterations, 13);
+  assert.equal(view.controlRevision, after.controlGeneration);
+  assert.match(view.amendmentBasis, /^[a-f0-9]{64}$/);
+
+  const timing = C.execution.timing(after);
+  assert.equal(timing.deadlineAt, GRANT.newDeadlineAt, 'effective deadline is the granted one');
+  assert.equal(timing.originalDeadlineAt, rec.originalDeadlineAt, 'original deadline still reported');
+  const guard = C.execution.budgetGuard(after, { fingerprint: 'brand-new-source-fingerprint' });
+  assert.equal(guard.ok, true, JSON.stringify(guard.spent));
+  assert.equal(guard.spent.candidates, false); assert.equal(guard.spent.deadline, false);
+});
+
+test('after a grant a new source candidate is admitted and ordinary tool admission is restored', async t => {
+  const s = await exhaust(t);
+  assert.equal((await s.amend(grantArgs(s.read()))).ok, true);
+  const resumed = JSON.parse(await s.hooks.tool.longrun.execute({ action: 'resume', runId: s.start.runId }, s.ctx));
+  assert.equal(resumed.state, 'IMPLEMENTING', JSON.stringify(resumed));
+  await s.hooks['tool.execute.before']({ tool: 'bash', sessionID: s.ctx.sessionID }, { args: {} });
+  const verified = await s.verify();
+  assert.equal(verified.status, 'PASS', JSON.stringify(verified));
+  const after = s.read();
+  assert.equal(C.candidateCount(after), 2, 'the newly admitted source counts as a candidate');
+  assert.equal(after.budget.iterations, 1, 'the original declared limit is still 1');
+});
+
+test('amendment refuses invalid, stale, conflicting, non-paused and in-flight requests without mutation', async t => {
+  const s = await fixture(t, { candidateBudget: 5 });
+  s.store.mutate(s.key, C.pauseRun);
+  const paused = s.read();
+  const good = grantArgs(paused);
+  const cases = [
+    [{ ...good, expectedBasis: 'f'.repeat(64) }, 'AMENDMENT_BASIS_CHANGED'],
+    [{ ...good, expectedRevision: (paused.controlGeneration || 0) + 7 }, 'AMENDMENT_REVISION_CHANGED'],
+    [{ ...good, amendmentId: 'short' }, 'INVALID_AMENDMENT'],
+    [{ ...good, additionalCandidates: 0 }, 'INVALID_AMENDMENT'],
+    [{ ...good, additionalCandidates: 1.5 }, 'INVALID_AMENDMENT'],
+    [{ ...good, additionalCandidates: 1e6 }, 'INVALID_AMENDMENT'],
+    [{ ...good, newDeadlineAt: Date.now() - 1000 }, 'AMENDMENT_DEADLINE_NOT_FUTURE'],
+    [{ ...good, newDeadlineAt: paused.createdAt + paused.budget.deadlineSeconds * 1000 - 1000 }, 'AMENDMENT_DEADLINE_NOT_EXTENDING'],
+    [{ ...good, authorization: '   ' }, 'INVALID_AMENDMENT'],
+    [{ ...good, reason: '' }, 'INVALID_AMENDMENT'],
+  ];
+  for (const [args, expected] of cases) {
+    const before = s.bytes();
+    const result = await s.amend(args);
+    assert.equal(result.error, expected, JSON.stringify({ args, result }));
+    assert.deepEqual(s.bytes(), before, `refusal ${expected} must not mutate canonical state`);
+  }
+  for (const [mutate, expected] of [
+    [run => { run.status = 'IMPLEMENTING'; }, 'AMENDMENT_REQUIRES_PAUSE'],
+    [run => { run.status = 'COMPLETE'; }, 'RUN_COMPLETE'],
+    [run => { run.status = 'CANCELLED'; }, 'RUN_CANCELLED'],
+    [run => { run.status = 'PAUSED'; run.execution.inFlight = { ownerPid: process.pid, token: 'live' }; }, 'VERIFY_IN_FLIGHT'],
+  ]) {
+    const run = s.read(); mutate(run); s.store.writeJSON(s.key, 'run.json', run);
+    const before = s.bytes();
+    assert.equal((await s.amend(grantArgs(s.read()))).error, expected);
+    assert.deepEqual(s.bytes(), before, `refusal ${expected} must not mutate canonical state`);
+  }
+  const run = s.read(); run.status = 'PAUSED'; run.execution.inFlight = null; s.store.writeJSON(s.key, 'run.json', run);
+  const before = s.bytes();
+  const mismatch = await C.operatorBudgetAmendment(s.store, s.key, { directory: s.dir, runId: 'someone-else', ...grantArgs(s.read()) });
+  assert.equal(mismatch.error, 'AMENDMENT_RUN_MISMATCH');
+  assert.deepEqual(s.bytes(), before);
+});
+
+test('an exact repeat is idempotent, a conflicting repeat is refused, and a stale grant cannot be applied', async t => {
+  const s = await exhaust(t);
+  const first = s.read();
+  const staleBasis = basisOf(first), staleRevision = first.controlGeneration || 0;
+  assert.equal((await s.amend({ ...GRANT, expectedRevision: staleRevision, expectedBasis: staleBasis })).ok, true);
+  const afterFirst = s.read();
+  assert.equal(afterFirst.budgetAmendments.length, 1);
+
+  const repeat = await s.amend({ ...GRANT, expectedRevision: staleRevision, expectedBasis: staleBasis });
+  assert.equal(repeat.ok, true); assert.equal(repeat.alreadyApplied, true);
+  assert.equal(s.read().budgetAmendments.length, 1, 'an exact repeat does not double-count');
+  assert.equal(C.execution.effectiveIterations(s.read()), 13);
+
+  const conflict = await s.amend({ ...GRANT, additionalCandidates: 99, expectedRevision: staleRevision, expectedBasis: staleBasis });
+  assert.equal(conflict.error, 'AMENDMENT_ID_CONFLICT');
+  assert.equal(s.read().budgetAmendments.length, 1);
+
+  const stale = await s.amend({ ...GRANT, amendmentId: 'grant-second-stale-0001', additionalCandidates: 4, expectedRevision: staleRevision, expectedBasis: staleBasis });
+  assert.equal(stale.error, 'AMENDMENT_BASIS_CHANGED', 'a grant bound to a superseded state is refused');
+
+  const current = s.read();
+  const second = await s.amend({ ...GRANT, amendmentId: 'grant-example-20260921-02', additionalCandidates: 4, newDeadlineAt: GRANT.newDeadlineAt + 3600000, expectedRevision: current.controlGeneration || 0, expectedBasis: basisOf(current) });
+  assert.equal(second.ok, true, JSON.stringify(second));
+  const after = s.read();
+  assert.equal(after.budgetAmendments.length, 2);
+  assert.equal(C.execution.effectiveIterations(after), 1 + 12 + 4, 'finite allowances accumulate');
+  assert.equal(C.execution.timing(after).deadlineAt, GRANT.newDeadlineAt + 3600000);
+});
+
+test('a grant invalidates a prior completion acceptance and never resumes or self-approves', async t => {
+  const s = await fixture(t, { candidateBudget: 5 });
+  fs.writeFileSync(path.join(s.dir, 'value.txt'), 'valid-one');
+  assert.equal((await s.verify()).status, 'PASS');
+  s.store.mutate(s.key, C.pauseRun);
+  approveStoredFixtureReview(s.store, s.key);
+  const accepted = s.read();
+  const fp = accepted.sourceFingerprint;
+  assert.equal(C.completionReviewStatus(accepted, fp).status, 'ACCEPTED');
+  assert.equal(C.canComplete(accepted, { currentFingerprint: fp }).complete, true);
+
+  const result = await s.amend(grantArgs(accepted));
+  assert.equal(result.ok, true, JSON.stringify(result));
+  const after = s.read();
+  assert.equal(after.status, 'PAUSED', 'the grant itself never resumes');
+  assert.equal(after.autoEnabled, false);
+  assert.equal(C.completionReviewStatus(after, fp).status, 'STALE', 'prior acceptance is invalidated by the budget change');
+  const completion = C.canComplete(after, { currentFingerprint: fp });
+  assert.equal(completion.complete, false);
+  assert.equal(completion.reason, 'completion_review_stale');
+});
+
+test('the real exhausted annotations run gains exactly a finite allowance without rewriting history', async t => {
+  const base = fs.mkdtempSync(path.join(os.tmpdir(), 'lr1220-copy-'));
+  t.after(() => fs.rmSync(base, { recursive: true, force: true }));
+  const dir = path.join(base, 'project'); fs.mkdirSync(dir);
+  const state = path.join(base, 'state');
+  const run = JSON.parse(fs.readFileSync(new URL('./fixtures/notes-budget-exhausted-run.json', import.meta.url)));
+  const runId = run.runId;
+  run.status = 'PAUSED'; run.autoEnabled = false; run.controlGeneration = (run.controlGeneration || 0) + 1;
+  run.directory = dir;
+  const store = new C.Store(state), key = C.stateKey(C.projectIdentity(dir), runId);
+  store.writeJSON(key, 'run.json', run);
+  const before = store.readRun(key).run;
+  assert.equal(C.candidateCount(before), 24);
+  assert.equal(before.receipts.length, 37);
+  assert.equal(before.budget.iterations, 24);
+
+  const result = await C.operatorBudgetAmendment(store, key, { directory: dir, runId,
+    amendmentId: 'grant-example-real-0001', additionalCandidates: 12,
+    newDeadlineAt: TEST_GRANT_DEADLINE,
+    authorization: GRANT.authorization, reason: GRANT.reason,
+    expectedRevision: before.controlGeneration || 0, expectedBasis: basisOf(before) });
+  assert.equal(result.ok, true, JSON.stringify(result));
+
+  const after = store.readRun(key).run;
+  assert.deepEqual(after.budget, before.budget, 'original 24/7200/140 limit preserved');
+  assert.equal(C.candidateCount(after), 24, '24 used candidates preserved');
+  assert.equal(after.receipts.length, 37, '37 receipts preserved');
+  assert.equal(after.execution.verificationMs, before.execution.verificationMs);
+  assert.equal(after.createdAt, before.createdAt);
+  assert.equal(after.contractHash, before.contractHash);
+  assert.equal(C.execution.effectiveIterations(after), 36, 'cumulative effective limit is 36');
+  assert.equal(C.execution.timing(after).deadlineAt, TEST_GRANT_DEADLINE);
+  assert.equal(C.execution.budgetGuard(after, { fingerprint: 'post-grant-unverified-source' }).ok, true);
+
+  const view = C.deriveRunView(after, { currentFingerprint: 'post-grant-unverified-source' });
+  assert.equal(view.historicalReceiptCount, 37);
+  assert.equal(view.candidates, '24/36');
+  assert.equal(view.checks.length, 6, 'all six declared checks still reported');
+  assert.equal(view.checks.every(c => c.effectiveStatus === 'STALE'), true, 'no historical PASS is promoted to current');
+});
+
+test('the installed operator CLI is the only amendment path and requires the read-only basis and revision', t => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'lr1220-cli-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  const project = path.join(root, 'project'), config = path.join(root, 'config'), state = path.join(root, 'state');
+  fs.mkdirSync(project); fs.writeFileSync(path.join(project, 'value.txt'), 'fixture');
+  install({ configDir: config });
+  const store = new C.Store(state), runId = 'amendment-cli-fixture', key = C.stateKey(C.projectIdentity(project), runId);
+  const run = { runId, directory: project, status: 'PAUSED', autoEnabled: false, controlGeneration: 2,
+    createdAt: Date.now() - 3600 * 1000, sourceFingerprint: C.sourceFingerprint(project),
+    budget: { iterations: 2, activeSeconds: 3600, deadlineSeconds: 60, sameFailureLimit: 3, noProgressLimit: 5, autoDispatchCap: 40, toolActionCap: 140 },
+    contract: { criteria: [{ id: 'c', required: true, checks: ['check'] }], gates: [{ id: 'check', required: true }], lossTarget: 0 },
+    contractHash: 'retained-mapping', checkCatalogue: { check: { command: ['true'], kind: 'cmd', gate: true } },
+    state: { candidates: [], lastEvalFingerprint: null }, receipts: [],
+    execution: { commandAttempts: 0, verificationMs: 0, inFlight: null } };
+  store.writeJSON(key, 'run.json', run);
+  const bin = path.join(config, 'longrun-harness', 'releases', VERSION, 'bin', 'longrun.mjs');
+  const invoke = (args, extra = {}) => {
+    const result = spawnSync(process.execPath, [bin, ...args], {
+      cwd: root, env: { ...process.env, LONGRUN_TEST: '1', LONGRUN_STATE_DIR: state, OPENCODE_CONFIG_DIR: config },
+      encoding: 'utf8', timeout: 10000, ...extra });
+    assert.equal(result.error, undefined);
+    return { exit: result.status, output: JSON.parse(result.stdout) };
+  };
+  const status = invoke(['status', '--json', '--project', project, '--run', runId]);
+  assert.equal(status.exit, 0, JSON.stringify(status.output));
+  assert.match(status.output.amendmentBasis, /^[a-f0-9]{64}$/);
+  assert.equal(status.output.controlRevision, 2);
+  assert.equal(status.output.budgetLimit.effective.iterations, 2);
+
+  const authFile = path.join(root, 'authorization.txt'), reasonFile = path.join(root, 'reason.txt');
+  fs.writeFileSync(authFile, GRANT.authorization); fs.writeFileSync(reasonFile, GRANT.reason);
+  const amendArgs = ['amend', '--json', '--project', project, '--run', runId,
+    '--amendment-id', 'grant-cli-fixture-0001', '--additional-candidates', '12',
+    '--new-deadline', new Date(TEST_GRANT_DEADLINE).toISOString(),
+    '--authorization-file', authFile, '--reason-file', reasonFile,
+    '--expected-basis', status.output.amendmentBasis, '--expected-revision', String(status.output.controlRevision)];
+
+  const missing = invoke(['amend', '--json', '--project', project, '--run', runId]);
+  assert.equal(missing.exit, 2); assert.equal(missing.output.error, 'AMENDMENT_ARGUMENTS_REQUIRED');
+
+  const before = fs.readFileSync(store._file(key, 'run.json'));
+  const stale = invoke(['amend', '--json', '--project', project, '--run', runId,
+    '--amendment-id', 'grant-cli-fixture-stale', '--additional-candidates', '12',
+    '--new-deadline', new Date(TEST_GRANT_DEADLINE).toISOString(),
+    '--authorization-file', authFile, '--reason-file', reasonFile,
+    '--expected-basis', 'f'.repeat(64), '--expected-revision', '2']);
+  assert.equal(stale.exit, 2); assert.equal(stale.output.error, 'AMENDMENT_BASIS_CHANGED');
+  assert.deepEqual(fs.readFileSync(store._file(key, 'run.json')), before);
+
+  const applied = invoke(amendArgs);
+  assert.equal(applied.exit, 0, JSON.stringify(applied.output));
+  assert.equal(applied.output.state, 'PAUSED');
+  const after = store.readRun(key).run;
+  assert.deepEqual(after.budget, run.budget);
+  assert.equal(after.budgetAmendments.length, 1);
+  assert.equal(C.execution.effectiveIterations(after), 14);
+  assert.equal(after.status, 'PAUSED');
+  assert.equal(after.controlGeneration, 3);
+});

package/harness/test/v1221-negative-fixture-anchor.test.mjs

@@ -0,0 +1,65 @@
+// v1.2.21 — negative-fixture isolation must not be defeated by a filesystem-root anchor.
+//
+// Reproduced BEFORE the fix: a real OpenCode CLI host supplied context.worktree="/" so the plugin
+// passed "/" among the project directories, and validateNegativeFixture rejected EVERY fixture
+// (including one under /private/tmp) as "fixture and production project overlap". The original
+// negative-control tests only ever passed the project as both directory and worktree, so this path
+// was never exercised. These are offline deterministic tests, not native host evidence.
+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';
+
+function mk(t, prefix) {
+  const d = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  t.after(() => fs.rmSync(d, { recursive: true, force: true }));
+  return d;
+}
+
+test('a filesystem-root anchor does not make every fixture overlap', t => {
+  const base = mk(t, 'lr1221-');
+  const project = path.join(base, 'project'); fs.mkdirSync(project); fs.writeFileSync(path.join(project, 'a.mjs'), 'x');
+  const fixture = path.join(base, 'fixture'); fs.mkdirSync(fixture); fs.writeFileSync(path.join(fixture, 'a.mjs'), 'x');
+  const fsRoot = path.parse(process.cwd()).root;
+  const result = C.validateNegativeFixture(fixture, [project, fsRoot]);
+  assert.equal(result.ok, true, JSON.stringify(result));
+  assert.equal(result.fixture, fs.realpathSync(fixture));
+});
+
+test('a fixture inside the project is still refused, and the refusal names the offending directory', t => {
+  const base = mk(t, 'lr1221-');
+  const project = path.join(base, 'project'); fs.mkdirSync(project); fs.writeFileSync(path.join(project, 'a.mjs'), 'x');
+  const inside = path.join(project, 'fixture'); fs.mkdirSync(inside);
+  const result = C.validateNegativeFixture(inside, [project]);
+  assert.equal(result.ok, false);
+  assert.equal(result.error, 'FIXTURE_NOT_ISOLATED');
+  assert.match(result.detail, /overlap/);
+  assert.ok(result.detail.includes(fs.realpathSync(project)), 'detail names the overlapping project directory');
+});
+
+test('a project directory nested inside the fixture is still refused', t => {
+  const base = mk(t, 'lr1221-');
+  const fixture = path.join(base, 'fixture'); fs.mkdirSync(fixture);
+  const nested = path.join(fixture, 'project'); fs.mkdirSync(nested);
+  const result = C.validateNegativeFixture(fixture, [nested]);
+  assert.equal(result.ok, false);
+  assert.match(result.detail, /overlap/);
+});
+
+test('an escaping symlink and a shared hard link are still refused', t => {
+  const base = mk(t, 'lr1221-');
+  const symlinked = path.join(base, 'symlinked'); fs.mkdirSync(symlinked);
+  fs.symlinkSync(fs.realpathSync(os.tmpdir()), path.join(symlinked, 'escape'));
+  const escaped = C.validateNegativeFixture(symlinked, []);
+  assert.equal(escaped.ok, false);
+  assert.match(escaped.detail, /symlink escapes/);
+
+  const hard = path.join(base, 'hard'); fs.mkdirSync(hard);
+  const source = path.join(base, 'hard-source.txt'); fs.writeFileSync(source, 'x');
+  fs.linkSync(source, path.join(hard, 'linked.txt'));
+  const shared = C.validateNegativeFixture(hard, []);
+  assert.equal(shared.ok, false);
+  assert.match(shared.detail, /hard link/);
+});