@selesai/code 0.13.13 → 0.13.14

package/dist/skills/unlazy/tests/lint-tests.mjs

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+// lint-tests.mjs : behavioural tests for scripts/gate-lint.mjs.
+// Zero dependencies, cross-platform.
+//
+//   node tests/lint-tests.mjs            run all
+//   node tests/lint-tests.mjs regex      run tests whose name contains "regex"
+//
+// Prints "N/N passed" on success, which is the string CI matches on.
+
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+import assert from "node:assert/strict";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const LINT = join(HERE, "..", "scripts", "gate-lint.mjs");
+const filter = process.argv[2] || "";
+const DIR = mkdtempSync(join(tmpdir(), "unlazy-lint-test-"));
+
+const tests = [];
+const test = (name, fn) => tests.push({ name, fn });
+
+function write(name, body) {
+  const path = join(DIR, name);
+  writeFileSync(path, body);
+  return path;
+}
+
+function lint(...args) {
+  const result = spawnSync(process.execPath, [LINT, ...args], { encoding: "utf8" });
+  return { out: result.stdout + result.stderr, code: result.status };
+}
+
+// ------------------------------------------------------------- fixtures
+
+// Every defect below passes gate-check today.
+const WEAK = write("weak.md", `# Gates: weak ledger
+
+Scope: a ledger that satisfies every enforcement layer and proves nothing
+
+- [ ] G1: the entire feature works perfectly
+  CHECK: echo ok
+  EXPECT: ok
+  EVIDENCE: pending
+
+- [ ] G2: improve the error handling
+  CHECK: node scripts/verify.mjs --banner DONE
+  EXPECT: DONE
+  EVIDENCE: pending
+
+- [ ] G3: renders 34 stat rows
+  EVIDENCE: pending
+
+- [ ] G4: config path is reported
+  CHECK: node scripts/show-path.mjs
+  EXPECT: /etc/app/conf/
+  EVIDENCE: pending
+`);
+
+const SOUND_BODY = `# Gates: sound ledger
+
+Scope: pricing section renders and behaves
+
+- [ ] G1: three tiers render with real copy
+  CHECK: node scripts/check.mjs pricing --tiers
+  EXPECT: 3/3 tiers rendered
+  EVIDENCE: pending
+
+- [ ] G2: annual toggle changes price and label
+  CHECK: node scripts/check.mjs pricing --toggle
+  EXPECT: toggle switched both fields
+  EVIDENCE: pending
+
+- [ ] G3: typecheck is clean
+  CHECK: npx tsc --noEmit
+  EXPECT: /Found 0 errors/
+  EVIDENCE: pending
+
+- [ ] G4: unit suite green
+  CHECK: node --test test/pricing.test.mjs
+  EXPECT: /# fail 0/
+  EVIDENCE: pending
+
+- [ ] G5: no console errors on load
+  CHECK: node scripts/check.mjs pricing --console
+  EXPECT: 0 console errors
+  EVIDENCE: pending
+`;
+
+const SOUND = write("sound.md", SOUND_BODY);
+const MANUAL = write("manual.md", SOUND_BODY + `
+- [ ] G6: copy reads as written by the brand, not by a model
+  EVIDENCE: pending
+`);
+
+// ------------------------------------------------------------- tests
+
+test("lint: a fixed-output command is advisory by default", () => {
+  const { out, code } = lint(WEAK);
+  assert.match(out, /G1: CHECK looks like a fixed-output command/);
+  assert.equal(code, 0);
+});
+
+test("lint: a chained verifier is not classified as a tautology", () => {
+  const chained = write("chained.md", `# Gates: chained
+
+- [ ] G1: verifier succeeds
+  CHECK: echo starting && node scripts/verify.mjs
+  EXPECT: VERIFY_OK
+  EVIDENCE: pending
+`);
+  assert.doesNotMatch(lint(chained).out, /tautological-check|fixed-output command/);
+});
+
+test("lint: EXPECT passed as an argument is not guaranteed output", () => {
+  const argument = write("argument.md", `# Gates: argument
+
+- [ ] G1: verifier succeeds
+  CHECK: node scripts/verify.mjs --expected VERIFY_OK
+  EXPECT: VERIFY_OK
+  EVIDENCE: pending
+`);
+  assert.doesNotMatch(lint(argument).out, /guarantees its own pass|expect-echoes-check/);
+});
+
+test("lint: an expectation shared with failure output is warned", () => {
+  assert.match(lint(WEAK).out, /G1:.*also appears in failure output/);
+});
+
+test("lint: an activity title is warned", () => {
+  assert.match(lint(WEAK).out, /G2:.*names an activity, not an outcome/);
+});
+
+test("lint: an unmeasured number in a manual gate is warned", () => {
+  assert.match(lint(WEAK).out, /G3:.*states a number that nothing measures/);
+});
+
+test("lint: a literal path read as a regex is warned", () => {
+  assert.match(lint(WEAK).out, /G4:.*looks like a literal path/);
+});
+
+test("lint: a deliberate slash wrapped pattern is not warned", () => {
+  assert.doesNotMatch(lint(SOUND).out, /looks like a literal path/);
+});
+
+test("lint: shipped leaf and node templates satisfy the documented size policy", () => {
+  for (const name of ["gates-leaf.md", "gates-node.md"]) {
+    const result = lint(join(HERE, "..", "templates", name));
+    assert.equal(result.code, 0, result.out);
+    assert.doesNotMatch(result.out, /thin-ledger|fat-ledger|under five|over twelve/);
+  }
+});
+
+test("lint: a sound ledger is clean and exits 0", () => {
+  const { out, code } = lint(SOUND);
+  assert.match(out, /^LINT OK$/m);
+  assert.equal(code, 0);
+});
+
+test("lint: default warnings and strict warnings have distinct gate markers and exits", () => {
+  const normal = lint(MANUAL);
+  assert.match(normal.out, /G6:.*judged by hand/);
+  assert.match(normal.out, /^LINT OK \(\d+ warning\(s\)\)$/m);
+  assert.equal(normal.code, 0);
+  const strict = lint("--strict", MANUAL);
+  assert.equal(strict.code, 1);
+  assert.match(strict.out, /^LINT FINDINGS:/m);
+  assert.doesNotMatch(strict.out, /^LINT OK/m);
+});
+
+test("lint: json reports counts and stays parseable", () => {
+  const data = JSON.parse(lint("--json", WEAK).out);
+  assert.equal(data.ok, true);
+  assert.equal(data.errors, 0);
+  assert.ok(data.warnings >= 1, "expected warnings, got " + data.warnings);
+  assert.ok(data.findings.every((f) => f.rule && f.level));
+  const strict = JSON.parse(lint("--strict", "--json", WEAK).out);
+  assert.equal(strict.ok, false);
+});
+
+test("lint: a ledger the shared parser rejects exits 2, not 1", () => {
+  const broken = write("broken.md", "# Gates: broken\n\n- [ ] no explicit id here\n");
+  assert.equal(lint(broken).code, 2);
+});
+
+test("lint: multiple ledgers in one run are all honored", () => {
+  const { out } = lint(SOUND, WEAK);
+  assert.match(out, /weak\.md/);
+  assert.match(out, /G1: CHECK looks like a fixed-output command/);
+});
+
+test("lint: path ambiguity is sourced once from the shared parser", () => {
+  const result = lint(WEAK);
+  assert.equal((result.out.match(/\[path-read-as-regex\]/g) || []).length, 1, result.out);
+});
+
+test("lint: an unknown option exits 2", () => {
+  assert.equal(lint("--nope", SOUND).code, 2);
+});
+
+test("CLI: an unknown short option exits 2", () => {
+  assert.equal(lint("-x", SOUND).code, 2);
+});
+
+test("CLI: the positional marker permits literal files named --help and -h", () => {
+  write("--help", SOUND_BODY);
+  write("-h", SOUND_BODY);
+  for (const filename of ["--help", "-h"]) {
+    const result = spawnSync(process.execPath, [LINT, "--", filename], { cwd: DIR, encoding: "utf8" });
+    assert.equal(result.status, 0, result.stdout + result.stderr);
+    assert.match(result.stdout, /^LINT OK$/m);
+    assert.doesNotMatch(result.stdout, /^usage:/m);
+  }
+});
+
+test("lint: no arguments exits 2", () => {
+  assert.equal(lint().code, 2);
+});
+
+// ------------------------------------------------------------- runner
+
+const selected = tests.filter((t) => t.name.includes(filter));
+let passed = 0;
+const failures = [];
+
+for (const t of selected) {
+  try {
+    t.fn();
+    passed++;
+    console.log("ok   " + t.name);
+  } catch (e) {
+    failures.push(t.name);
+    console.log("FAIL " + t.name + "\n     " + String(e.message).split("\n").join("\n     "));
+  }
+}
+
+console.log("");
+console.log(passed + "/" + selected.length + " passed");
+try { rmSync(DIR, { recursive: true, force: true }); } catch { /* windows lag */ }
+process.exit(failures.length ? 1 : 0);

