@lovrozagar/grunt 0.2.0 → 0.3.1

package/scripts/hooks-union.mjs

@@ -0,0 +1,391 @@
+#!/usr/bin/env node
+/**
+ * Durable driver overlay after `rulesync generate -f hooks`.
+ * Union, never replace: keep Stop / UserPromptSubmit / SubagentStop / mcp deny.
+ *
+ * Claude/Codex native event is UserPromptSubmit (mapped from SoT beforeSubmitPrompt).
+ * Antigravity has neither beforeSubmitPrompt nor subagentStop.
+ * Grok SessionStart stays empty on orchestrate-parent.json.
+ *
+ * Consumer extras (if those scripts exist): SessionStart, check-behind,
+ * validate+sim, platform/** deny. Gemini: SessionStart + AfterTool only;
+ * check-behind / path deny stay caveats.
+ *
+ *   node scripts/hooks-union.mjs           apply then check
+ *   node scripts/hooks-union.mjs --check   keep-list only
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+export const PULL = "node scripts/daily-pull-check.mjs";
+export const RTK = "node scripts/rtk-check.mjs";
+export const FLEET = "node scripts/daily-fleet-check.mjs";
+export const BEHIND = "node scripts/check-behind.mjs --hook";
+export const VALIDATE = "node scripts/validate.mjs --hook";
+export const SIM = "node scripts/sim.mjs --hook";
+export const SCRUB =
+  'node "${GROK_WORKSPACE_ROOT:-${CLAUDE_PROJECT_DIR:-.}}/scripts/scrub-spawn-prompt.mjs"';
+export const GATE_FAT =
+  'node "${GROK_WORKSPACE_ROOT:-${CLAUDE_PROJECT_DIR:-.}}/scripts/gate-fat-tools.mjs"';
+
+export const AUTORUN_NEEDLES = [
+  "daily-pull-check.mjs",
+  "rtk-check.mjs",
+  "daily-fleet-check.mjs",
+  "check-behind.mjs",
+  "validate.mjs",
+  "sim.mjs",
+];
+export const GRUNT_NEEDLES = ["scrub-spawn-prompt.mjs", "gate-fat-tools.mjs"];
+export const PLATFORM_DENY = ["Write(platform/**)", "Edit(platform/**)"];
+export const GIT_HOOKS = [
+  "scripts/git-hooks/pre-commit",
+  "scripts/git-hooks/pre-commit.mjs",
+  "scripts/git-hooks/pre-push",
+  "scripts/git-hooks/pre-push.mjs",
+];
+
+const CAVEAT_BEHIND =
+  "NOT ported: PreToolUse check-behind.mjs. Gemini has no confirmed before-tool deny event.";
+const CAVEAT_PERMS =
+  "NOT ported: Write/Edit(platform/**). Gemini tool controls are name-scoped, not path-scoped.";
+
+export function parseArgv(argv) {
+  const args = Array.isArray(argv) ? argv : [];
+  let check = false;
+  for (const a of args) {
+    if (a === "--check") {
+      check = true;
+      continue;
+    }
+    return { ok: false, error: `unknown flag: ${a}` };
+  }
+  return { ok: true, check };
+}
+
+function isPlainObject(v) {
+  return v != null && typeof v === "object" && !Array.isArray(v);
+}
+
+function resolveRoot(opts) {
+  if (typeof opts === "string") return opts;
+  if (opts && typeof opts.workspaceRoot === "string" && opts.workspaceRoot) {
+    return opts.workspaceRoot;
+  }
+  return process.cwd();
+}
+
+function hasScript(root, name) {
+  return fs.existsSync(path.join(root, "scripts", name));
+}
+
+function hasPlatform(root) {
+  return fs.existsSync(path.join(root, "platform"));
+}
+
+function presentAutorun(root) {
+  return AUTORUN_NEEDLES.filter((n) => hasScript(root, n));
+}
+
+function hookCmd(command, timeout) {
+  const h = { type: "command", command };
+  if (timeout != null) h.timeout = timeout;
+  return h;
+}
+
+function gruntPreToolUse() {
+  return [
+    {
+      matcher: "spawn_subagent|Task|Agent|spawn_agent",
+      hooks: [hookCmd(SCRUB, 5)],
+    },
+    {
+      matcher: "Read|read_file|Grep|grep|Glob|list_dir|Bash|run_terminal_command|Write|Edit|write|search_replace",
+      hooks: [hookCmd(GATE_FAT, 5)],
+    },
+  ];
+}
+
+function commandsIn(group) {
+  if (!isPlainObject(group)) return [];
+  const out = [];
+  if (typeof group.command === "string") out.push(group.command);
+  const hooks = Array.isArray(group.hooks) ? group.hooks : [];
+  for (const h of hooks) {
+    if (isPlainObject(h) && typeof h.command === "string") out.push(h.command);
+  }
+  return out;
+}
+
+function needleOf(group) {
+  for (const c of commandsIn(group)) {
+    const m = String(c).match(/([\w.-]+\.mjs|orchestrate-parent\.js)/);
+    if (m) return m[1];
+  }
+  return commandsIn(group)[0] || JSON.stringify(group);
+}
+
+function upsertGroups(existing, desired) {
+  const prev = Array.isArray(existing) ? existing : [];
+  const desiredNeedles = new Set(desired.map(needleOf));
+  const extras = prev.filter((g) => !desiredNeedles.has(needleOf(g)));
+  return [...desired, ...extras];
+}
+
+function uniq(arr) {
+  const seen = new Set();
+  const out = [];
+  for (const x of arr) {
+    if (seen.has(x)) continue;
+    seen.add(x);
+    out.push(x);
+  }
+  return out;
+}
+
+function loadJson(p) {
+  if (!fs.existsSync(p)) return {};
+  const raw = fs.readFileSync(p, "utf8");
+  if (!String(raw).trim()) return {};
+  const v = JSON.parse(raw);
+  return isPlainObject(v) ? v : {};
+}
+
+function saveJson(p, obj) {
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, `${JSON.stringify(obj, null, 2)}\n`);
+}
+
+function desiredPre(root) {
+  const pre = [];
+  if (hasScript(root, "check-behind.mjs")) {
+    pre.push({ matcher: "Write|Edit", hooks: [hookCmd(BEHIND)] });
+  }
+  pre.push(...gruntPreToolUse());
+  return pre;
+}
+
+function desiredSession(root) {
+  const hooks = [];
+  if (hasScript(root, "daily-pull-check.mjs")) hooks.push(hookCmd(PULL));
+  if (hasScript(root, "rtk-check.mjs")) hooks.push(hookCmd(RTK));
+  if (hasScript(root, "daily-fleet-check.mjs")) hooks.push(hookCmd(FLEET));
+  return hooks.length ? [{ hooks }] : null;
+}
+
+function desiredPost(root) {
+  const hooks = [];
+  if (hasScript(root, "validate.mjs")) hooks.push(hookCmd(VALIDATE));
+  if (hasScript(root, "sim.mjs")) hooks.push(hookCmd(SIM));
+  return hooks.length ? [{ matcher: "Write|Edit", hooks }] : null;
+}
+
+function consumerNamed(root) {
+  const named = {};
+  if (hasScript(root, "daily-pull-check.mjs")) {
+    named["daily-pull-all"] = { event: "SessionStart", command: PULL };
+  }
+  if (hasScript(root, "rtk-check.mjs")) {
+    named["rtk-check"] = { event: "SessionStart", command: RTK };
+  }
+  if (hasScript(root, "daily-fleet-check.mjs")) {
+    named["daily-fleet-digest"] = { event: "SessionStart", command: FLEET };
+  }
+  if (hasScript(root, "check-behind.mjs")) {
+    named["check-behind"] = { event: "PreToolUse", matcher: "Write|Edit", command: BEHIND };
+  }
+  named["scrub-spawn-prompt"] = {
+    event: "PreToolUse",
+    matcher: "spawn_subagent|Task|Agent|spawn_agent",
+    command: SCRUB,
+    timeout: 5,
+  };
+  named["gate-fat-tools"] = {
+    event: "PreToolUse",
+    matcher: "Read|read_file|Grep|grep|Glob|list_dir|Bash|run_terminal_command|Write|Edit|write|search_replace",
+    command: GATE_FAT,
+    timeout: 5,
+  };
+  if (hasScript(root, "validate.mjs")) {
+    named["validate-artifact"] = { event: "PostToolUse", matcher: ".*", command: VALIDATE };
+  }
+  if (hasScript(root, "sim.mjs")) {
+    named["simulate-artifact"] = { event: "PostToolUse", matcher: ".*", command: SIM };
+  }
+  return named;
+}
+
+function applyClaude(root) {
+  const abs = path.join(root, ".claude/settings.json");
+  const live = loadJson(abs);
+  const hooks = isPlainObject(live.hooks) ? { ...live.hooks } : {};
+  hooks.PreToolUse = upsertGroups(hooks.PreToolUse, desiredPre(root));
+  const session = desiredSession(root);
+  if (session) hooks.SessionStart = session;
+  const post = desiredPost(root);
+  if (post) hooks.PostToolUse = upsertGroups(hooks.PostToolUse, post);
+  const permissions = isPlainObject(live.permissions) ? { ...live.permissions } : {};
+  const deny = Array.isArray(permissions.deny) ? [...permissions.deny] : [];
+  permissions.deny = hasPlatform(root) ? uniq([...deny, ...PLATFORM_DENY]) : deny;
+  const next = { ...live, permissions, hooks };
+  saveJson(abs, next);
+}
+
+function applyCodex(root) {
+  const abs = path.join(root, ".codex/hooks.json");
+  const live = loadJson(abs);
+  const nested = isPlainObject(live.hooks);
+  const cur = nested ? { ...live.hooks } : { ...live };
+  cur.PreToolUse = upsertGroups(cur.PreToolUse, desiredPre(root));
+  const session = desiredSession(root);
+  if (session) cur.SessionStart = session;
+  const post = desiredPost(root);
+  if (post) {
+    const codexPost = post.map((g) => ({ hooks: g.hooks }));
+    cur.PostToolUse = upsertGroups(cur.PostToolUse, codexPost);
+  }
+  if (nested) saveJson(abs, { ...live, hooks: cur });
+  else saveJson(abs, { ...live, ...cur });
+}
+
+function applyAgents(root) {
+  const abs = path.join(root, ".agents/hooks.json");
+  const live = loadJson(abs);
+  const rulesync = isPlainObject(live.rulesync) ? { ...live.rulesync } : {};
+  rulesync.PreToolUse = upsertGroups(rulesync.PreToolUse, desiredPre(root));
+  const session = desiredSession(root);
+  if (session) {
+    rulesync.SessionStart = [{ matcher: ".*", hooks: session[0].hooks }];
+  }
+  const post = desiredPost(root);
+  if (post) {
+    rulesync.PostToolUse = [{ matcher: ".*", hooks: post[0].hooks }];
+  }
+  const named = presentAutorun(root).length ? consumerNamed(root) : {};
+  saveJson(abs, { ...live, ...named, rulesync });
+}
+
+function applyGemini(root) {
+  if (!presentAutorun(root).length) return;
+  const abs = path.join(root, ".gemini/settings.json");
+  const live = loadJson(abs);
+  const session = desiredSession(root);
+  const post = desiredPost(root);
+  const hooks = isPlainObject(live.hooks) ? { ...live.hooks } : {};
+  if (session) hooks.SessionStart = session;
+  if (post) {
+    hooks.AfterTool = [{ matcher: "write_file|replace", hooks: post[0].hooks }];
+  }
+  saveJson(abs, {
+    ...live,
+    _caveat_check_behind: CAVEAT_BEHIND,
+    _caveat_permissions: CAVEAT_PERMS,
+    hooks,
+  });
+}
+
+export function applyUnion(opts = {}) {
+  const root = resolveRoot(opts);
+  const check = typeof opts === "object" && opts && opts.check === true;
+  if (check) {
+    const failures = checkUnion({ workspaceRoot: root });
+    if (failures.length) {
+      return { ok: false, check: true, error: `drift: ${failures.join("; ")}`, failures };
+    }
+    return { ok: true, check: true, failures: [] };
+  }
+  applyClaude(root);
+  applyCodex(root);
+  applyAgents(root);
+  applyGemini(root);
+  return { ok: true, check: false };
+}
+
+export function checkUnion(opts = {}) {
+  const root = resolveRoot(opts);
+  const failures = [];
+  const autorun = presentAutorun(root);
+  const files = [
+    {
+      id: "claude",
+      path: ".claude/settings.json",
+      needles: [
+        ...GRUNT_NEEDLES,
+        ...autorun,
+        ...(hasPlatform(root) ? PLATFORM_DENY : []),
+      ],
+    },
+    {
+      id: "codex",
+      path: ".codex/hooks.json",
+      needles: [...GRUNT_NEEDLES, ...autorun],
+    },
+    {
+      id: "agents",
+      path: ".agents/hooks.json",
+      needles: [...GRUNT_NEEDLES, ...autorun],
+    },
+  ];
+  if (autorun.length) {
+    files.push({
+      id: "gemini",
+      path: ".gemini/settings.json",
+      needles: [
+        ...autorun.filter((n) => n !== "check-behind.mjs"),
+        "_caveat_check_behind",
+        "_caveat_permissions",
+      ],
+    });
+  }
+  for (const spec of files) {
+    const p = path.join(root, spec.path);
+    if (!fs.existsSync(p)) {
+      failures.push(`${spec.id}: missing ${spec.path}`);
+      continue;
+    }
+    const text = fs.readFileSync(p, "utf8");
+    for (const n of spec.needles) {
+      if (!text.includes(n)) failures.push(`${spec.id}: missing ${n}`);
+    }
+  }
+  const gitDir = path.join(root, "scripts/git-hooks");
+  if (fs.existsSync(gitDir)) {
+    for (const rel of GIT_HOOKS) {
+      if (!fs.existsSync(path.join(root, rel))) failures.push(`git-hook missing: ${rel}`);
+    }
+  }
+  return failures;
+}
+
+function main() {
+  try {
+    const parsed = parseArgv(process.argv.slice(2));
+    if (!parsed.ok) {
+      process.stderr.write((parsed.error || "invalid argv") + "\n");
+      return 1;
+    }
+    if (!parsed.check) {
+      applyUnion({ workspaceRoot: process.cwd() });
+      process.stdout.write("hooks-union: applied\n");
+    }
+    const failures = checkUnion({ workspaceRoot: process.cwd() });
+    if (failures.length) {
+      for (const f of failures) process.stderr.write(`hooks-union FAIL ${f}\n`);
+      return 1;
+    }
+    process.stdout.write("hooks-union: check ok\n");
+    return 0;
+  } catch (err) {
+    process.stderr.write(String(err && err.message ? err.message : err) + "\n");
+    return 1;
+  }
+}
+
+const thisFile = fileURLToPath(import.meta.url);
+const invoked = process.argv[1] ? path.resolve(process.argv[1]) : "";
+if (invoked === thisFile || import.meta.url === pathToFileURL(invoked).href) {
+  process.exit(main());
+}

package/scripts/persist-handoff.mjs

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+/** Allocate/slugify/validate/write a session handoff under .tmp/grunt/handoffs/. */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import {
+  CREATED_RE,
+  DATETIME_RE,
+  SERIAL_LINE_RE,
+  compactCreatedStamp,
+  ensureGitignore,
+  nextSerial,
+  slugify,
+  utcDateTime,
+} from "./persist-plan.mjs";
+
+export const HANDOFF_DIR = ".tmp/grunt/handoffs";
+/** `{serial}-{slug}-{YYYYMMDDTHHMMSSZ}.md`; stamp required for new writes. */
+export const FILENAME_RE = /^[0-9]+-[a-z0-9]+(-[a-z0-9]+)*-\d{8}T\d{6}Z\.md$/;
+export const STATUS_RE = /^(open|resumed|done)$/;
+export const FILENAME_STAMP_RE = /-\d{8}T\d{6}Z$/;
+export const REQUIRED_H2 = ["Goal", "State", "Context", "Next", "Watch-outs"];
+const BOX_RE = /^( {0,2})(\d+(?:\.\d+){0,2}) \[([ xX])\] (.+)$/;
+const LEAF_ID_RE = /^\d+\.\d+(?:\.\d+)?$/;
+
+export function slugFromFilename(filename) {
+  return String(filename)
+    .replace(/\.md$/, "")
+    .replace(/^[0-9]+-/, "")
+    .replace(FILENAME_STAMP_RE, "");
+}
+
+export function extractHandoffName(content) {
+  const m = String(content).match(/^\s*HANDOFF_NAME:\s*(.+?)\s*$/m);
+  return m ? m[1].trim() : "";
+}
+
+export function stripHandoffName(content) {
+  return String(content).replace(/^\s*HANDOFF_NAME:\s*.+\s*\n/, "");
+}
+
+export function extractH1(content) {
+  const m = String(content).match(/^#\s+(.+?)\s*$/m);
+  return m ? m[1].trim() : "";
+}
+
+function stripFrontmatter(text) {
+  const s = String(text).replace(/^\uFEFF/, "");
+  if (!s.startsWith("---\n")) return s;
+  const end = s.indexOf("\n---\n", 4);
+  if (end === -1) return s;
+  return s.slice(end + 5);
+}
+
+export function injectFrontmatter({ serial, slug, source, body, created }) {
+  const src = String(source || "").slice(0, 120);
+  let rest = stripFrontmatter(body).replace(/^\s+/, "");
+  if (!rest.startsWith("# ")) {
+    rest = `# ${slug}\n\n` + rest;
+  } else {
+    rest = rest.replace(/^# .+/, `# ${slug}`);
+  }
+  return `---
+serial: ${serial}
+name: ${slug}
+status: open
+created: ${created || utcDateTime()}
+source: ${JSON.stringify(src)}
+---
+
+${rest}`;
+}
+
+function sectionBodies(text) {
+  const h2 = [...text.matchAll(/^## (.+)$/gm)].map((m) => ({
+    title: m[1].trim(),
+    index: m.index,
+  }));
+  const bodies = {};
+  for (let i = 0; i < h2.length; i++) {
+    const start = h2[i].index + h2[i].title.length + 4;
+    const end = i + 1 < h2.length ? h2[i + 1].index : text.length;
+    bodies[h2[i].title] = text.slice(start, end);
+  }
+  return { order: h2.map((h) => h.title), bodies };
+}
+
+function parseFrontmatter(text) {
+  if (!text.startsWith("---\n")) return { error: "missing frontmatter" };
+  const end = text.indexOf("\n---\n", 4);
+  if (end === -1) return { error: "unterminated frontmatter" };
+  const raw = text.slice(4, end);
+  const map = {};
+  for (const line of raw.split("\n")) {
+    const m = line.match(/^([a-z]+):(?:\s+(.*))?$/);
+    if (!m) continue;
+    let v = m[2] ?? "";
+    if (v.startsWith('"') && v.endsWith('"')) {
+      try {
+        v = JSON.parse(v);
+      } catch {
+        v = v.slice(1, -1);
+      }
+    }
+    map[m[1]] = v;
+  }
+  return { map, body: text.slice(end + 5) };
+}
+
+export function validateHandoff(filename, text) {
+  const errors = [];
+  if (!FILENAME_RE.test(filename)) errors.push("filename");
+  const fm = parseFrontmatter(text);
+  if (fm.error) {
+    errors.push(fm.error);
+    return errors;
+  }
+  const { map, body } = fm;
+  const serialLine = text.split("\n").find((l) => l.startsWith("serial:"));
+  if (!serialLine || !SERIAL_LINE_RE.test(serialLine)) errors.push("serial line");
+  for (const k of ["serial", "name", "status", "created", "source"]) {
+    if (map[k] == null || map[k] === "") errors.push(`missing ${k}`);
+  }
+  if (map.status && !STATUS_RE.test(map.status)) errors.push("status");
+  if (map.created && !CREATED_RE.test(map.created)) errors.push("created");
+  if (typeof map.source === "string" && map.source.length > 120) {
+    errors.push("source length");
+  }
+  const slug = map.name;
+  if (slug && slugFromFilename(filename) !== slug) errors.push("name/filename slug");
+  if (!body.trim().startsWith(`# ${slug}`)) errors.push("h1 slug");
+  const { order, bodies } = sectionBodies(body);
+  const firstFive = order.slice(0, REQUIRED_H2.length);
+  if (REQUIRED_H2.some((h, i) => firstFive[i] !== h)) errors.push("heading order");
+  const extra = order.filter((h) => !REQUIRED_H2.includes(h));
+  if (extra.length) errors.push("extra h2");
+  const goal = (bodies.Goal || "").trim();
+  const sentences = goal.split(/(?<=[.!?])(?:\s+|$)/).filter((s) => s.trim());
+  if (!goal || sentences.length < 1 || sentences.length > 3) errors.push("goal");
+  for (const h of ["State", "Context", "Watch-outs"]) {
+    const b = (bodies[h] || "").trim();
+    if (!b) errors.push(`${h} empty`);
+    else if (!/^(?:[-*] |\(none\))/m.test(b)) errors.push(`${h} bullets`);
+  }
+  const boxes = [];
+  for (const line of (bodies.Next || "").split("\n")) {
+    const m = line.match(BOX_RE);
+    if (!m) continue;
+    if (m[3] !== " ") errors.push("fresh [x]");
+    boxes.push({ id: m[2], text: m[4] });
+  }
+  const leaves = boxes.filter((b) => LEAF_ID_RE.test(b.id));
+  if (leaves.length < 1) errors.push("no N.M leaf");
+  const phases = boxes.filter((b) => /^\d+$/.test(b.id));
+  for (const p of phases) {
+    if (!boxes.some((b) => b.id.startsWith(p.id + "."))) errors.push(`phase ${p.id} leaf`);
+  }
+  return [...new Set(errors)];
+}
+
+export function persistHandoff({ workspaceRoot, content, source, created } = {}) {
+  const ws = workspaceRoot || process.cwd();
+  const raw = String(content || "");
+  const name =
+    extractHandoffName(raw) || extractH1(stripFrontmatter(stripHandoffName(raw)));
+  const slug = slugify(name);
+  const body = stripHandoffName(raw);
+  const dir = path.join(ws, HANDOFF_DIR);
+  fs.mkdirSync(dir, { recursive: true });
+  const createdAt = created && DATETIME_RE.test(created) ? created : utcDateTime();
+  const stamp = compactCreatedStamp(createdAt);
+  let serial = nextSerial(dir);
+  let filename = `${serial}-${slug}-${stamp}.md`;
+  let dest = path.join(dir, filename);
+  let tries = 0;
+  while (fs.existsSync(dest) && tries < 5) {
+    serial += 1;
+    filename = `${serial}-${slug}-${stamp}.md`;
+    dest = path.join(dir, filename);
+    tries += 1;
+  }
+  if (fs.existsSync(dest)) return { ok: false, error: "serial collision" };
+  const goalMatch = stripFrontmatter(body).match(/## Goal\n([\s\S]*?)\n## /);
+  const sourceText = String(
+    source ||
+      name ||
+      (goalMatch ? goalMatch[1].trim().replace(/\s+/g, " ") : slug),
+  ).slice(0, 120);
+  const full = injectFrontmatter({
+    serial,
+    slug,
+    source: sourceText,
+    body,
+    created: createdAt,
+  });
+  const errors = validateHandoff(filename, full);
+  if (errors.length) return { ok: false, error: errors.join("; "), errors };
+  ensureGitignore(ws);
+  fs.writeFileSync(dest, full);
+  return { ok: true, path: dest, serial, slug, content: full, filename };
+}
+
+function main() {
+  try {
+    const wsIdx = process.argv.indexOf("--workspace");
+    const workspaceRoot = wsIdx >= 0 ? process.argv[wsIdx + 1] : process.cwd();
+    const content = fs.readFileSync(0, "utf8");
+    const result = persistHandoff({ workspaceRoot, content });
+    if (!result.ok) {
+      process.stderr.write((result.error || "invalid handoff") + "\n");
+      return 1;
+    }
+    process.stdout.write(
+      JSON.stringify({
+        serial: result.serial,
+        path: result.path,
+        filename: result.filename,
+      }) + "\n",
+    );
+    return 0;
+  } catch (err) {
+    process.stderr.write(String(err && err.message ? err.message : err) + "\n");
+    return 1;
+  }
+}
+
+const thisFile = fileURLToPath(import.meta.url);
+const invoked = process.argv[1] ? path.resolve(process.argv[1]) : "";
+if (invoked === thisFile || import.meta.url === pathToFileURL(invoked).href) {
+  process.exit(main());
+}