@selesai/code 0.13.13 → 0.13.15

package/dist/skills/unlazy/scripts/gate-lint.mjs

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+// gate-lint.mjs : audit whether a ledger is worth passing.
+// Zero dependencies. Node 16+.
+//
+// The checker decides whether gates were met. It does not ask
+// whether the gates were worth meeting. A gate reading "the entire feature
+// works perfectly" with `CHECK: echo ok` and `EXPECT: ok` passes the checker,
+// the parent re-verification and the hook, because the oracle is real, runs,
+// and returns what it promised. Authoring is the one step in the enforcement
+// hierarchy that is still pure prose discipline, and this lints it.
+//
+// This never executes a CHECK. It reads the ledger and judges its oracles.
+//
+//   node gate-lint.mjs [options] <ledger.md ...>
+//     --strict   treat warnings as failures
+//     --json     machine-readable findings
+//
+// exit codes: 0 no strict failures, 1 strict findings, 2 usage or parse error.
+//
+// Usable as a gate, so a ledger can require its own quality:
+//   CHECK: node scripts/gate-lint.mjs GATES.md
+//   EXPECT: LINT OK
+
+import { readFileSync } from "node:fs";
+import { parseGates } from "./lib/gates.mjs";
+
+const HELP = `usage: gate-lint.mjs [--strict] [--json] <ledger.md ...>
+
+Audit gate quality, not gate completion. Report lexical signs of fixed-output
+oracles, weak expectations, manual measurements, and titles that name an
+activity instead of an outcome. Never executes a CHECK.
+
+exit codes: 0 no strict failures, 1 strict findings, 2 usage or parse error.`;
+
+const KNOWN_OPTIONS = new Set(["--strict", "--json", "--help", "-h"]);
+
+const args = process.argv.slice(2);
+if (!args.length) {
+  console.error(HELP);
+  process.exit(2);
+}
+// `--` makes every following token a filename, including literal files named
+// `--help` and `-h`. Only scan the option prefix for the help flags.
+const positionalIndex = args.indexOf("--");
+const optionPrefix = positionalIndex === -1 ? args : args.slice(0, positionalIndex);
+if (optionPrefix.includes("--help") || optionPrefix.includes("-h")) {
+  console.log(HELP);
+  process.exit(0);
+}
+let strict = false;
+let asJson = false;
+let positional = false;
+const files = [];
+for (const arg of args) {
+  if (!positional && arg === "--") { positional = true; continue; }
+  if (!positional && KNOWN_OPTIONS.has(arg)) {
+    if (arg === "--strict") strict = true;
+    else if (arg === "--json") asJson = true;
+    continue;
+  }
+  if (!positional && arg.startsWith("-")) {
+    console.error("gate-lint: unknown option " + arg);
+    console.error("run gate-lint.mjs --help for usage");
+    process.exit(2);
+  }
+  files.push(arg);
+}
+if (!files.length) {
+  console.error("gate-lint: name at least one ledger file");
+  process.exit(2);
+}
+
+// This is deliberately advisory and whole-command only. Shell text beginning
+// with `echo` can still chain a real verifier, and argv containing EXPECT says
+// nothing about what the called program prints or whether it exits zero.
+const FIXED_OUTPUT_COMMAND = /^\s*(?:(?:echo|printf)(?:\s+[^&|;]*)?|true|:|exit\s+0)\s*$/i;
+// Tokens that appear in failure output as readily as in success output.
+const WEAK_EXPECT = new Set([
+  "ok", "okay", "done", "pass", "passed", "success", "successful", "succeeded",
+  "complete", "completed", "finished", "yes", "true", "0", "good", "fine", "working",
+]);
+// Openings that name an activity rather than an outcome a stranger could judge.
+const ACTIVITY_START = /^(work(ing)? on|improve|enhance|handle|support|ensure|make sure|try|attempt|look (at|into)|investigate|consider|review|refactor|clean ?up|polish|update|tidy|address|deal with|add support)\b/i;
+const findings = [];
+const add = (file, level, gate, rule, message) =>
+  findings.push({ file, level, gate: gate || null, rule, message });
+
+let parseFailed = false;
+
+for (const file of files) {
+  let text;
+  try {
+    text = readFileSync(file, "utf8");
+  } catch (error) {
+    console.error("gate-lint: cannot read " + file + ": " + error.message);
+    process.exit(2);
+  }
+
+  const doc = parseGates(text);
+  if (doc.errors.length) {
+    // A ledger the shared parser rejects cannot be judged on quality.
+    parseFailed = true;
+    for (const error of doc.errors) add(file, "error", null, "parse", error);
+    continue;
+  }
+
+  const live = doc.gates.filter((gate) => !doc.abandoned.has(gate.id));
+  const runnable = live.filter((gate) => gate.check);
+
+  for (const gate of live) {
+    const { id, title, check, expect } = gate;
+
+    if (check && FIXED_OUTPUT_COMMAND.test(check)) {
+      add(file, "warn", id, "tautological-check",
+        'CHECK looks like a fixed-output command: "' + check + '"; use an oracle that observes the named outcome');
+    }
+
+    if (expect && WEAK_EXPECT.has(expect.trim().toLowerCase())) {
+      add(file, "warn", id, "weak-expect",
+        'EXPECT "' + expect + '" also appears in failure output; match a line only success can print');
+    }
+
+    if (gate.expectation && gate.expectation.kind === "regex" && gate.expectation.pathLike) {
+      add(file, "warn", id, "path-read-as-regex",
+        'EXPECT "' + expect + '" looks like a literal path but is read as a regular expression, so its dots are wildcards');
+    }
+
+    if (!check) {
+      add(file, "warn", id, "manual-gate",
+        "no CHECK, so this outcome is judged by hand and its evidence is only as good as the reader");
+      if (/\d/.test(title)) {
+        add(file, "warn", id, "unmeasured-number",
+          'title states a number that nothing measures: "' + title + '"');
+      }
+    }
+
+    if (ACTIVITY_START.test(title)) {
+      add(file, "warn", id, "activity-not-outcome",
+        'names an activity, not an outcome a stranger could judge: "' + title + '"');
+    }
+  }
+
+  if (live.length && runnable.length / live.length < 0.5) {
+    add(file, "warn", null, "mostly-manual",
+      runnable.length + "/" + live.length + " gates are runnable; a mostly manual ledger is prose with checkboxes");
+  }
+}
+
+const errors = findings.filter((f) => f.level === "error");
+const warnings = findings.filter((f) => f.level === "warn");
+const failed = errors.length > 0 || (strict && warnings.length > 0);
+
+if (asJson) {
+  console.log(JSON.stringify({
+    ok: !failed,
+    errors: errors.length,
+    warnings: warnings.length,
+    findings,
+  }, null, 2));
+} else {
+  let lastFile = null;
+  for (const finding of findings) {
+    if (finding.file !== lastFile) {
+      console.log(finding.file);
+      lastFile = finding.file;
+    }
+    const label = finding.level === "error" ? "ERROR" : "WARN ";
+    const who = finding.gate ? finding.gate + ": " : "";
+    console.log("  " + label + " " + who + finding.message + "  [" + finding.rule + "]");
+  }
+  if (!failed) {
+    console.log(warnings.length ? "LINT OK (" + warnings.length + " warning(s))" : "LINT OK");
+  } else {
+    console.log("LINT FINDINGS: " + errors.length + " error(s), " + warnings.length + " warning(s)");
+  }
+}
+
+process.exit(parseFailed ? 2 : failed ? 1 : 0);