package/dist/skills/unlazy/tests/run-tests.mjs

@@ -0,0 +1,360 @@
+#!/usr/bin/env node
+// run-tests.mjs : behavioural tests for the unlazy enforcement scripts.
+// Zero dependencies, cross-platform (every CHECK command is a `node -e`).
+//
+//   node tests/run-tests.mjs            run all
+//   node tests/run-tests.mjs scope      run tests whose name contains "scope"
+//
+// Prints "N/N passed" on success, which is the string CI and the repo's own
+// gates match on.
+
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync } from "node:fs";
+import { execFile } from "node:child_process";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const GATE_CHECK = join(HERE, "..", "scripts", "gate-check.mjs");
+const filter = process.argv[2] || "";
+const APPROVAL_ROOT = mkdtempSync(join(tmpdir(), "unlazy-test-approvals-"));
+
+const tests = [];
+const test = (name, fn) => tests.push({ name, fn });
+
+// ------------------------------------------------------------- helpers
+
+function sandbox() {
+  const dir = mkdtempSync(join(tmpdir(), "unlazy-test-"));
+  return {
+    dir,
+    write(rel, text) {
+      const p = join(dir, rel);
+      mkdirSync(dirname(p), { recursive: true });
+      writeFileSync(p, text);
+      return p;
+    },
+    read(rel) { return readFileSync(join(dir, rel), "utf8"); },
+    cleanup() { try { rmSync(dir, { recursive: true, force: true }); } catch { /* windows lag */ } },
+  };
+}
+
+function run(script, args, opts = {}) {
+  return new Promise((res) => {
+    const actions = new Set(["--status", "--claim", "--release", "--list-scopes", "--log", "--help", "-h"]);
+    const needsApproval = script === GATE_CHECK && !opts.noApprove && !args.some((arg) => actions.has(arg));
+    const actualArgs = needsApproval && !args.includes("--approve") ? ["--approve", ...args] : args;
+    const child = execFile(process.execPath, [script, ...actualArgs], {
+      cwd: opts.cwd, encoding: "utf8", maxBuffer: 8 * 1024 * 1024,
+      env: { ...process.env, UNLAZY_APPROVAL_DIR: APPROVAL_ROOT, ...(opts.env || {}) },
+    }, (err, stdout, stderr) => {
+      res({ code: err ? (err.code ?? 1) : 0, out: (stdout || "") + (stderr || "") });
+    });
+    if (opts.stdin !== undefined) { child.stdin.end(opts.stdin); }
+  });
+}
+
+const gate = (id, title, check, expect) =>
+  "- [ ] " + id + ": " + title + "\n" +
+  (check ? "  CHECK: " + check + "\n" : "") +
+  (expect ? "  EXPECT: " + expect + "\n" : "") +
+  "  EVIDENCE: pending\n";
+
+const nodeEval = (js) => 'node -e "' + js.replace(/"/g, '\\"') + '"';
+const echoOk = (word) => nodeEval("console.log('" + word + "')");
+
+function assert(cond, msg) { if (!cond) throw new Error(msg); }
+function assertHas(hay, needle, label) {
+  assert(hay.includes(needle), (label || "output") + " missing " + JSON.stringify(needle) + "\n--- got ---\n" + hay);
+}
+function assertLacks(hay, needle, label) {
+  assert(!hay.includes(needle), (label || "output") + " unexpectedly contains " + JSON.stringify(needle) + "\n--- got ---\n" + hay);
+}
+
+// --------------------------------------------------------------- tests
+
+test("args: two explicit files are both processed without --timeout", async () => {
+  const s = sandbox();
+  try {
+    s.write("gates/leaf-a.md", "# Gates: A\n\n" + gate("G1", "A", echoOk("A-OK"), "A-OK"));
+    s.write("gates/leaf-b.md", "# Gates: B\n\n" + gate("G1", "B", echoOk("B-OK"), "B-OK"));
+    const r = await run(GATE_CHECK, ["gates/leaf-a.md", "gates/leaf-b.md"], { cwd: s.dir });
+    assertHas(r.out, "PASS leaf-a:G1");
+    assertHas(r.out, "PASS leaf-b:G1");
+    assertHas(r.out, "ALL MET (2 met)");
+    assertHas(s.read("gates/leaf-a.md"), "- [x] G1", "leaf-a");
+    assert(r.code === 0, "expected exit 0, got " + r.code);
+  } finally { s.cleanup(); }
+});
+
+test("args: one explicit file never widens to the rest of the tree", async () => {
+  const s = sandbox();
+  try {
+    s.write("gates/leaf-a.md", "# Gates: A\n\n" + gate("G1", "A", echoOk("A-OK"), "A-OK"));
+    s.write("gates/leaf-b.md", "# Gates: B\n\n" + gate("G1", "B", echoOk("B-OK"), "B-OK"));
+    const r = await run(GATE_CHECK, ["gates/leaf-a.md"], { cwd: s.dir });
+    assertHas(r.out, "PASS leaf-a:G1");
+    assertLacks(r.out, "leaf-b", "run output");
+    assertHas(s.read("gates/leaf-b.md"), "- [ ] G1", "leaf-b must be untouched");
+    assertHas(s.read("gates/leaf-b.md"), "EVIDENCE: pending", "leaf-b evidence must be untouched");
+  } finally { s.cleanup(); }
+});
+
+test("args: unknown option is rejected instead of treated as a file", async () => {
+  const s = sandbox();
+  try {
+    s.write("GATES.md", "# Gates\n\n" + gate("G1", "x", echoOk("OK"), "OK"));
+    const r = await run(GATE_CHECK, ["--nope"], { cwd: s.dir });
+    assert(r.code === 2, "expected exit 2, got " + r.code);
+    assertHas(r.out, "unknown option --nope");
+  } finally { s.cleanup(); }
+});
+
+test("scope: running one pipeline leaves the other pipeline alone", async () => {
+  const s = sandbox();
+  try {
+    s.write(".unlazy/api/gates/leaf-1.md", "# Gates: api1\n\n" + gate("G1", "api", echoOk("API-OK"), "API-OK"));
+    s.write(".unlazy/web/gates/leaf-1.md", "# Gates: web1\n\n" + gate("G1", "web", echoOk("WEB-OK"), "WEB-OK"));
+    const r = await run(GATE_CHECK, ["--scope", "api"], { cwd: s.dir });
+    assertHas(r.out, "PASS leaf-1:G1");
+    assertHas(r.out, "[scope api]");
+    assertHas(s.read(".unlazy/api/gates/leaf-1.md"), "- [x] G1", "api gates");
+    assertHas(s.read(".unlazy/web/gates/leaf-1.md"), "- [ ] G1", "web gates must be untouched");
+  } finally { s.cleanup(); }
+});
+
+test("scope: two pipelines and no scope is refused, not guessed", async () => {
+  const s = sandbox();
+  try {
+    s.write(".unlazy/api/gates/leaf-1.md", "# Gates: api\n\n" + gate("G1", "api", echoOk("API-OK"), "API-OK"));
+    s.write(".unlazy/web/gates/leaf-1.md", "# Gates: web\n\n" + gate("G1", "web", echoOk("WEB-OK"), "WEB-OK"));
+    const r = await run(GATE_CHECK, [], { cwd: s.dir });
+    assert(r.code === 2, "expected exit 2, got " + r.code);
+    assertHas(r.out, "2 pipelines present");
+    assertHas(r.out, "api");
+    assertHas(r.out, "web");
+    assertHas(s.read(".unlazy/api/gates/leaf-1.md"), "- [ ] G1", "api must be untouched");
+    assertHas(s.read(".unlazy/web/gates/leaf-1.md"), "- [ ] G1", "web must be untouched");
+  } finally { s.cleanup(); }
+});
+
+test("scope: UNLAZY_SCOPE selects the pipeline", async () => {
+  const s = sandbox();
+  try {
+    s.write(".unlazy/api/gates/leaf-1.md", "# Gates: api\n\n" + gate("G1", "api", echoOk("API-OK"), "API-OK"));
+    s.write(".unlazy/web/gates/leaf-1.md", "# Gates: web\n\n" + gate("G1", "web", echoOk("WEB-OK"), "WEB-OK"));
+    const r = await run(GATE_CHECK, [], { cwd: s.dir, env: { UNLAZY_SCOPE: "web" } });
+    assertHas(r.out, "[scope web]");
+    assertHas(s.read(".unlazy/web/gates/leaf-1.md"), "- [x] G1", "web gates");
+    assertHas(s.read(".unlazy/api/gates/leaf-1.md"), "- [ ] G1", "api must be untouched");
+  } finally { s.cleanup(); }
+});
+
+test("scope: a single pipeline needs no flag", async () => {
+  const s = sandbox();
+  try {
+    s.write(".unlazy/solo/GATES.md", "# Gates: solo\n\n" + gate("G1", "solo", echoOk("S-OK"), "S-OK"));
+    const r = await run(GATE_CHECK, [], { cwd: s.dir });
+    assertHas(r.out, "ALL MET (1 met) [scope solo]");
+  } finally { s.cleanup(); }
+});
+
+test("scope: legacy GATES.md layout still works", async () => {
+  const s = sandbox();
+  try {
+    s.write("GATES.md", "# Gates\n\n" + gate("G1", "legacy", echoOk("L-OK"), "L-OK"));
+    const r = await run(GATE_CHECK, [], { cwd: s.dir });
+    assertHas(r.out, "PASS GATES:G1");
+    assertHas(r.out, "ALL MET (1 met)");
+  } finally { s.cleanup(); }
+});
+
+test("state: checked box with pending evidence counts as unmet", async () => {
+  const s = sandbox();
+  try {
+    s.write("GATES.md", "# Gates\n\n- [x] G1: claimed\n  EVIDENCE: pending\n");
+    const r = await run(GATE_CHECK, ["--status"], { cwd: s.dir });
+    assert(r.code === 1, "expected exit 1, got " + r.code);
+    assertHas(r.out, "UNMET GATES:G1 (checked but EVIDENCE pending)");
+  } finally { s.cleanup(); }
+});
+
+test("state: ABANDON is a non-success handoff, not completion", async () => {
+  const s = sandbox();
+  try {
+    s.write("GATES.md", "# Gates\n\n- [ ] G1: impossible\n  EVIDENCE: pending\n\nABANDON: G1 upstream API removed\n");
+    const r = await run(GATE_CHECK, ["--status"], { cwd: s.dir });
+    assert(r.code === 1, "expected exit 1, got " + r.code);
+    assertHas(r.out, "HANDOFF REQUIRED: 1 abandoned");
+    assertLacks(r.out, "ALL MET");
+  } finally { s.cleanup(); }
+});
+
+test("state: abandoned and mixed ledgers stay handoffs in every run mode", async () => {
+  for (const args of [["--status"], [], ["--reverify"]]) {
+    const s = sandbox();
+    try {
+      s.write("GATES.md", [
+        "# Gates",
+        "",
+        "- [x] G1: measured outcome",
+        "  EVIDENCE: checked by test",
+        "",
+        "- [ ] G2: impossible outcome",
+        "  EVIDENCE: pending",
+        "",
+        "ABANDON: G2 upstream API removed",
+        "",
+      ].join("\n"));
+      const r = await run(GATE_CHECK, args, { cwd: s.dir });
+      assert(r.code === 1, "expected exit 1 for " + JSON.stringify(args) + ", got " + r.code + "\n" + r.out);
+      assertHas(r.out, "HANDOFF REQUIRED: 1 abandoned");
+      assertLacks(r.out, "ALL MET");
+    } finally { s.cleanup(); }
+  }
+});
+
+test("state: multi-file verification cannot hide one abandoned child", async () => {
+  const s = sandbox();
+  try {
+    s.write("met.md", "# Gates\n\n- [x] G1: complete\n  EVIDENCE: checked by test\n");
+    s.write("abandoned.md", "# Gates\n\n- [ ] G1: impossible\n  EVIDENCE: pending\n\nABANDON: G1 upstream removed\n");
+    const r = await run(GATE_CHECK, ["--status", "met.md", "abandoned.md"], { cwd: s.dir });
+    assert(r.code === 1, "expected exit 1, got " + r.code + "\n" + r.out);
+    assertHas(r.out, "HANDOFF REQUIRED: 1 abandoned");
+    assertHas(r.out, "abandoned:G1");
+    assertLacks(r.out, "ALL MET");
+  } finally { s.cleanup(); }
+});
+
+test("hierarchy: an abandoned child cannot promote its N1 parent", async () => {
+  const s = sandbox();
+  try {
+    const child = s.write("child.md", "# Gates\n\n- [ ] G1: impossible\n  EVIDENCE: pending\n\nABANDON: G1 upstream removed\n");
+    s.write("parent-oracle.mjs", [
+      "import { spawnSync } from 'node:child_process';",
+      "const result = spawnSync(process.execPath, [" + JSON.stringify(GATE_CHECK) + ", '--reverify', " + JSON.stringify(child) + "], { encoding: 'utf8', env: process.env });",
+      "process.stdout.write((result.stdout || '') + (result.stderr || ''));",
+      "process.exit(result.status === 0 ? 0 : 1);",
+      "",
+    ].join("\n"));
+    s.write("parent.md", "# Gates: parent\n\n" + gate("N1", "child is complete", "node parent-oracle.mjs", "ALL MET"));
+    const r = await run(GATE_CHECK, ["parent.md"], { cwd: s.dir });
+    assert(r.code === 1, "parent unexpectedly passed\n" + r.out);
+    assertHas(r.out, "FAIL parent:N1");
+    assertHas(r.out, "HANDOFF REQUIRED");
+    assertLacks(r.out, "PASS parent:N1");
+    assertHas(s.read("parent.md"), "- [ ] N1");
+  } finally { s.cleanup(); }
+});
+
+test("state: unmet gates are reported with file-qualified ids", async () => {
+  const s = sandbox();
+  try {
+    s.write(".unlazy/api/gates/leaf-1.md", "# Gates: 1\n\n" + gate("G1", "a", null, null));
+    s.write(".unlazy/api/gates/leaf-2.md", "# Gates: 2\n\n" + gate("G1", "b", null, null));
+    const r = await run(GATE_CHECK, ["--scope", "api", "--status"], { cwd: s.dir });
+    assertHas(r.out, "leaf-1:G1");
+    assertHas(r.out, "leaf-2:G1");
+  } finally { s.cleanup(); }
+});
+
+test("run: a concurrent edit to another gate in the same file survives", async () => {
+  const s = sandbox();
+  try {
+    // G1 is slow and will be flipped by gate-check; G2 is manual and gets its
+    // evidence filled in by hand while that check is still running.
+    s.write("GATES.md",
+      "# Gates\n\n" +
+      "- [ ] G1: slow\n  CHECK: " + nodeEval("setTimeout(()=>console.log('SLOW-OK'),2500)") +
+      "\n  EXPECT: SLOW-OK\n  EVIDENCE: pending\n\n" +
+      "- [ ] G2: manual\n  EVIDENCE: pending\n");
+    const running = run(GATE_CHECK, [], { cwd: s.dir });
+    await new Promise(r => setTimeout(r, 800));
+    const text = s.read("GATES.md")
+      .replace("- [ ] G2: manual\n  EVIDENCE: pending", "- [x] G2: manual\n  EVIDENCE: measured 47 rows, threadAnalysis.ts:88");
+    s.write("GATES.md", text);
+    await running;
+    const after = s.read("GATES.md");
+    assertHas(after, "- [x] G1", "G1 should be flipped by the checker");
+    assertHas(after, "measured 47 rows", "the hand edit to G2 must not be clobbered");
+    assertLacks(after, "G2: manual\n  EVIDENCE: pending", "G2 must not be reverted");
+  } finally { s.cleanup(); }
+});
+
+test("checks: CWD runs a check in the directory it names", async () => {
+  const s = sandbox();
+  try {
+    s.write("sub/marker.txt", "here\n");
+    s.write("GATES.md", "# Gates\n\n" +
+      "- [ ] G1: in sub\n  CHECK: " + nodeEval("console.log(require('fs').readFileSync('marker.txt','utf8'))") +
+      "\n  EXPECT: here\n  CWD: sub\n  EVIDENCE: pending\n");
+    const r = await run(GATE_CHECK, [], { cwd: s.dir });
+    assertHas(r.out, "ALL MET (1 met)");
+  } finally { s.cleanup(); }
+});
+
+test("leases: overlapping OWNS across pipelines is refused", async () => {
+  const s = sandbox();
+  try {
+    s.write(".unlazy/api/gates/leaf-1.md", "OWNS: src/shared/**\n\n# Gates\n\n" + gate("G1", "a", null, null));
+    s.write(".unlazy/web/gates/leaf-1.md", "OWNS: src/shared/util.ts\n\n# Gates\n\n" + gate("G1", "b", null, null));
+    const a = await run(GATE_CHECK, ["--scope", "api", "--leaf", "leaf-1", "--claim"], { cwd: s.dir });
+    assertHas(a.out, "CLAIMED 1 path(s) for api/leaf-1");
+    const b = await run(GATE_CHECK, ["--scope", "web", "--leaf", "leaf-1", "--claim"], { cwd: s.dir });
+    assert(b.code === 3, "expected exit 3 on conflict, got " + b.code);
+    assertHas(b.out, "CONFLICT src/shared/util.ts overlaps src/shared/** held by api/leaf-1");
+    assertHas(b.out, "CLAIM REFUSED");
+  } finally { s.cleanup(); }
+});
+
+test("leases: disjoint OWNS both succeed, and release frees them", async () => {
+  const s = sandbox();
+  try {
+    s.write(".unlazy/api/gates/leaf-1.md", "OWNS: src/api/**\n\n# Gates\n\n" + gate("G1", "a", null, null));
+    s.write(".unlazy/api/gates/leaf-2.md", "OWNS: src/web/**\n\n# Gates\n\n" + gate("G1", "b", null, null));
+    const a = await run(GATE_CHECK, ["--scope", "api", "--leaf", "leaf-1", "--claim"], { cwd: s.dir });
+    const b = await run(GATE_CHECK, ["--scope", "api", "--leaf", "leaf-2", "--claim"], { cwd: s.dir });
+    assert(a.code === 0 && b.code === 0, "disjoint claims should both succeed");
+    assertHas(b.out, "CLAIMED 1 path(s) for api/leaf-2");
+    const rel = await run(GATE_CHECK, ["--scope", "api", "--release"], { cwd: s.dir });
+    assertHas(rel.out, "released 2 lease(s)");
+  } finally { s.cleanup(); }
+});
+
+test("status log: appends, and appends survive concurrency", async () => {
+  const s = sandbox();
+  try {
+    s.write(".unlazy/api/gates/leaf-1.md", "# Gates\n\n" + gate("G1", "a", null, null));
+    await Promise.all([
+      run(GATE_CHECK, ["--scope", "api", "--log", "leaf-1 started"], { cwd: s.dir }),
+      run(GATE_CHECK, ["--scope", "api", "--log", "leaf-2 started"], { cwd: s.dir }),
+      run(GATE_CHECK, ["--scope", "api", "--log", "leaf-3 started"], { cwd: s.dir }),
+    ]);
+    const log = s.read(".unlazy/api/status.log");
+    for (const n of [1, 2, 3]) assertHas(log, "leaf-" + n + " started", "status log");
+  } finally { s.cleanup(); }
+});
+
+
+// ---------------------------------------------------------------- driver
+
+const selected = tests.filter(t => t.name.includes(filter));
+let passed = 0;
+const failures = [];
+
+for (const t of selected) {
+  try {
+    await t.fn();
+    passed++;
+    console.log("ok   " + t.name);
+  } catch (e) {
+    failures.push({ name: t.name, err: e });
+    console.log("FAIL " + t.name + "\n     " + String(e.message).split("\n").join("\n     "));
+  }
+}
+
+console.log("");
+console.log(passed + "/" + selected.length + " passed");
+try { rmSync(APPROVAL_ROOT, { recursive: true, force: true }); } catch { /* best effort */ }
+process.exit(failures.length ? 1 : 0);