@selesai/code 0.13.7 → 0.13.8

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

@@ -13,8 +13,6 @@ import { claimLeases, releaseLeases, writeAtomic } from "../scripts/lib/gates.mj
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const GATE_CHECK = join(HERE, "..", "scripts", "gate-check.mjs");
-const STOP_HOOK = join(HERE, "..", "scripts", "stop-hook.mjs");
-const INSTALL = join(HERE, "..", "scripts", "install-hooks.mjs");
 const tests = [];
 const test = (name, fn) => tests.push({ name, fn });
 
@@ -107,57 +105,6 @@ test("leases: an explicit release cleans orphaned leases after a scope directory
   } finally { s.cleanup(); }
 });
 
-test("hook: repeated 64-writer bursts are serialized without lost increments", async () => {
-  const s = sandbox();
-  try {
-    s.write("GATES.md", "- [ ] G1: pending\n  EVIDENCE: pending\n");
-    const payload = JSON.stringify({ cwd: s.dir, session_id: "one-session" });
-    for (let round = 1; round <= 3; round++) {
-      rmSync(s.path(".unlazy-hook-state.json"), { force: true });
-      const results = await Promise.all(Array.from({ length: 64 }, () =>
-        run(STOP_HOOK, [], { cwd: s.dir, stdin: payload })));
-      const crashed = results.filter((result) => result.code !== 0);
-      assert(crashed.length === 0,
-        "round " + round + ": " + crashed.length + " hook process(es) failed\n" +
-        [...new Set(crashed.map((result) => "exit=" + result.code + "\n" + result.out.trim()))]
-          .slice(0, 4).join("\n---\n"));
-      const failedUpdates = results
-        .filter((result) => result.out.includes("could not update the serialized hook state"))
-        .map((result) => result.out.trim());
-      assert(failedUpdates.length === 0,
-        "round " + round + ": " + failedUpdates.length + " hook(s) failed open on the state update\n" +
-        [...new Set(failedUpdates)].slice(0, 4).join("\n---\n"));
-      const state = JSON.parse(s.read(".unlazy-hook-state.json"));
-      const sessions = Object.values(state.sessions);
-      assert(sessions.length === 1, "round " + round + ": expected one session, got " + sessions.length);
-      assert(sessions[0].blocks === 64, "round " + round + ": expected 64 blocks, got " + sessions[0].blocks);
-    }
-  } finally { s.cleanup(); }
-});
-
-test("hook: sessions remain isolated and completion/no-gates clears stale state", async () => {
-  const s = sandbox();
-  try {
-    s.write("GATES.md", "- [ ] G1: pending\n  EVIDENCE: pending\n");
-    for (const id of ["alpha", "beta"]) {
-      const payload = JSON.stringify({ cwd: s.dir, session_id: id });
-      await Promise.all(Array.from({ length: 3 }, () => run(STOP_HOOK, [], { cwd: s.dir, stdin: payload })));
-    }
-    let state = JSON.parse(s.read(".unlazy-hook-state.json"));
-    assert(Object.keys(state.sessions).length === 2, "sessions were mixed: " + JSON.stringify(state));
-    assert(Object.values(state.sessions).every((value) => value.blocks === 3), "session counters were not isolated");
-
-    s.write("GATES.md", "- [x] G1: done\n  EVIDENCE: measured\n");
-    await run(STOP_HOOK, [], { cwd: s.dir, stdin: JSON.stringify({ cwd: s.dir, session_id: "alpha" }) });
-    state = JSON.parse(s.read(".unlazy-hook-state.json"));
-    assert(Object.keys(state.sessions).length === 1, "completed alpha state was not cleared");
-
-    rmSync(s.path("GATES.md"));
-    await run(STOP_HOOK, [], { cwd: s.dir, stdin: JSON.stringify({ cwd: s.dir, session_id: "beta" }) });
-    assert(!existsSync(s.path(".unlazy-hook-state.json")), "no-gates path did not clear final state");
-  } finally { s.cleanup(); }
-});
-
 test("atomic writer: predictable pre-created temp links are never followed", async () => {
   if (process.platform === "win32") return;
   const s = sandbox();
@@ -216,141 +163,3 @@ test("status log: a FIFO is rejected without blocking the logger", async () => {
     has(result.out, "cannot append status");
   } finally { s.cleanup(); }
 });
-
-test("installer: malformed settings shapes are refused without mutation", async () => {
-  const fixtures = [
-    "[]\n",
-    JSON.stringify({ hooks: [] }, null, 2) + "\n",
-    JSON.stringify({ hooks: { Stop: {} } }, null, 2) + "\n",
-    JSON.stringify({ hooks: { Stop: [{ hooks: {} }] } }, null, 2) + "\n",
-    JSON.stringify({ hooks: { Stop: [{ hooks: [null] }] } }, null, 2) + "\n",
-  ];
-  for (const fixture of fixtures) {
-    const s = sandbox();
-    try {
-      s.write(".claude/settings.local.json", fixture);
-      const result = await run(INSTALL, [], { cwd: s.dir });
-      assert(result.code === 1, "invalid shape should fail\n" + result.out);
-      assert(s.read(".claude/settings.local.json") === fixture, "invalid settings were mutated");
-    } finally { s.cleanup(); }
-  }
-});
-
-test("installer: a FIFO settings target is rejected without blocking", async () => {
-  if (process.platform === "win32") return;
-  const s = sandbox();
-  try {
-    mkdirSync(s.path(".claude"), { recursive: true });
-    const target = s.path(".claude/settings.local.json");
-    const made = spawnSync("mkfifo", [target], { encoding: "utf8" });
-    assert(made.status === 0, "could not create FIFO fixture: " + made.stderr);
-    const started = Date.now();
-    const result = await run(INSTALL, [], { cwd: s.dir, timeoutMs: 2000 });
-    assert(result.code === 1, "FIFO installer target did not fail closed\n" + result.out);
-    assert(Date.now() - started < 1800, "FIFO installer validation blocked");
-    has(result.out, "Refusing to touch");
-  } finally { s.cleanup(); }
-});
-
-test("installer: uninstall preserves a sibling in the same matcher group and writes a backup", async () => {
-  const s = sandbox();
-  try {
-    const original = JSON.stringify({
-      hooks: {
-        Stop: [{
-          matcher: "",
-          hooks: [
-            { type: "command", command: "node other-tool.mjs" },
-            { type: "command", command: "node /tmp/unlazy/scripts/stop-hook.mjs --unlazy" },
-          ],
-        }],
-      },
-    }, null, 2) + "\n";
-    s.write(".claude/settings.local.json", original);
-    const result = await run(INSTALL, ["--uninstall"], { cwd: s.dir });
-    assert(result.code === 0, result.out);
-    const after = JSON.parse(s.read(".claude/settings.local.json"));
-    assert(after.hooks.Stop.length === 1, "matcher group was removed");
-    assert(after.hooks.Stop[0].matcher === "", "matcher metadata was lost");
-    assert(after.hooks.Stop[0].hooks.length === 1, "wrong handler count");
-    has(after.hooks.Stop[0].hooks[0].command, "other-tool.mjs");
-    assert(s.read(".claude/settings.local.json.unlazy.bak") === original, "backup did not preserve original bytes");
-  } finally { s.cleanup(); }
-});
-
-test("installer: marker substrings do not claim an unrelated stop hook", async () => {
-  const s = sandbox();
-  try {
-    const unrelated = [
-      "node /opt/other/stop-hook.mjs --unlazy-helper",
-      "node /opt/unlazy/scripts/stop-hook.mjs --unlazy-helper",
-      "node " + JSON.stringify(STOP_HOOK) + " --unlazy-helper",
-      "node " + JSON.stringify(STOP_HOOK) + " \"--unlazy-helper\"",
-    ];
-    s.write(".claude/settings.local.json", JSON.stringify({
-      hooks: { Stop: [{ hooks: unrelated.map((command) => ({ type: "command", command, timeout: 20 })) }] },
-    }, null, 2) + "\n");
-    const result = await run(INSTALL, ["--uninstall"], { cwd: s.dir });
-    assert(result.code === 0, result.out);
-    has(result.out, "Nothing to remove");
-    const after = JSON.parse(s.read(".claude/settings.local.json"));
-    assert(after.hooks.Stop[0].hooks.map((hook) => hook.command).join("\n") === unrelated.join("\n"),
-      "unrelated hook was removed");
-  } finally { s.cleanup(); }
-});
-
-test("installer: a matching command with broken managed fields is repaired", async () => {
-  const s = sandbox();
-  try {
-    const installed = await run(INSTALL, [], { cwd: s.dir });
-    assert(installed.code === 0, installed.out);
-    const settings = JSON.parse(s.read(".claude/settings.local.json"));
-    const handler = settings.hooks.Stop[0].hooks[0];
-    handler.type = "prompt";
-    handler.timeout = 1;
-    s.write(".claude/settings.local.json", JSON.stringify(settings, null, 2) + "\n");
-    const repaired = await run(INSTALL, [], { cwd: s.dir });
-    assert(repaired.code === 0, repaired.out);
-    assert(!repaired.out.includes("Already installed"), "broken handler was treated as current");
-    const after = JSON.parse(s.read(".claude/settings.local.json"));
-    const managed = after.hooks.Stop.flatMap((group) => group.hooks)
-      .filter((item) => typeof item.command === "string" && item.command.includes("--unlazy"));
-    assert(managed.length === 1, "repair did not leave exactly one managed handler");
-    assert(managed[0].type === "command", "repair did not restore command type");
-    assert(managed[0].timeout === 20, "repair did not restore timeout");
-  } finally { s.cleanup(); }
-});
-
-test("installer: scope input is validated and local state warning is explicit", async () => {
-  const s = sandbox();
-  try {
-    const invalid = await run(INSTALL, ["--scope", "bad;echo"], { cwd: s.dir });
-    assert(invalid.code === 2, invalid.out);
-    assert(!existsSync(s.path(".claude/settings.local.json")), "invalid scope wrote settings");
-    const good = await run(INSTALL, ["--scope", "api"], { cwd: s.dir });
-    assert(good.code === 0, good.out);
-    has(good.out, ".unlazy/");
-    has(good.out, ".unlazy-hook-state.json");
-    const settings = JSON.parse(s.read(".claude/settings.local.json"));
-    const command = settings.hooks.Stop[0].hooks[0].command;
-    has(command, "--scope api");
-  } finally { s.cleanup(); }
-});
-
-let passed = 0;
-const failures = [];
-for (const item of tests) {
-  try {
-    await item.fn();
-    passed++;
-    console.log("ok   " + item.name);
-  } catch (error) {
-    failures.push(item.name);
-    console.log("FAIL " + item.name + "\n     " + String(error.message).replace(/\n/g, "\n     "));
-  }
-}
-console.log("\n" + passed + "/" + tests.length + " passed");
-if (failures.length) {
-  console.log("failed: " + failures.join(", "));
-  process.exit(1);
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@selesai/code",
-  "version": "0.13.7",
+  "version": "0.13.8",
   "description": "Maintained, extension-first Pi coding agent with built-in workflows, subagents, web research, questions, skills, and an enhanced terminal UI.",
   "type": "module",
   "repository": {

package/dist/skills/unlazy/scripts/install-hooks.mjs

@@ -1,206 +0,0 @@
-#!/usr/bin/env node
-// Install or remove unlazy's Claude Code Stop hook. Zero dependencies. Node 16+.
-
-import {
-  closeSync, constants as fsConstants, existsSync, fstatSync, lstatSync,
-  openSync, readFileSync,
-} from "node:fs";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { homedir } from "node:os";
-import { validateScopeId, writeAtomic } from "./lib/gates.mjs";
-
-const HELP = `usage: install-hooks.mjs [--scope ID] [--shared | --global] [--uninstall]
-
-  default       .claude/settings.local.json in the current project
-  --shared      .claude/settings.json in the current project
-  --global      ~/.claude/settings.json
-  --scope ID    pin the hook to one validated .unlazy/ID pipeline
-  --uninstall   remove only unlazy handlers, preserving sibling handlers`;
-
-function usage(message) {
-  console.error("install-hooks: " + message);
-  console.error("run install-hooks.mjs --help for usage");
-  process.exit(2);
-}
-
-const args = process.argv.slice(2);
-const known = new Set(["--scope", "--shared", "--global", "--uninstall", "--help", "-h"]);
-let scope = null;
-let shared = false;
-let global = false;
-let uninstall = false;
-for (let index = 0; index < args.length; index++) {
-  const arg = args[index];
-  if (!known.has(arg)) usage("unknown option " + arg);
-  if (arg === "--help" || arg === "-h") { console.log(HELP); process.exit(0); }
-  if (arg === "--scope") {
-    if (scope !== null) usage("duplicate --scope");
-    scope = args[++index];
-    if (!scope) usage("--scope needs a pipeline id");
-    continue;
-  }
-  if (arg === "--shared") shared = true;
-  if (arg === "--global") global = true;
-  if (arg === "--uninstall") uninstall = true;
-}
-if (shared && global) usage("--shared and --global are mutually exclusive");
-if (scope) {
-  const error = validateScopeId(scope);
-  if (error) usage(error);
-}
-
-const script = fileURLToPath(new URL("./stop-hook.mjs", import.meta.url));
-const MANAGED_MARKER = "--unlazy-hook-v2";
-const target = global
-  ? join(homedir(), ".claude", "settings.json")
-  : join(process.cwd(), ".claude", shared ? "settings.json" : "settings.local.json");
-const backup = target + ".unlazy.bak";
-
-const isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-let raw = "";
-let settings = {};
-if (existsSync(target)) {
-  let fd = null;
-  try {
-    const noFollow = process.platform === "win32" ? 0 : (fsConstants.O_NOFOLLOW || 0);
-    fd = openSync(target, fsConstants.O_RDONLY | (fsConstants.O_NONBLOCK || 0) | noFollow);
-    const opened = fstatSync(fd);
-    const named = lstatSync(target);
-    if (!opened.isFile() || !named.isFile() || named.isSymbolicLink() ||
-        opened.nlink !== 1 || named.nlink !== 1 ||
-        opened.dev !== named.dev || opened.ino !== named.ino) {
-      throw new Error("target must be one unchanged regular file, not a link or directory");
-    }
-    raw = readFileSync(fd, "utf8");
-    const after = lstatSync(target);
-    if (!after.isFile() || after.isSymbolicLink() || after.nlink !== 1 ||
-        after.dev !== opened.dev || after.ino !== opened.ino) {
-      throw new Error("target changed while it was read");
-    }
-    settings = JSON.parse(raw);
-  } catch (error) {
-    console.error("Refusing to touch " + target + ": " + error.message);
-    process.exit(1);
-  } finally {
-    if (fd !== null) try { closeSync(fd); } catch { /* ignore */ }
-  }
-}
-
-function validateSettings(value) {
-  if (!isObject(value)) return "settings root must be a JSON object";
-  if (value.hooks !== undefined && !isObject(value.hooks)) return "hooks must be a JSON object";
-  if (value.hooks && value.hooks.Stop !== undefined && !Array.isArray(value.hooks.Stop)) return "hooks.Stop must be an array";
-  const groups = (value.hooks && value.hooks.Stop) || [];
-  for (let groupIndex = 0; groupIndex < groups.length; groupIndex++) {
-    const group = groups[groupIndex];
-    if (!isObject(group)) return "hooks.Stop[" + groupIndex + "] must be an object";
-    if (!Array.isArray(group.hooks)) return "hooks.Stop[" + groupIndex + "].hooks must be an array";
-    for (let hookIndex = 0; hookIndex < group.hooks.length; hookIndex++) {
-      if (!isObject(group.hooks[hookIndex])) {
-        return "hooks.Stop[" + groupIndex + "].hooks[" + hookIndex + "] must be an object";
-      }
-    }
-  }
-  return null;
-}
-
-const shapeError = validateSettings(settings);
-if (shapeError) {
-  console.error("Refusing to touch " + target + ": " + shapeError + ".");
-  process.exit(1);
-}
-
-const quote = (value) => {
-  if (process.platform === "win32") return '"' + String(value).replace(/"/g, '""') + '"';
-  return "'" + String(value).replace(/'/g, "'\\''") + "'";
-};
-const command = quote(process.execPath) + " " + quote(script) + " " + MANAGED_MARKER +
-  (scope ? " --scope " + scope : "");
-
-const isOurHandler = (handler) => {
-  if (!isObject(handler) || typeof handler.command !== "string") return false;
-  const value = handler.command;
-  const token = (name) => new RegExp("(?:^|\\s)" + name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "(?=\\s|$)").test(value);
-  // An exact foreign --unlazy-* option is positive evidence that this is not
-  // our legacy entry, even when it happens to invoke the same script path.
-  const foreignUnlazyOption = value.split(/\s+/).some((part) => {
-    const quoted = part.length >= 2 &&
-      ((part[0] === '"' && part[part.length - 1] === '"') ||
-       (part[0] === "'" && part[part.length - 1] === "'"));
-    const option = quoted ? part.slice(1, -1) : part;
-    return option.startsWith("--unlazy-") && option !== MANAGED_MARKER;
-  });
-  if (foreignUnlazyOption) return false;
-  if (token(MANAGED_MARKER)) return true;
-  // Migrate v2.0/v2.1 handlers only when both the exact old marker and the
-  // packaged scripts/stop-hook.mjs shape are present. Substrings such as
-  // --unlazy-helper and unrelated same-named scripts are never ownership.
-  const packagedStopHook = /(?:^|[\s"'])[^\s"']*[\\/]scripts[\\/]stop-hook\.mjs(?=$|[\s"'])/i.test(value);
-  const namedLegacyInstall = /[\\/]unlazy[\\/]scripts[\\/]stop-hook\.mjs(?=$|[\s"'])/i.test(value);
-  // Upstream v2.0 shipped before any marker and is recognizable only at its
-  // conventional Claude skill location. Keep that narrow compatibility path,
-  // while marker-era moved installs require the exact standalone old token.
-  const conventionalV2Path = /[\\/]\.claude[\\/]skills[\\/]unlazy[\\/]scripts[\\/]stop-hook\.mjs(?=$|[\s"'])/i.test(value);
-  return value.includes(script) || conventionalV2Path ||
-    (token("--unlazy") && (namedLegacyInstall || packagedStopHook));
-};
-
-const originalGroups = (settings.hooks && settings.hooks.Stop) || [];
-let removed = 0;
-const keptGroups = [];
-for (const group of originalGroups) {
-  const hooks = group.hooks.filter((handler) => {
-    if (!isOurHandler(handler)) return true;
-    removed++;
-    return false;
-  });
-  if (hooks.length) keptGroups.push({ ...group, hooks });
-}
-
-function nextSettings(groups) {
-  const result = { ...settings };
-  const hooks = { ...(settings.hooks || {}) };
-  if (groups.length) hooks.Stop = groups;
-  else delete hooks.Stop;
-  if (Object.keys(hooks).length) result.hooks = hooks;
-  else delete result.hooks;
-  return result;
-}
-
-function persist(value) {
-  try {
-    if (raw) writeAtomic(backup, raw);
-    writeAtomic(target, JSON.stringify(value, null, 2) + "\n");
-  } catch (error) {
-    console.error("Could not update " + target + ": " + error.message);
-    process.exit(1);
-  }
-}
-
-if (uninstall) {
-  if (!removed) {
-    console.log("Nothing to remove: no unlazy Stop hook found in " + target);
-    process.exit(0);
-  }
-  persist(nextSettings(keptGroups));
-  console.log("Removed unlazy Stop hook (" + removed + " handler(s)) from " + target + ". Sibling handlers were preserved.");
-  process.exit(0);
-}
-
-const alreadyCurrent = removed === 1 && originalGroups.some((group) =>
-  group.hooks.some((handler) => isOurHandler(handler) && handler.command === command &&
-    handler.type === "command" && handler.timeout === 20));
-if (alreadyCurrent) {
-  console.log("Already installed in " + target + " (idempotent, nothing changed).");
-  process.exit(0);
-}
-
-const entry = { hooks: [{ type: "command", command, timeout: 20 }] };
-persist(nextSettings([...keptGroups, entry]));
-console.log("Installed unlazy Stop hook into " + target + "\n" +
-  "  command: " + command + "\n" +
-  "  scope:   " + (scope ? scope : "resolved per session/pipeline") + "\n" +
-  "  backup:  " + (raw ? backup : "not needed for a new file") + "\n" +
-  "  note:    keep .unlazy/ and .unlazy-hook-state.json ignored; they are local coordination state." +
-  (shared ? "\n  warning: shared settings contain this machine's absolute Node and skill paths." : ""));

package/dist/skills/unlazy/scripts/stop-hook.mjs

@@ -1,174 +0,0 @@
-#!/usr/bin/env node
-// Claude Code Stop hook for one unlazy pipeline. Zero dependencies. Node 16+.
-
-import { existsSync, readFileSync, unlinkSync } from "node:fs";
-import { resolve } from "node:path";
-import {
-  UNLAZY_DIR, gateState, hookStatePath, parseGates, qualify, resolveTarget,
-  sha256, validateScopeId, withFileLock, writeAtomic,
-} from "./lib/gates.mjs";
-import { dispatchStatus } from "./lib/dispatch.mjs";
-
-const MAX_BLOCKS = 6;
-const safeHostText = (value, max = 500) => String(value)
-  .replace(/[\u0000-\u001f\u007f-\u009f\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/g, " ")
-  .replace(/\s+/g, " ")
-  .trim()
-  .slice(0, max);
-
-function normalizeHookState(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value) || value.schema !== 1 ||
-      !value.sessions || typeof value.sessions !== "object" || Array.isArray(value.sessions)) {
-    return { schema: 1, sessions: {} };
-  }
-  const sessions = {};
-  for (const [key, current] of Object.entries(value.sessions)) {
-    if (!/^[a-f0-9]{24}$/.test(key) || !current || typeof current !== "object" || Array.isArray(current) ||
-        !/^[a-f0-9]{24}$/.test(String(current.hash || "")) ||
-        !Number.isInteger(current.blocks) || current.blocks < 0 ||
-        typeof current.updatedAt !== "string" || Number.isNaN(Date.parse(current.updatedAt))) continue;
-    sessions[key] = current;
-  }
-  return { schema: 1, sessions };
-}
-
-const args = process.argv.slice(2);
-const scopeIndex = args.indexOf("--scope");
-const scopeArg = scopeIndex === -1 ? null : args[scopeIndex + 1];
-
-const allow = (message) => {
-  if (message) console.log(JSON.stringify({ systemMessage: message }));
-  process.exit(0);
-};
-
-if (scopeIndex !== -1 && (!scopeArg || validateScopeId(scopeArg))) {
-  allow("unlazy: installed hook has an invalid --scope value; not blocking.");
-}
-
-let payload = {};
-try { payload = JSON.parse(readFileSync(0, "utf8") || "{}"); }
-catch { allow(null); }
-
-const root = resolve(typeof payload.cwd === "string" && payload.cwd ? payload.cwd : process.cwd());
-const sessionId = payload.session_id || payload.sessionId || "anonymous";
-const sessionKey = sha256(String(sessionId)).slice(0, 24);
-const target = resolveTarget({ root, scope: scopeArg, sessionId });
-
-if (target.ambiguous) {
-  allow("unlazy: " + target.ambiguous.length + " pipelines under " + UNLAZY_DIR +
-    "/ (" + target.ambiguous.join(", ") + ") and none bound to this session; not blocking.");
-}
-if (target.error && !target.ambiguous) allow("unlazy: " + safeHostText(target.error) + "; not blocking.");
-
-const statePath = hookStatePath(root, target.scope);
-
-async function clearSessionState() {
-  if (!existsSync(statePath)) return;
-  try {
-    await withFileLock(root, statePath, () => {
-      let state = { schema: 1, sessions: {} };
-      try { state = JSON.parse(readFileSync(statePath, "utf8")); } catch { /* replace invalid local state */ }
-      state = normalizeHookState(state);
-      delete state.sessions[sessionKey];
-      if (!Object.keys(state.sessions).length) {
-        try { unlinkSync(statePath); } catch { /* already absent */ }
-      } else writeAtomic(statePath, JSON.stringify(state, null, 2) + "\n", { root });
-    }, { timeoutMs: 10000 });
-  } catch {
-    // State cleanup must never trap a session after the gates are complete.
-  }
-}
-
-const dispatch = dispatchStatus(root, target.scope);
-
-if (!target.files.length && !dispatch.blocking.length && !dispatch.abandoned.length) {
-  await clearSessionState();
-  allow(null);
-}
-
-const unmet = [...dispatch.blocking];
-const invalid = [];
-const handoffs = [...dispatch.abandoned];
-const handoffMessage = () => {
-  if (!handoffs.length) return "";
-  const shown = handoffs.slice(0, 5).join(", ") +
-    (handoffs.length > 5 ? ", +" + (handoffs.length - 5) + " more" : "");
-  return " HANDOFF REQUIRED: " + handoffs.length + " abandoned item(s): " + safeHostText(shown) + ".";
-};
-// The loop guard compares resolved gate state between stops, not raw bytes.
-// Byte comparison counted any edit as progress: a comment, a reflowed line, or
-// the checker rewriting an evidence line with a fresh PATH hash. That rearmed
-// the guard indefinitely, so the six-block release could only ever fire for an
-// agent doing literally nothing, which is the one case least in need of it.
-// Dispatch issue strings encode only canonical state and counts, not raw JSON
-// bytes or timestamps, so metadata-only edits do not reset the same guard.
-const resolved = [...dispatch.resolved];
-for (const file of [...target.files].sort()) {
-  let text;
-  try { text = readFileSync(file, "utf8"); }
-  catch (error) {
-    invalid.push(qualify(file, "PARSE") + " unreadable: " + safeHostText(error.message));
-    resolved.push(qualify(file, "PARSE") + "=unreadable");
-    continue;
-  }
-  const doc = parseGates(text);
-  if (doc.errors.length) {
-    invalid.push(qualify(file, "PARSE") + " " + doc.errors.slice(0, 2).map((error) => safeHostText(error)).join("; "));
-    // Record only that the ledger is invalid. Diagnostic text carries line
-    // numbers, which shift on an unrelated edit and would restore byte coupling.
-    resolved.push(qualify(file, "PARSE") + "=invalid");
-    continue;
-  }
-  for (const gate of doc.gates) {
-    const state = gateState(gate, doc.abandoned);
-    resolved.push(qualify(file, gate.id) + "=" + state);
-    if (state === "unmet" || state === "unmet-no-evidence") unmet.push(qualify(file, gate.id));
-    else if (state === "abandoned") handoffs.push(qualify(file, gate.id));
-  }
-}
-
-if (!unmet.length && !invalid.length) {
-  await clearSessionState();
-  if (!handoffs.length) allow(null);
-  const where = target.scope ? " [scope " + target.scope + "]" : "";
-  allow("unlazy" + where + ":" + handoffMessage());
-}
-
-const progressHash = sha256(resolved.sort().join("\0")).slice(0, 24);
-let sessionState;
-try {
-  sessionState = await withFileLock(root, statePath, () => {
-    let state = { schema: 1, sessions: {} };
-    try { state = JSON.parse(readFileSync(statePath, "utf8")); } catch { /* new or corrupt local state */ }
-    state = normalizeHookState(state);
-    let current = state.sessions[sessionKey];
-    if (!current || current.hash !== progressHash) current = { hash: progressHash, blocks: 0 };
-    current.blocks += 1;
-    current.updatedAt = new Date().toISOString();
-    state.sessions[sessionKey] = current;
-    // Bound abandoned session debris without mixing counters between sessions.
-    const entries = Object.entries(state.sessions).sort((a, b) => String(b[1].updatedAt).localeCompare(String(a[1].updatedAt)));
-    state.sessions = Object.fromEntries(entries.slice(0, 64));
-    writeAtomic(statePath, JSON.stringify(state, null, 2) + "\n", { root });
-    return current;
-  }, { timeoutMs: 10000 });
-} catch (error) {
-  allow("unlazy: could not update the serialized hook state (" + safeHostText(error.message) + "); not blocking to avoid a trap.");
-}
-
-const where = target.scope ? " [scope " + target.scope + "]" : "";
-const outstanding = [...invalid, ...unmet].map((item) => safeHostText(item));
-if (sessionState.blocks > MAX_BLOCKS) {
-  allow("unlazy: releasing after " + MAX_BLOCKS + " blocks without gate progress" + where +
-    "; " + outstanding.length + " item(s) remain (" + outstanding.slice(0, 4).join(", ") + ")." +
-    handoffMessage());
-}
-
-const list = outstanding.slice(0, 5).join(", ") + (outstanding.length > 5 ? ", +" + (outstanding.length - 5) + " more" : "");
-console.log(JSON.stringify({
-  decision: "block",
-  reason: "unlazy" + where + ": " + outstanding.length + " gate/ledger/dispatch item(s) need work: " + list +
-    ". Run gate-check.mjs --status to inspect without execution. To run inherited CHECK lines, inspect them and use --approve. " +
-    "Use ABANDON: <id> <non-blank reason> only when a gate is genuinely impossible." + handoffMessage(),
-}));
-process.exit(0);