nccgs 2.0.0 → 2.1.1

package/tests/uninstall.test.mjs

@@ -0,0 +1,477 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import crypto from "node:crypto";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import test from "node:test";
+import { uninstall } from "../scripts/uninstall.mjs";
+import { launchPlan, run as runClaude } from "../scripts/run.mjs";
+import { recoverSession } from "../scripts/recover-session.mjs";
+import { acquireInstallationLease, assertInstallationAvailable } from "../.claude/nccgs/tools/installation-guard.mjs";
+import { ownerState } from "../.claude/nccgs/tools/process-lock.mjs";
+import { compile } from "../.claude/nccgs/tools/compile-policy.mjs";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const hash = value => crypto.createHash("sha256").update(value).digest("hex");
+const read = file => JSON.parse(fs.readFileSync(file, "utf8"));
+function inventory(directory, relative = "") {
+  return Object.fromEntries(fs.readdirSync(path.join(directory, relative), { withFileTypes: true }).flatMap(entry => {
+    const name = relative ? `${relative}/${entry.name}` : entry.name;
+    if (name.startsWith(".nccgs/uninstall/") || name === ".nccgs/uninstall") return [];
+    if (entry.isDirectory()) return Object.entries(inventory(directory, name));
+    assert.ok(entry.isFile(), name);
+    return [[name, hash(fs.readFileSync(path.join(directory, name)))]];
+  }));
+}
+function fixture({ settings, claude } = {}) {
+  const parent = fs.realpathSync(os.tmpdir()), directory = fs.mkdtempSync(path.join(parent, "nccgs-uninstall-")), project = path.join(directory, "Unity project Việt");
+  fs.mkdirSync(project);
+  const at = relative => path.join(project, relative), write = (relative, value) => {
+    fs.mkdirSync(path.dirname(at(relative)), { recursive: true }); fs.writeFileSync(at(relative), typeof value === "string" ? value : JSON.stringify(value, null, 2) + "\n");
+  };
+  write("Assets/Game.cs", "// owner's game source\n"); write("Packages/manifest.json", { dependencies: {} }); write("ProjectSettings/ProjectVersion.txt", "m_EditorVersion: 6000.3.17f1\n");
+  if (settings) write(".claude/settings.json", settings);
+  if (claude !== undefined) write("CLAUDE.md", claude);
+  const env = { ...process.env };
+  for (const key of ["CLAUDECODE", "CLAUDE_CODE_ENTRYPOINT", "NCCGS_SUPERVISED_SESSION", "NCCGS_TASK_AUTONOMY", "NCCGS_PROJECT_ROOT"]) delete env[key];
+  const run = (...args) => spawnSync(process.execPath, [path.join(root, "scripts/cli.mjs"), ...args, "--project", project], { cwd: directory, env, windowsHide: true, encoding: "utf8", timeout: 60000, maxBuffer: 5e6 });
+  const installed = run("install", "--autonomy", "guarded"); assert.equal(installed.status, 0, installed.stderr + installed.stdout);
+  const remove = (...args) => { const r = run("uninstall", ...args); assert.equal(r.status, 0, r.stderr + r.stdout); return JSON.parse(r.stdout); };
+  const dispose = () => {
+    assert.equal(fs.realpathSync(path.dirname(directory)).toLowerCase(), parent.toLowerCase());
+    assert.ok(path.basename(directory).startsWith("nccgs-uninstall-")); assert.ok(!fs.lstatSync(directory).isSymbolicLink());
+    fs.rmSync(directory, { recursive: true, force: true });
+  };
+  return { directory, project, at, write, run, remove, env, dispose };
+}
+
+test("uninstall preview is read-only, preserves game/history, detaches hooks and restores exact bytes", () => {
+  const f = fixture({ claude: "# Owner instructions\r\nKeep my game rules.\r\n", settings: { env: { OWNER: "keep" }, permissions: { allow: ["Bash(git status*)"], deny: ["Read(private/**)"] }, hooks: { SessionStart: [{ matcher: "", timeout: 9, hooks: [{ type: "command", command: "echo owner" }] }] } } });
+  try {
+    f.write(".nccgs/tasks/open.json", { id: "open", closed: null, history: [{ outcome: "failed" }], reviewBudget: { used: 1, limit: 3 } });
+    f.write(".nccgs/budgets/open.json", { totalUsd: 12, spentUsd: 7 }); f.write(".nccgs/evidence/original.txt", "negative evidence\n");
+    f.write(".claude/skills/owner/SKILL.md", "Owner tool\n");
+    const before = inventory(f.project), settings = read(f.at(".claude/settings.json"));
+    const preview = f.remove("--dry-run"); assert.equal(preview.status, "PLANNED"); assert.ok(preview.remove.length > 300); assert.deepEqual(inventory(f.project), before);
+    const result = f.remove(); assert.equal(result.status, "UNINSTALLED"); assert.ok(!fs.existsSync(f.at(".claude/nccgs/install-state.json")));
+    for (const name of Object.keys(before).filter(n => n.startsWith(".nccgs/") || n.startsWith("Assets/") || n.startsWith("Packages/") || n.startsWith("ProjectSettings/") || n.includes("/owner/"))) assert.equal(inventory(f.project)[name], before[name], name);
+    const after = read(f.at(".claude/settings.json")); assert.deepEqual(after.permissions, settings.permissions); assert.deepEqual(after.env, settings.env); assert.equal(after.model, settings.model);
+    assert.deepEqual(after.hooks.SessionStart, [{ matcher: "", timeout: 9, hooks: [{ type: "command", command: "echo owner" }] }]);
+    assert.ok(fs.readFileSync(f.at("CLAUDE.md"), "utf8").startsWith("# Owner instructions\r\nKeep my game rules.\r\n"));
+    assert.ok(!fs.readFileSync(f.at("CLAUDE.md"), "utf8").includes("@.claude/nccgs/"));
+    const removed = inventory(f.project); assert.equal(f.remove().status, "NOT_INSTALLED"); assert.deepEqual(inventory(f.project), removed);
+    assert.equal(f.remove("--rollback", result.id, "--dry-run").status, "ROLLBACK_PREVIEW"); assert.deepEqual(inventory(f.project), removed);
+    assert.equal(f.remove("--rollback", result.id).status, "RESTORED"); assert.deepEqual(inventory(f.project), before); assert.equal(f.run("doctor").status, 0);
+  } finally { f.dispose(); }
+});
+
+test("modified managed files and unrelated files survive; optional generated agents are removed", () => {
+  const f = fixture();
+  try {
+    assert.equal(f.run("agents", "--enable", "nccgs-network-programmer").status, 0);
+    f.write(".claude/agents/nccgs-gameplay-programmer.md", "My customized worker\n");
+    f.write(".claude/skills/review/SKILL.md", "My customized review\n");
+    f.write(".claude/nccgs/owner-notes.txt", "Untracked owner file\n");
+    const before = inventory(f.project), result = f.remove(); assert.equal(result.status, "UNINSTALLED_WITH_PRESERVED_FILES");
+    assert.ok(result.preserved.some(x => x.path === ".claude/agents/nccgs-gameplay-programmer.md"));
+    for (const name of [".claude/agents/nccgs-gameplay-programmer.md", ".claude/skills/review/SKILL.md", ".claude/nccgs/owner-notes.txt"]) assert.equal(inventory(f.project)[name], before[name]);
+    assert.ok(!fs.existsSync(f.at(".claude/agents/nccgs-network-programmer.md"))); assert.ok(!fs.existsSync(f.at("CLAUDE.md")));
+    f.remove("--rollback", result.id); assert.deepEqual(inventory(f.project), before);
+  } finally { f.dispose(); }
+});
+
+test("mixed hook groups preserve owner metadata and hooks; customized compound hooks refuse cleanup", () => {
+  const f = fixture();
+  try {
+    const settings = read(f.at(".claude/settings.json")), group = settings.hooks.PreToolUse[0];
+    group.ownerMarker = "keep"; group.hooks.push({ type: "command", command: "echo user", timeout: 2 }); f.write(".claude/settings.json", settings);
+    const result = f.remove(); const after = read(f.at(".claude/settings.json")); assert.equal(after.hooks.PreToolUse[0].ownerMarker, "keep"); assert.deepEqual(after.hooks.PreToolUse[0].hooks, [{ type: "command", command: "echo user", timeout: 2 }]);
+    f.remove("--rollback", result.id);
+    settings.hooks.PreToolUse[0].hooks[0].command += " && echo private-owner-step"; f.write(".claude/settings.json", settings);
+    const before = inventory(f.project), refused = f.run("uninstall"); assert.notEqual(refused.status, 0); assert.match(refused.stderr, /Customized NCCGS hook/); assert.deepEqual(inventory(f.project), before);
+  } finally { f.dispose(); }
+});
+
+test("active or uncertain dispatch, verification, run and process ownership block without mutation", () => {
+  const f = fixture();
+  try {
+    const scenarios = [
+      [".nccgs/orchestration.json", { dispatches: { one: { id: "one", status: "uncertain" } } }],
+      [".nccgs/jobs/one/request.json", { id: "one" }],
+      [".nccgs/runs/one/run.json", { status: "blocked", invocations: [{ status: "running", pid: process.pid }] }],
+      [".nccgs/runs/one/run.json", { status: "unknown", invocations: [] }],
+      [".nccgs/uninstall.lock.recovery", { broken: true }],
+      [".nccgs/sessions/one.lock", { schemaVersion: 1, host: os.hostname(), pid: process.pid, token: "owner", phase: "owned", child: null }],
+      [".nccgs/orchestration.lock", { broken: true }]
+    ];
+    for (const [relative, value] of scenarios) {
+      f.write(relative, value); const before = inventory(f.project);
+      for (const args of [[], ["--dry-run"]]) { const r = f.run("uninstall", ...args); assert.notEqual(r.status, 0, relative); assert.deepEqual(inventory(f.project), before, relative); }
+      fs.unlinkSync(f.at(relative));
+    }
+    assert.equal(f.remove().status, "UNINSTALLED");
+  } finally { f.dispose(); }
+});
+
+test("unsafe and duplicate manifest paths are rejected before touching source", () => {
+  const f = fixture();
+  try {
+    const file = f.at(".claude/nccgs/install-state.json"), initial = read(file);
+    for (const name of ["../outside", "Assets/Game.cs", ".claude/settings.json", ".claude/nccgs/../../Assets/Game.cs", "C:/outside", ".claude/nccgs/con.txt"]) {
+      const state = structuredClone(initial); state.files.push({ relative: name, sha256: hash("x") }); f.write(".claude/nccgs/install-state.json", state);
+      const before = inventory(f.project); assert.notEqual(f.run("uninstall").status, 0, name); assert.deepEqual(inventory(f.project), before);
+    }
+    const state = structuredClone(initial); state.files.push(state.files[0]); f.write(".claude/nccgs/install-state.json", state); assert.notEqual(f.run("uninstall").status, 0);
+  } finally { f.dispose(); }
+});
+
+test("rollback refuses new owner edits and corrupt backups before restoring anything", () => {
+  const f = fixture();
+  try {
+    const result = f.remove(), manifest = read(f.at(result.backup)), first = manifest.files.find(x => x.after === null);
+    f.write(first.path, "new owner content\n"); const modified = inventory(f.project);
+    assert.notEqual(f.run("uninstall", "--rollback", result.id).status, 0); assert.deepEqual(inventory(f.project), modified);
+    fs.unlinkSync(f.at(first.path)); const backup = `.nccgs/uninstall/${result.id}/files/${first.path}`; f.write(backup, "tampered\n");
+    const before = inventory(f.project); const rejected = f.run("uninstall", "--rollback", result.id); assert.notEqual(rejected.status, 0); assert.match(rejected.stderr, /Changed rollback backup/); assert.deepEqual(inventory(f.project), before);
+  } finally { f.dispose(); }
+});
+
+test("reinstall after uninstall retains existing task history policy and spent budget", () => {
+  const f = fixture();
+  try {
+    f.write(".nccgs/tasks/retained.json", { id: "retained", history: [{ outcome: "failed" }], reviewBudget: { used: 2 } });
+    f.write(".nccgs/budgets/retained.json", { totalUsd: 12, spentUsd: 9 });
+    const before = inventory(f.project), result = f.remove(); assert.equal(result.status, "UNINSTALLED");
+    assert.equal(f.run("install").status, 0); assert.equal(f.run("doctor").status, 0);
+    for (const name of [".nccgs/tasks/retained.json", ".nccgs/budgets/retained.json", ".nccgs/project.yaml", ".nccgs/execution.json"]) assert.equal(inventory(f.project)[name], before[name]);
+    assert.notEqual(f.run("uninstall", "--rollback", result.id).status, 0, "Reinstall must not be silently overwritten by rollback");
+  } finally { f.dispose(); }
+});
+
+test("write failure restores previously removed files and records the failed attempt", () => {
+  const f = fixture();
+  try {
+    const before = inventory(f.project), original = fs.unlinkSync; let count = 0;
+    fs.unlinkSync = function(file) { if (String(file).includes(`${path.sep}.claude${path.sep}`) && ++count === 3) throw new Error("synthetic unlink failure"); return original.call(fs, file); };
+    try { assert.throws(() => uninstall(f.project), /all planned files restored/); } finally { fs.unlinkSync = original; }
+    assert.deepEqual(inventory(f.project), before); const ids = fs.readdirSync(f.at(".nccgs/uninstall")); assert.equal(ids.length, 1);
+    const manifest = read(f.at(`.nccgs/uninstall/${ids[0]}/manifest.json`)); assert.equal(manifest.status, "restored"); assert.match(manifest.error, /synthetic unlink failure/);
+  } finally { f.dispose(); }
+});
+
+test("interrupted uninstall blocks launch/update and can recover from the preserved receipt", () => {
+  const f = fixture();
+  try {
+    const result = f.remove(), receipt = read(f.at(result.backup)); receipt.status = "applying"; f.write(result.backup, receipt);
+    assert.throws(() => launchPlan(["--project", f.project, "--dry-run"], f.env), /Interrupted uninstall/);
+    assert.notEqual(f.run("install").status, 0); assert.notEqual(f.run("uninstall").status, 0);
+    assert.equal(f.remove("--rollback", result.id).status, "RESTORED"); assert.equal(f.run("doctor").status, 0);
+  } finally { f.dispose(); }
+});
+
+test("active removal prevents install and launch; unknown tracked files and line endings stay safe", () => {
+  const f = fixture();
+  try {
+    f.write(".nccgs/uninstall.lock", { schemaVersion: 1, host: os.hostname(), pid: process.pid, token: "active-removal", phase: "owned", child: null });
+    const locked = inventory(f.project);
+    assert.notEqual(f.run("install").status, 0); assert.notEqual(f.run("run", "--dry-run").status, 0);
+    assert.deepEqual(inventory(f.project), locked); fs.unlinkSync(f.at(".nccgs/uninstall.lock"));
+    const state = read(f.at(".claude/nccgs/install-state.json"));
+    f.write(".claude/owner-secret.txt", "unrelated owner file\n");
+    state.files.push({ relative: ".claude/owner-secret.txt", sha256: hash("unrelated owner file\n") }); f.write(".claude/nccgs/install-state.json", state);
+    const skill = ".claude/skills/review/SKILL.md";
+    f.write(skill, fs.readFileSync(f.at(skill), "utf8").replace(/\r\n/g, "\n").replace(/\n/g, "\r\n"));
+    const before = inventory(f.project), result = f.remove();
+    assert.equal(result.status, "UNINSTALLED_WITH_PRESERVED_FILES"); assert.ok(!fs.existsSync(f.at(skill)));
+    assert.equal(inventory(f.project)[".claude/owner-secret.txt"], before[".claude/owner-secret.txt"]);
+    f.remove("--rollback", result.id); assert.deepEqual(inventory(f.project), before);
+  } finally { f.dispose(); }
+});
+
+test("failed native launch releases its session lease without starting a provider", async () => {
+  const f = fixture();
+  try {
+    await assert.rejects(runClaude(["--project", f.project, "--claude", path.join(f.directory, "absent-claude-binary")]), /Cannot start Claude Code/);
+    assert.equal(fs.readdirSync(f.at(".nccgs/sessions")).length, 0); assert.equal(f.remove().status, "UNINSTALLED");
+  } finally { f.dispose(); }
+});
+
+test("uninstall completed between planning and session registration cannot start Claude", async () => {
+  const f = fixture();
+  const original = fs.openSync; let intercepted = false;
+  try {
+    fs.openSync = function(file, ...args) {
+      if (!intercepted && String(file) === f.at(".nccgs/uninstall.lock")) {
+        intercepted = true; assert.equal(uninstall(f.project).status, "UNINSTALLED");
+      }
+      return original.call(fs, file, ...args);
+    };
+    await assert.rejects(runClaude(["--project", f.project, "--claude", path.join(f.directory, "absent-claude-binary")]), /removed before launch/);
+    assert.ok(intercepted); assert.equal(fs.readdirSync(f.at(".nccgs/sessions")).length, 0);
+  } finally { fs.openSync = original; f.dispose(); }
+});
+
+test("dead launcher recovery requires explicit tree attestation and archives exact leases without resetting history", () => {
+  const f = fixture();
+  try {
+    const stopped = spawnSync(process.execPath, ["-e", "process.exit(0)"], { windowsHide: true });
+    assert.equal(stopped.status, 0); assert.throws(() => process.kill(stopped.pid, 0), error => error.code === "ESRCH");
+    f.write(".nccgs/tasks/history.json", { outcome: "partial", reviewBudget: { used: 2 }, history: ["failed"] });
+    f.write(".nccgs/budgets/history.json", { spentUsd: 9, totalUsd: 12 });
+    const history = inventory(f.project);
+    for (const phase of ["running", "spawning"]) {
+      const id = crypto.randomUUID(), relative = `.nccgs/sessions/${id}.lock`;
+      const record = { schemaVersion: 1, operation: "nccgs-run", host: os.hostname(), pid: stopped.pid, token: crypto.randomUUID(), phase,
+        child: phase === "running" ? { pid: stopped.pid, group: false } : null };
+      f.write(relative, record); assert.equal(ownerState(record), "unknown");
+      const before = inventory(f.project); assert.notEqual(f.run("uninstall").status, 0);
+      const preview = recoverSession(f.project, { id, dryRun: true }); assert.equal(preview.descendantTree, "unverified"); assert.deepEqual(inventory(f.project), before);
+      assert.throws(() => recoverSession(f.project, { id, expectedSha256: preview.sha256, reason: "I checked the tree" }), /confirm-process-tree-stopped/);
+      assert.throws(() => recoverSession(f.project, { id, expectedSha256: "a".repeat(64), confirmStopped: true, reason: "I checked the tree" }), /does not match/);
+      const result = recoverSession(f.project, { id, expectedSha256: preview.sha256, confirmStopped: true, reason: "Test-only dead harmless process; no descendants were created." });
+      assert.equal(result.status, "SESSION_RECONCILED"); assert.ok(!fs.existsSync(f.at(relative)));
+      assert.equal(hash(fs.readFileSync(f.at(result.archivedLease))), before[relative]);
+      assert.equal(read(f.at(result.receipt)).attestation.automaticDescendantProof, false);
+      assert.equal(read(f.at(result.receipt)).status, "pending");
+      assert.equal(read(f.at(result.outcome)).status, "completed");
+      assert.equal(read(f.at(result.outcome)).receiptSha256, hash(fs.readFileSync(f.at(result.receipt))));
+      assert.equal(read(f.at(result.outcome)).originalSha256, before[relative]);
+      assert.equal(ownerState(read(f.at(result.archivedLease))), "unknown", "Recovery does not weaken ownerState");
+    }
+    for (const relative of [".nccgs/tasks/history.json", ".nccgs/budgets/history.json"]) assert.equal(inventory(f.project)[relative], history[relative]);
+    f.write(".nccgs/jobs/unfinished/request.json", { id: "unfinished" }); assert.notEqual(f.run("uninstall").status, 0);
+    fs.unlinkSync(f.at(".nccgs/jobs/unfinished/request.json")); assert.equal(f.remove().status, "UNINSTALLED");
+  } finally { f.dispose(); }
+});
+
+test("session recovery rejects live owners, live children, foreign or unrelated records and unsafe identities without writes", () => {
+  const f = fixture();
+  try {
+    const stopped = spawnSync(process.execPath, ["-e", "process.exit(0)"], { windowsHide: true });
+    const id = crypto.randomUUID(), relative = `.nccgs/sessions/${id}.lock`;
+    const base = { schemaVersion: 1, operation: "nccgs-run", host: os.hostname(), pid: stopped.pid, token: crypto.randomUUID(), phase: "running", child: { pid: stopped.pid, group: false } };
+    for (const record of [{ ...base, pid: process.pid }, { ...base, child: { pid: process.pid } }, { ...base, host: "another-host" }, { ...base, operation: "verification" }, { ...base, token: "invalid" }]) {
+      f.write(relative, record); const before = inventory(f.project);
+      assert.throws(() => recoverSession(f.project, { id, expectedSha256: before[relative], confirmStopped: true, reason: "Cannot authorize a live or foreign process" }));
+      assert.deepEqual(inventory(f.project), before);
+    }
+    for (const unsafe of ["../tasks/one", "one", "C:/outside"]) assert.throws(() => recoverSession(f.project, { id: unsafe, dryRun: true }), /UUID/);
+    f.write(relative, base); const before = inventory(f.project), original = process.env.CLAUDECODE;
+    try { process.env.CLAUDECODE = "1"; assert.throws(() => recoverSession(f.project, { id, dryRun: true }), /external operator/); }
+    finally { if (original === undefined) delete process.env.CLAUDECODE; else process.env.CLAUDECODE = original; }
+    assert.deepEqual(inventory(f.project), before);
+    const preview = f.run("recover-session", "--id", id, "--dry-run"); assert.equal(preview.status, 0);
+    const result = f.run("recover-session", "--id", id, "--sha256", JSON.parse(preview.stdout).sha256, "--confirm-process-tree-stopped", "--reason", "Test fixture: dead process created no descendants.");
+    assert.equal(result.status, 0, result.stderr); assert.equal(JSON.parse(result.stdout).status, "SESSION_RECONCILED");
+  } finally { f.dispose(); }
+});
+
+test("admission contention identifies holders, empty locks and released holders after the first check", () => {
+  const f = fixture(), original = fs.openSync, originalRead = fs.readFileSync;
+  const gate = ".nccgs/uninstall.lock";
+  const owner = { schemaVersion: 1, host: os.hostname(), pid: process.pid, token: crypto.randomUUID(), phase: "owned", child: null };
+  try {
+    for (const operation of ["installation-admission", "uninstall"]) {
+      f.write(gate, { ...owner, operation }); const before = inventory(f.project);
+      const expected = operation === "installation-admission" ? /installation admission is busy or unverified/ : /uninstall is active or unverified/;
+      assert.throws(() => assertInstallationAvailable(f.project), expected);
+      assert.throws(() => acquireInstallationLease(f.project, "test"), expected);
+      assert.deepEqual(inventory(f.project), before); fs.unlinkSync(f.at(gate));
+    }
+    for (const state of ["valid", "empty", "released"]) {
+      let raced = false, released = false;
+      fs.openSync = function(file, flags, ...args) {
+        if (!raced && path.resolve(String(file)) === f.at(gate) && flags === "wx") {
+          raced = true; f.write(gate, state === "empty" ? "" : { ...owner, operation: "installation-admission" });
+        }
+        return original.call(fs, file, flags, ...args);
+      };
+      fs.readFileSync = function(file, ...args) {
+        const value = originalRead.call(fs, file, ...args);
+        if (state === "released" && !released && path.resolve(String(file)) === f.at(gate)) {
+          released = true; fs.unlinkSync(file);
+        }
+        return value;
+      };
+      try { assert.throws(() => acquireInstallationLease(f.project, "test"), /installation admission is busy or unverified/); }
+      finally { fs.openSync = original; fs.readFileSync = originalRead; }
+      assert.ok(raced);
+      if (state === "released") { assert.ok(released); assert.ok(!fs.existsSync(f.at(gate))); }
+      else { assert.equal(fs.readFileSync(f.at(gate), "utf8"), state === "empty" ? "" : JSON.stringify({ ...owner, operation: "installation-admission" }, null, 2) + "\n"); fs.unlinkSync(f.at(gate)); }
+    }
+    const lease = acquireInstallationLease(f.project, "test"); lease.release();
+    assert.equal(fs.readdirSync(f.at(".nccgs/sessions")).length, 0);
+  } finally { fs.openSync = original; fs.readFileSync = originalRead; f.dispose(); }
+});
+
+test("unreadable or changing admission records fail closed with actionable diagnostics and no mutations", () => {
+  const f = fixture(), originalRead = fs.readFileSync;
+  try {
+    for (const relative of [".nccgs/uninstall.lock", ".nccgs/uninstall.lock.recovery"]) {
+      for (const contents of ["", "{", "null", "true", "42", "[]", '"invalid"']) {
+        f.write(relative, contents); const before = inventory(f.project);
+        assert.throws(() => assertInstallationAvailable(f.project), error => !(error instanceof SyntaxError) && /admission is busy or unverified/.test(error.message));
+        assert.throws(() => acquireInstallationLease(f.project, "test"), /admission is busy or unverified/);
+        assert.deepEqual(inventory(f.project), before); fs.unlinkSync(f.at(relative));
+      }
+      for (const code of ["EACCES", "ENOENT"]) {
+        f.write(relative, "{}"); const before = inventory(f.project);
+        fs.readFileSync = function(file, ...args) {
+          if (path.resolve(String(file)) === f.at(relative)) { const error = new Error(`injected ${code}`); error.code = code; throw error; }
+          return originalRead.call(fs, file, ...args);
+        };
+        try { assert.throws(() => acquireInstallationLease(f.project, "test"), error => /admission is busy or unverified/.test(error.message) && error.cause?.code === code); }
+        finally { fs.readFileSync = originalRead; }
+        assert.deepEqual(inventory(f.project), before); fs.unlinkSync(f.at(relative));
+      }
+    }
+  } finally { fs.readFileSync = originalRead; f.dispose(); }
+});
+
+test("recovery rename errors preserve the lease and separate failed outcomes from pending intent", () => {
+  const f = fixture(), original = fs.renameSync;
+  try {
+    const stopped = spawnSync(process.execPath, ["-e", "process.exit(0)"], { windowsHide: true }); assert.equal(stopped.status, 0);
+    f.write(".nccgs/tasks/history.json", { history: ["failed"], review: "required" });
+    f.write(".nccgs/budgets/history.json", { spentUsd: 9, limitUsd: 12 });
+    for (const code of ["EPERM", "EBUSY"]) {
+      const id = crypto.randomUUID(), relative = `.nccgs/sessions/${id}.lock`;
+      f.write(relative, { schemaVersion: 1, operation: "nccgs-run", host: os.hostname(), pid: stopped.pid, token: crypto.randomUUID(), phase: "spawning", child: null });
+      const before = inventory(f.project), options = { id, expectedSha256: before[relative], confirmStopped: true, reason: "Test-only stopped process with no descendants." };
+      let attempted;
+      fs.renameSync = function(from, to) {
+        if (path.resolve(String(from)) === f.at(relative)) { attempted = path.dirname(to); const error = new Error(`injected ${code}`); error.code = code; throw error; }
+        return original.call(fs, from, to);
+      };
+      try { assert.throws(() => recoverSession(f.project, options), /Session recovery .* failed: injected/); }
+      finally { fs.renameSync = original; }
+      assert.ok(attempted); assert.equal(hash(fs.readFileSync(f.at(relative))), before[relative]);
+      const receipt = path.join(attempted, "receipt.json"), outcome = path.join(attempted, "outcome.json");
+      assert.equal(read(receipt).status, "pending"); assert.equal(read(outcome).status, "failed"); assert.equal(read(outcome).code, code);
+      assert.equal(read(outcome).receiptSha256, hash(fs.readFileSync(receipt))); assert.ok(!fs.existsSync(path.join(attempted, "lease.lock")));
+      for (const [name, digest] of Object.entries(before)) assert.equal(hash(fs.readFileSync(f.at(name))), digest, name);
+      assert.notEqual(f.run("uninstall").status, 0); const failedReceipt = hash(fs.readFileSync(receipt)), failedOutcome = hash(fs.readFileSync(outcome));
+      const retry = recoverSession(f.project, options); assert.equal(retry.status, "SESSION_RECONCILED"); assert.notEqual(path.dirname(f.at(retry.receipt)), attempted);
+      assert.equal(hash(fs.readFileSync(receipt)), failedReceipt); assert.equal(hash(fs.readFileSync(outcome)), failedOutcome);
+    }
+  } finally { fs.renameSync = original; f.dispose(); }
+});
+
+test("recovery audit write failures never claim completion before or after the lease moves", () => {
+  const f = fixture(), originalWrite = fs.writeFileSync, originalRename = fs.renameSync;
+  try {
+    const stopped = spawnSync(process.execPath, ["-e", "process.exit(0)"], { windowsHide: true }); assert.equal(stopped.status, 0);
+    for (const moveFails of [true, false]) {
+      const id = crypto.randomUUID(), relative = `.nccgs/sessions/${id}.lock`;
+      f.write(relative, { schemaVersion: 1, operation: "nccgs-run", host: os.hostname(), pid: stopped.pid, token: crypto.randomUUID(), phase: "spawning", child: null });
+      const digest = hash(fs.readFileSync(f.at(relative))); let directory;
+      fs.writeFileSync = function(file, data, ...args) {
+        if (typeof file === "string" && path.basename(file) === "outcome.json") {
+          directory = path.dirname(file); const error = new Error("injected outcome write failure"); error.code = "EIO"; throw error;
+        }
+        return originalWrite.call(fs, file, data, ...args);
+      };
+      fs.renameSync = function(from, to) {
+        if (moveFails && path.resolve(String(from)) === f.at(relative)) throw new Error("injected move failure");
+        return originalRename.call(fs, from, to);
+      };
+      try { assert.throws(() => recoverSession(f.project, { id, expectedSha256: digest, confirmStopped: true, reason: "Test-only stopped process with no descendants." }), moveFails ? /Outcome could not be recorded/ : /lease was archived, but completion could not be recorded/); }
+      finally { fs.writeFileSync = originalWrite; fs.renameSync = originalRename; }
+      assert.ok(directory); assert.equal(read(path.join(directory, "receipt.json")).status, "pending");
+      assert.ok(!fs.existsSync(path.join(directory, "outcome.json"))); assert.ok(!fs.existsSync(f.at(".nccgs/uninstall.lock")));
+      assert.equal(fs.existsSync(f.at(relative)), moveFails);
+      assert.equal(hash(fs.readFileSync(moveFails ? f.at(relative) : path.join(directory, "lease.lock"))), digest);
+      if (moveFails) assert.notEqual(f.run("uninstall").status, 0);
+    }
+  } finally { fs.writeFileSync = originalWrite; fs.renameSync = originalRename; f.dispose(); }
+});
+
+test("busy empty-directory cleanup returns completed removal, backup id and warnings", () => {
+  const f = fixture(), original = fs.rmdirSync; let injected = false;
+  try {
+    const before = inventory(f.project);
+    fs.rmdirSync = function(file, ...args) {
+      if (!injected && String(file).startsWith(f.at(".claude") + path.sep)) { injected = true; const error = new Error("busy fixture folder"); error.code = "EBUSY"; throw error; }
+      return original.call(fs, file, ...args);
+    };
+    let result; try { result = uninstall(f.project); } finally { fs.rmdirSync = original; }
+    assert.ok(injected); assert.equal(result.status, "UNINSTALLED"); assert.ok(result.id && result.backup);
+    assert.ok(result.warnings.some(warning => warning.includes("EBUSY"))); assert.equal(read(f.at(result.backup)).status, "completed");
+    f.remove("--rollback", result.id); assert.deepEqual(inventory(f.project), before);
+  } finally { fs.rmdirSync = original; f.dispose(); }
+});
+
+test("pre-apply refusal cancels without restoring or stranding launch behind an incomplete receipt", () => {
+  const f = fixture(), original = fs.renameSync; let injected = false;
+  try {
+    const before = inventory(f.project);
+    fs.renameSync = function(from, to) {
+      const value = original.call(fs, from, to);
+      if (!injected && String(to).startsWith(f.at(".nccgs/uninstall") + path.sep) && path.basename(to) === "manifest.json" && read(to).status === "prepared") {
+        injected = true; f.write(".nccgs/sessions/legacy-competitor.lock", { schemaVersion: 1, host: os.hostname(), pid: process.pid, token: crypto.randomUUID(), phase: "owned", child: null });
+      }
+      return value;
+    };
+    try { assert.throws(() => uninstall(f.project), /cancelled before changing files/); } finally { fs.renameSync = original; }
+    assert.ok(injected); const ids = fs.readdirSync(f.at(".nccgs/uninstall")); assert.equal(ids.length, 1);
+    assert.equal(read(f.at(`.nccgs/uninstall/${ids[0]}/manifest.json`)).status, "cancelled");
+    fs.unlinkSync(f.at(".nccgs/sessions/legacy-competitor.lock")); assert.deepEqual(inventory(f.project), before);
+    assert.equal(f.run("run", "--dry-run").status, 0); assert.equal(f.run("agents", "--enable", "nccgs-network-programmer").status, 0);
+  } finally { fs.renameSync = original; f.dispose(); }
+});
+
+test("apply and automatic rollback keep admissions closed without weakening process checks", () => {
+  const f = fixture(), original = fs.unlinkSync; let injected = false;
+  try {
+    const before = inventory(f.project);
+    fs.unlinkSync = function(file, ...args) {
+      const value = original.call(fs, file, ...args);
+      if (!injected && String(file).startsWith(f.at(".claude") + path.sep)) {
+        injected = true;
+        assert.throws(() => acquireInstallationLease(f.project, "nccgs-agents"), /active or unverified/);
+        assert.equal(fs.readdirSync(f.at(".nccgs/sessions")).length, 0);
+        throw new Error("controlled interruption during apply");
+      }
+      return value;
+    };
+    try { assert.throws(() => uninstall(f.project), /all planned files restored/); } finally { fs.unlinkSync = original; }
+    assert.ok(injected); assert.deepEqual(inventory(f.project), before);
+    const lease = acquireInstallationLease(f.project, "nccgs-agents");
+    try { assert.throws(() => uninstall(f.project), /active or unverified process lock/); } finally { lease.release(); }
+    assert.deepEqual(inventory(f.project), before);
+  } finally { fs.unlinkSync = original; f.dispose(); }
+});
+
+test("agents, migration and policy writers refuse active and interrupted uninstall before changes", () => {
+  const f = fixture();
+  try {
+    const id = crypto.randomUUID(), receipt = `.nccgs/uninstall/${id}/manifest.json`;
+    for (const state of ["applying", "failed", "active-lock"]) {
+      if (state === "active-lock") f.write(".nccgs/uninstall.lock", { schemaVersion: 1, host: os.hostname(), pid: process.pid, token: crypto.randomUUID(), phase: "owned", child: null });
+      else f.write(receipt, { status: state });
+      const before = inventory(f.project);
+      assert.notEqual(f.run("agents", "--profile", "astra-claude").status, 0);
+      assert.notEqual(f.run("migrate-execution", "--to", "standalone").status, 0);
+      assert.throws(() => compile(f.project, true), /uninstall/);
+      assert.deepEqual(inventory(f.project), before);
+      fs.unlinkSync(f.at(state === "active-lock" ? ".nccgs/uninstall.lock" : receipt));
+    }
+    assert.equal(f.run("agents", "--profile", "astra-claude").status, 0);
+    assert.equal(f.run("migrate-execution", "--to", "standalone", "--model-profile", "claude-standalone").status, 0);
+    assert.equal(fs.readdirSync(f.at(".nccgs/sessions")).length, 0);
+  } finally { f.dispose(); }
+});
+
+test("junction or symlink in a managed path cannot redirect deletion outside the project", t => {
+  const f = fixture();
+  try {
+    const outside = path.join(f.directory, "outside"); fs.mkdirSync(outside); fs.writeFileSync(path.join(outside, "sentinel.txt"), "untouched");
+    const link = f.at(".claude/nccgs/trap");
+    try { fs.symlinkSync(outside, link, process.platform === "win32" ? "junction" : "dir"); }
+    catch (error) { if (["EPERM", "EACCES"].includes(error.code)) return t.skip("Host does not permit symlinks"); throw error; }
+    const state = read(f.at(".claude/nccgs/install-state.json")); state.files.push({ relative: ".claude/nccgs/trap/sentinel.txt", sha256: hash("untouched") }); f.write(".claude/nccgs/install-state.json", state);
+    assert.notEqual(f.run("uninstall").status, 0); assert.equal(fs.readFileSync(path.join(outside, "sentinel.txt"), "utf8"), "untouched"); fs.unlinkSync(link);
+  } finally { f.dispose(); }
+});