package/dist/skills/unlazy/scripts/lib/check-supervisor.mjs

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+// Keep a stable process-group leader alive until CHECK stdio closes.
+// Zero dependencies. Node 16+.
+
+import { spawn } from "node:child_process";
+
+const [shell, command] = process.argv.slice(2);
+if (!shell || command === undefined) {
+  console.error("unlazy-check-supervisor: expected resolved shell and CHECK command");
+  process.exit(2);
+}
+
+let child;
+let spawnError = null;
+try {
+  child = spawn(command, {
+    cwd: process.cwd(),
+    shell,
+    windowsHide: true,
+    env: process.env,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+} catch (error) {
+  console.error("unlazy-check-supervisor: could not start CHECK: " + error.message);
+  process.exit(127);
+}
+
+// Pipe instead of inheriting descriptors directly. Node's `close` event then
+// waits for descendants that inherited the shell's stdout or stderr, keeping
+// this detached supervisor alive as the original process-group identity.
+child.stdout.pipe(process.stdout, { end: false });
+child.stderr.pipe(process.stderr, { end: false });
+child.once("error", (error) => { spawnError = error; });
+child.once("close", (code, signal) => {
+  if (spawnError) {
+    console.error("unlazy-check-supervisor: CHECK spawn failed: " + spawnError.message);
+    process.exitCode = 127;
+    return;
+  }
+  if (Number.isInteger(code)) {
+    process.exitCode = code;
+    return;
+  }
+  console.error("unlazy-check-supervisor: CHECK ended by " + (signal || "unknown signal"));
+  process.exitCode = 1;
+});

package/dist/skills/unlazy/scripts/lib/dispatch.mjs

@@ -0,0 +1,283 @@
+// Atomic host-dispatch wave state. Zero dependencies. Node 16+.
+
+import { existsSync, lstatSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import {
+  appendStatus, scopeRoot, validateScopeId, withFileLock, writeAtomic,
+} from "./gates.mjs";
+
+const SCHEMA = 1;
+const STATES = new Set(["open", "sealed", "complete", "abandoned"]);
+const CONTROL = /[\u0000-\u001f\u007f-\u009f\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/;
+const CONTROL_GLOBAL = /[\u0000-\u001f\u007f-\u009f\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/g;
+
+const record = (value = {}) => Object.assign(Object.create(null), value);
+const emptyState = () => ({ schema: SCHEMA, waves: record() });
+const count = (record) => Object.keys(record).length;
+
+function fail(message) { throw new Error(message); }
+const safeDiagnostic = (value) => String(value).replace(CONTROL_GLOBAL, " ").replace(/\s+/g, " ").trim().slice(0, 500);
+
+function validId(value, label) {
+  if (typeof value !== "string") fail(label + " must be a string");
+  const error = validateScopeId(value, label);
+  if (error) fail(error);
+  return value;
+}
+
+function validHandle(value) {
+  if (typeof value !== "string") fail("handle must be a string");
+  const handle = value.trim();
+  if (!handle || handle.length > 256 || CONTROL.test(handle)) {
+    fail("handle must be printable, nonblank, and at most 256 characters");
+  }
+  return handle;
+}
+
+function validReason(value) {
+  if (typeof value !== "string") fail("reason must be a string");
+  const reason = value.trim();
+  if (!reason || reason.length > 500 || CONTROL.test(reason)) {
+    fail("reason must be printable, nonblank, and at most 500 characters");
+  }
+  return reason;
+}
+
+function validTime(value, label) {
+  if (typeof value !== "string" || !value || Number.isNaN(Date.parse(value))) {
+    fail(label + " must be an ISO timestamp");
+  }
+  return Date.parse(value);
+}
+
+const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+
+function validateState(state) {
+  if (!state || typeof state !== "object" || Array.isArray(state) || state.schema !== SCHEMA ||
+      !state.waves || typeof state.waves !== "object" || Array.isArray(state.waves)) {
+    fail("expected schema 1 with a waves object");
+  }
+  state.waves = record(state.waves);
+
+  for (const [waveId, wave] of Object.entries(state.waves)) {
+    validId(waveId, "wave");
+    if (!wave || typeof wave !== "object" || Array.isArray(wave) || !STATES.has(wave.state) ||
+        !Array.isArray(wave.leaves) || !wave.leaves.length ||
+        !wave.started || typeof wave.started !== "object" || Array.isArray(wave.started) ||
+        !wave.returned || typeof wave.returned !== "object" || Array.isArray(wave.returned)) {
+      fail("wave " + waveId + " has an invalid shape");
+    }
+    wave.started = record(wave.started);
+    wave.returned = record(wave.returned);
+    const openedAt = validTime(wave.openedAt, "wave " + waveId + " openedAt");
+    let abandonedAt = null;
+    if (wave.state === "abandoned") {
+      abandonedAt = validTime(wave.abandonedAt, "wave " + waveId + " abandonedAt");
+      wave.reason = validReason(wave.reason);
+    } else if (hasOwn(wave, "abandonedAt") || hasOwn(wave, "reason")) {
+      fail(wave.state + " wave " + waveId + " contains abandonment metadata");
+    }
+    const leaves = new Set();
+    for (const leaf of wave.leaves) {
+      const id = validId(leaf, "leaf");
+      if (leaves.has(id)) fail("wave " + waveId + " has duplicate leaf " + id);
+      leaves.add(id);
+    }
+
+    const handles = new Set();
+    const startTimes = record();
+    let latestStart = openedAt;
+    for (const [leaf, start] of Object.entries(wave.started)) {
+      if (!leaves.has(leaf)) fail("wave " + waveId + " started unknown leaf " + leaf);
+      if (!start || typeof start !== "object" || Array.isArray(start)) fail("wave " + waveId + " has invalid start for " + leaf);
+      const handle = validHandle(start.handle);
+      if (handles.has(handle)) fail("wave " + waveId + " reuses handle " + handle);
+      handles.add(handle);
+      const at = validTime(start.at, "wave " + waveId + " start time for " + leaf);
+      if (at < openedAt) fail("wave " + waveId + " starts " + leaf + " before it opened");
+      startTimes[leaf] = at;
+      latestStart = Math.max(latestStart, at);
+    }
+
+    const returnTimes = [];
+    for (const [leaf, returned] of Object.entries(wave.returned)) {
+      if (!leaves.has(leaf) || !wave.started[leaf]) fail("wave " + waveId + " returned unstarted leaf " + leaf);
+      if (!returned || typeof returned !== "object" || Array.isArray(returned)) fail("wave " + waveId + " has invalid return for " + leaf);
+      const at = validTime(returned.at, "wave " + waveId + " return time for " + leaf);
+      if (at < startTimes[leaf]) fail("wave " + waveId + " returns " + leaf + " before it started");
+      returnTimes.push(at);
+    }
+
+    const allStarted = count(wave.started) === wave.leaves.length;
+    const allReturned = count(wave.returned) === wave.leaves.length;
+    if (wave.state === "open" && count(wave.returned)) fail("open wave " + waveId + " contains returns");
+    if (wave.state !== "open" && wave.state !== "abandoned" && !allStarted) {
+      fail(wave.state + " wave " + waveId + " is missing starts");
+    }
+    if (wave.state === "complete" && !allReturned) fail("complete wave " + waveId + " is missing returns");
+    if (wave.state === "sealed" && allReturned) fail("sealed wave " + waveId + " should be complete");
+
+    const needsSeal = wave.state === "sealed" || wave.state === "complete" ||
+      (wave.state === "abandoned" && hasOwn(wave, "sealedAt"));
+    let sealedAt = null;
+    if (needsSeal) {
+      sealedAt = validTime(wave.sealedAt, "wave " + waveId + " sealedAt");
+      if (!allStarted) fail(wave.state + " wave " + waveId + " is missing starts after sealing");
+      if (sealedAt < latestStart) fail("wave " + waveId + " was sealed before its final start");
+    } else if (hasOwn(wave, "sealedAt")) {
+      fail(wave.state + " wave " + waveId + " contains seal metadata");
+    }
+
+    if (returnTimes.length) {
+      if (sealedAt === null) fail(wave.state + " wave " + waveId + " contains returns without being sealed");
+      if (returnTimes.some((at) => at < sealedAt)) fail("wave " + waveId + " contains a return before sealing");
+    }
+
+    if (wave.state === "complete") {
+      const completedAt = validTime(wave.completedAt, "wave " + waveId + " completedAt");
+      if (completedAt < Math.max(sealedAt, ...returnTimes)) {
+        fail("wave " + waveId + " completed before its final return");
+      }
+    } else if (hasOwn(wave, "completedAt")) {
+      fail(wave.state + " wave " + waveId + " contains completion metadata");
+    }
+
+    if (wave.state === "abandoned") {
+      if (allReturned) fail("abandoned wave " + waveId + " already has every return and must be complete");
+      if (abandonedAt < Math.max(openedAt, latestStart, sealedAt || openedAt, ...returnTimes)) {
+        fail("wave " + waveId + " was abandoned before its latest transition");
+      }
+    }
+  }
+  return state;
+}
+
+function readState(path) {
+  if (!existsSync(path)) return emptyState();
+  try {
+    if (lstatSync(path).isSymbolicLink()) fail("refusing dispatch state symlink");
+    return validateState(JSON.parse(readFileSync(path, "utf8")));
+  } catch (error) {
+    if (String(error.message).startsWith("invalid dispatch state:")) throw error;
+    throw new Error("invalid dispatch state: " + error.message);
+  }
+}
+
+export function dispatchStatePath(root, scope) {
+  return join(scopeRoot(resolve(root), validId(scope, "scope")), "dispatch.json");
+}
+
+export function getDispatchWave(root, scope, waveId) {
+  const wave = validId(waveId, "wave");
+  const state = readState(dispatchStatePath(root, scope));
+  if (!state.waves[wave]) fail("unknown wave " + wave);
+  return state.waves[wave];
+}
+
+export function dispatchIssues(root, scope) {
+  return dispatchStatus(root, scope).blocking;
+}
+
+export function dispatchStatus(root, scope) {
+  if (!scope) return { blocking: [], abandoned: [], resolved: [], errors: [] };
+  let state;
+  try { state = readState(dispatchStatePath(root, scope)); }
+  catch (error) {
+    const message = safeDiagnostic(error.message);
+    return {
+      blocking: ["dispatch:PARSE invalid dispatch state"],
+      abandoned: [],
+      resolved: ["dispatch:PARSE=invalid"],
+      errors: ["invalid dispatch state for scope " + scope + ": " + message],
+    };
+  }
+  const result = { blocking: [], abandoned: [], resolved: [], errors: [] };
+  for (const [id, wave] of Object.entries(state.waves).sort(([left], [right]) => left.localeCompare(right))) {
+    const started = count(wave.started);
+    const returned = count(wave.returned);
+    result.resolved.push("dispatch:" + id + "=" + wave.state + ";started=" + started + "/" +
+      wave.leaves.length + ";returned=" + returned + "/" + wave.leaves.length);
+    if (wave.state === "complete") continue;
+    if (wave.state === "abandoned") {
+      result.abandoned.push("dispatch:" + id);
+    } else if (wave.state === "open") {
+      result.blocking.push("dispatch:" + id + " open (" + started + "/" + wave.leaves.length + " started)");
+    } else {
+      result.blocking.push("dispatch:" + id + " sealed (" + returned + "/" + wave.leaves.length + " returned)");
+    }
+  }
+  return result;
+}
+
+export async function updateDispatch(root, spec) {
+  const scope = validId(spec.scope, "scope");
+  const waveId = validId(spec.wave, "wave");
+  const path = dispatchStatePath(root, scope);
+  let event = "";
+
+  const wave = await withFileLock(root, path, () => {
+    const state = readState(path);
+    const now = spec.now || new Date().toISOString();
+    validTime(now, "timestamp");
+
+    if (spec.action === "open") {
+      if (state.waves[waveId]) fail("wave " + waveId + " already exists");
+      const leaves = (spec.leaves || []).map((leaf) => validId(leaf, "leaf"));
+      if (!leaves.length) fail("open requires at least one --leaf");
+      const seen = new Set();
+      for (const leaf of leaves) {
+        if (seen.has(leaf)) fail("duplicate leaf " + leaf);
+        seen.add(leaf);
+      }
+      state.waves[waveId] = { leaves, state: "open", openedAt: now, started: record(), returned: record() };
+      event = "dispatch " + waveId + " opened: " + leaves.join(", ");
+    } else {
+      const current = state.waves[waveId];
+      if (!current) fail("unknown wave " + waveId);
+      if (spec.action === "abandon") {
+        if (current.state === "complete" || current.state === "abandoned") {
+          fail("wave " + waveId + " is " + current.state + "; abandon requires an open or sealed wave");
+        }
+        current.state = "abandoned";
+        current.reason = validReason(spec.reason);
+        current.abandonedAt = now;
+        event = "dispatch " + waveId + " abandoned: " + current.reason;
+      } else if (spec.action === "start") {
+        const leaf = validId(spec.leaf, "leaf");
+        const handle = validHandle(spec.handle);
+        if (current.state !== "open") fail("wave " + waveId + " is " + current.state + "; start requires an open wave");
+        if (!current.leaves.includes(leaf)) fail("unknown leaf " + leaf + " in wave " + waveId);
+        if (current.started[leaf]) fail("leaf " + leaf + " already started");
+        const owner = Object.entries(current.started).find(([, start]) => start.handle === handle);
+        if (owner) fail("handle is already assigned to " + owner[0]);
+        current.started[leaf] = { handle, at: now };
+        event = "dispatch " + waveId + " started " + leaf + " as " + handle;
+      } else if (spec.action === "seal") {
+        if (current.state !== "open") fail("wave " + waveId + " is " + current.state + "; seal requires an open wave");
+        const missing = current.leaves.filter((leaf) => !current.started[leaf]);
+        if (missing.length) fail("cannot seal " + waveId + ": missing starts for " + missing.join(", "));
+        current.state = "sealed";
+        current.sealedAt = now;
+        event = "dispatch " + waveId + " sealed";
+      } else if (spec.action === "return") {
+        const leaf = validId(spec.leaf, "leaf");
+        if (current.state !== "sealed") fail("return requires a sealed wave; " + waveId + " is " + current.state);
+        if (!current.leaves.includes(leaf)) fail("unknown leaf " + leaf + " in wave " + waveId);
+        if (current.returned[leaf]) fail("leaf " + leaf + " already returned");
+        current.returned[leaf] = { at: now };
+        if (count(current.returned) === current.leaves.length) {
+          current.state = "complete";
+          current.completedAt = now;
+        }
+        event = "dispatch " + waveId + " returned " + leaf;
+      } else fail("unknown dispatch action " + spec.action);
+    }
+
+    validateState(state);
+    writeAtomic(path, JSON.stringify(state, null, 2) + "\n", { root });
+    return state.waves[waveId];
+  });
+
+  await appendStatus(root, scope, new Date().toISOString() + " " + event);
+  return wave;
+}