@lovrozagar/grunt 0.4.2 → 0.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lovrozagar/grunt",
-  "version": "0.4.2",
+  "version": "0.5.2",
   "description": "Multi-agent orchestrator SoT — deep-merge rulesync trees, product scripts, and generate pipeline into a consumer repo",
   "keywords": [
     "agents",
@@ -27,13 +27,17 @@
     "scripts/check-globals.mjs",
     "scripts/emit-agent-shell-tools.mjs",
     "scripts/emit-gemini.mjs",
+    "scripts/emit-maps.mjs",
     "scripts/guarded-roots.mjs",
     "scripts/emit-mcp-policy.mjs",
     "scripts/gate-fat-tools.mjs",
     "scripts/hooks-union.mjs",
+    "scripts/pipeline.mjs",
     "scripts/grunt-job.mjs",
+    "scripts/grunt-config.mjs",
     "scripts/parse-need.mjs",
     "scripts/persist-handoff.mjs",
+    "scripts/persist-tmp.mjs",
     "scripts/persist-plan.mjs",
     "scripts/purge-global-mcps.mjs",
     "scripts/scrub-spawn-prompt.mjs",
@@ -41,6 +45,7 @@
     "scripts/sync-global-settings.mjs",
     "scripts/browser.mjs",
     "scripts/doctor.mjs",
+    "scripts/skill-conflicts.mjs",
     "scripts/scrub-text",
     ".rulesync",
     ".grok",
@@ -63,11 +68,8 @@
   },
   "scripts": {
     "rulesync:generate": "node ./scripts/guarded-roots.mjs generate",
-    "rulesync:generate:raw": "rulesync generate -t claudecode,codexcli,antigravity-cli,grokcli -f rules,subagents,skills && rulesync generate -t claudecode,codexcli,antigravity-cli -f hooks && node scripts/emit-mcp-policy.mjs && node scripts/emit-gemini.mjs && node scripts/emit-agent-shell-tools.mjs && node scripts/hooks-union.mjs",
     "rulesync:watch": "node ./scripts/guarded-roots.mjs watch",
-    "rulesync:watch:raw": "node scripts/emit-mcp-policy.mjs && node scripts/emit-gemini.mjs && node scripts/emit-agent-shell-tools.mjs && rulesync generate -t claudecode,codexcli,antigravity-cli,grokcli -f rules,subagents,skills --watch",
     "rulesync:check": "node ./scripts/guarded-roots.mjs check",
-    "rulesync:check:raw": "rulesync generate -t claudecode,codexcli,antigravity-cli,grokcli -f rules,skills --check && rulesync generate -t codexcli,antigravity-cli,grokcli -f subagents --check && rulesync generate -t claudecode,codexcli,antigravity-cli -f hooks --check && node scripts/emit-mcp-policy.mjs --check && node scripts/emit-gemini.mjs --check && node scripts/emit-agent-shell-tools.mjs --check && node scripts/check-globals.mjs && node scripts/hooks-union.mjs --check",
     "hooks:union": "node scripts/hooks-union.mjs",
     "hooks:check": "node scripts/hooks-union.mjs --check",
     "doctor": "node ./scripts/doctor.mjs",
@@ -77,6 +79,11 @@
     "sync:globals:apply": "node scripts/sync-global-settings.mjs --apply",
     "purge:global-mcps": "node scripts/purge-global-mcps.mjs",
     "purge:global-mcps:apply": "node scripts/purge-global-mcps.mjs --apply",
+    "antigravity": "antigravity --dangerously-skip-permissions",
+    "claude": "claude --dangerously-skip-permissions",
+    "codex": "codex --dangerously-bypass-approvals-and-sandbox",
+    "gemini": "gemini --yolo",
+    "grok": "grok --yolo",
     "test": "vitest run --coverage"
   },
   "devDependencies": {

package/scripts/doctor.mjs

@@ -4,6 +4,12 @@ import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import {
+  PACKAGED_SKILLS_REL,
+  WORKSPACE_SKILLS_REL,
+  findSkillContentConflicts,
+  formatSkillConflictWarn,
+} from "./skill-conflicts.mjs";
 
 export const CHROMIUM_BINS = [
   "chromium",
@@ -23,6 +29,12 @@ const RTK_DOCS = "https://www.rtk-ai.app/docs/getting-started/installation/";
 const LP_INSTALL_SH = "curl -fsSL https://pkg.lightpanda.io/install.sh | bash";
 const RULESYNC_SCHEMA = "rulesync schema doctor: npm run rulesync:doctor";
 const REQUIRED = ["node", "npm", "git", "rtk", "rulesync", "lightpanda", "chromium"];
+export const REQUIRED_MAP_FILES = [
+  { name: "INDEX.md", rel: ".rulesync/reference/INDEX.md" },
+  { name: "skills-map.md", rel: ".rulesync/reference/skills-map.md" },
+  { name: "refs-map.md", rel: ".rulesync/reference/refs-map.md" },
+  { name: "law.md", rel: ".rulesync/reference/law.md" },
+];
 
 export function nodeMajor(version) {
   const m = String(version || "").match(/(\d+)/);
@@ -158,12 +170,35 @@ export function installHints(id, platform = process.platform) {
 }
 
 function row(name, status, extra = "") {
-  const a = String(name).padEnd(10);
+  const a = String(name).padEnd(14);
   const b = String(status).padEnd(18);
   const c = extra ? String(extra).trim() : "";
   return c ? `${a} ${b} ${c}` : `${a} ${b}`;
 }
 
+function mapFilePresent(cwd, rel) {
+  try {
+    return fs.statSync(path.join(cwd, rel)).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function isDir(abs) {
+  try {
+    return fs.statSync(abs).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+/** Product SoT: reference tree or skills (emit-maps in play). No .rulesync / no those trees → bins-only. */
+export function mapsRequired(cwd) {
+  const rs = path.join(cwd || "", ".rulesync");
+  if (!isDir(rs)) return false;
+  return isDir(path.join(rs, "reference")) || isDir(path.join(rs, "skills"));
+}
+
 export function runDoctor({
   cwd = process.cwd(),
   pathEnv = process.env.PATH,
@@ -232,10 +267,37 @@ export function runDoctor({
     }
   }
 
+  const missingMaps = [];
+  if (mapsRequired(cwd)) {
+    for (const f of REQUIRED_MAP_FILES) {
+      if (mapFilePresent(cwd, f.rel)) {
+        lines.push(row(f.name, "ok", f.rel));
+      } else {
+        missingMaps.push(f);
+        lines.push(row(f.name, "missing", f.rel));
+      }
+    }
+    if (missingMaps.length) {
+      lines.push(`maps missing: ${missingMaps.map((f) => f.name).join(", ")}`);
+    }
+  }
+
+  const skillConflicts = findSkillContentConflicts({
+    workspaceSkillsDir: path.join(cwd || "", WORKSPACE_SKILLS_REL),
+    packagedSkillsDir: path.join(cwd || "", PACKAGED_SKILLS_REL),
+  });
+  if (skillConflicts.length) {
+    lines.push("");
+    lines.push("skill conflicts (warn; re-init overwrites grunt-owned names):");
+    for (const c of skillConflicts) {
+      lines.push(formatSkillConflictWarn(c.name));
+    }
+  }
+
   lines.push("");
   lines.push(RULESYNC_SCHEMA);
   const stdout = `${lines.join("\n")}\n`;
-  return { code: missingRequired.length ? 1 : 0, stdout, stderr: "" };
+  return { code: missingRequired.length || missingMaps.length ? 1 : 0, stdout, stderr: "" };
 }
 
 function main() {

package/scripts/emit-maps.mjs

@@ -0,0 +1,422 @@
+#!/usr/bin/env node
+/** Emit INDEX (aggregate) + skills-map/refs-map slices from one skills+refs scan; law.md is a hand slice. */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { splitFrontmatter } from "./emit-agent-shell-tools.mjs";
+
+export const INDEX_REL = ".rulesync/reference/INDEX.md";
+export const SKILLS_MAP_REL = ".rulesync/reference/skills-map.md";
+export const REFS_MAP_REL = ".rulesync/reference/refs-map.md";
+export const LAW_REL = ".rulesync/reference/law.md";
+const SKILLS_REL = ".rulesync/skills";
+const REFS_REL = ".rulesync/reference";
+const PACKAGED_SKILLS_REL = path.join("node_modules", "@lovrozagar", "grunt", ".rulesync", "skills");
+const BANNER = "<!-- Generated by emit-maps.mjs. Do not hand-edit. -->\n";
+const DESC_MAX = 120;
+const HUGE_BYTES = 512 * 1024;
+const SKIP_REF_NAMES = new Set(["skills-map.md", "refs-map.md", "INDEX.md"]);
+
+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 unquoteYaml(raw) {
+  const s = String(raw).trim();
+  if (s.length >= 2 && s[0] === '"' && s[s.length - 1] === '"') {
+    try {
+      return JSON.parse(s);
+    } catch {
+      return s.slice(1, -1);
+    }
+  }
+  if (s.length >= 2 && s[0] === "'" && s[s.length - 1] === "'") {
+    return s.slice(1, -1).replace(/''/g, "'");
+  }
+  return s;
+}
+
+function parseFlowSeq(s) {
+  const t = String(s).trim();
+  if (!t.startsWith("[") || !t.endsWith("]")) return null;
+  const inner = t.slice(1, -1).trim();
+  if (!inner) return [];
+  return inner.split(",").map((x) => unquoteYaml(x.trim())).filter((x) => x !== "");
+}
+
+function indentOf(line) {
+  const m = String(line).match(/^[ \t]*/);
+  return m ? m[0].length : 0;
+}
+
+function parseYamlDoc(fm) {
+  const lines = String(fm).split(/\r?\n/);
+  let i = 0;
+  function parseBlock(baseIndent) {
+    const obj = {};
+    while (i < lines.length) {
+      const line = lines[i];
+      if (!line.trim() || /^\s*#/.test(line)) {
+        i += 1;
+        continue;
+      }
+      const ind = indentOf(line);
+      if (ind < baseIndent) break;
+      if (baseIndent > 0 && ind > baseIndent) break;
+      const trimmed = line.trim();
+      const km = trimmed.match(/^([^:#\s][^:]*):\s*(.*?)\s*$/);
+      if (!km) {
+        i += 1;
+        continue;
+      }
+      const key = km[1].trim();
+      const val = km[2];
+      i += 1;
+      if (val === ">" || val === "|") {
+        const parts = [];
+        while (i < lines.length) {
+          const n = lines[i];
+          if (!n.trim()) {
+            parts.push("");
+            i += 1;
+            continue;
+          }
+          if (indentOf(n) <= ind) break;
+          parts.push(n.trim());
+          i += 1;
+        }
+        obj[key] = parts.filter(Boolean).join(" ");
+        continue;
+      }
+      if (val === "") {
+        if (i < lines.length && indentOf(lines[i]) > ind) {
+          const next = lines[i].trim();
+          if (next.startsWith("- ")) {
+            const arr = [];
+            while (i < lines.length && indentOf(lines[i]) > ind && lines[i].trim().startsWith("- ")) {
+              arr.push(unquoteYaml(lines[i].trim().replace(/^- /, "")));
+              i += 1;
+            }
+            obj[key] = arr;
+          } else {
+            obj[key] = parseBlock(indentOf(lines[i]));
+          }
+        } else {
+          obj[key] = {};
+        }
+        continue;
+      }
+      const seq = parseFlowSeq(val);
+      obj[key] = seq != null ? seq : unquoteYaml(val);
+    }
+    return obj;
+  }
+  return parseBlock(0);
+}
+
+function oneLine(s, max = DESC_MAX) {
+  const t = String(s ?? "").replace(/\s+/g, " ").trim();
+  if (t.length <= max) return t;
+  return `${t.slice(0, Math.max(0, max - 1)).trimEnd()}…`;
+}
+
+function cell(s) {
+  return oneLine(s).replace(/\|/g, "\\|");
+}
+
+function readText(abs) {
+  try {
+    return fs.readFileSync(abs, "utf8");
+  } catch (err) {
+    if (err && err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+
+function lstat(abs) {
+  try {
+    return fs.lstatSync(abs);
+  } catch (err) {
+    if (err && err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+
+function posixRel(...parts) {
+  return parts.join("/").replace(/\\/g, "/");
+}
+
+function mapRefs(parsed) {
+  if (Array.isArray(parsed["map.refs"])) return parsed["map.refs"].map(String);
+  if (typeof parsed["map.refs"] === "string" && parsed["map.refs"]) return [parsed["map.refs"]];
+  const m = parsed.map;
+  if (m && Array.isArray(m.refs)) return m.refs.map(String);
+  if (m && typeof m.refs === "string" && m.refs) return [m.refs];
+  return [];
+}
+
+function scalarTask(v) {
+  return typeof v === "string" && v !== "" ? v : "";
+}
+
+function mapTask(parsed) {
+  const dotted = scalarTask(parsed["map.task"]);
+  if (dotted) return dotted;
+  const m = parsed.map;
+  if (m && typeof m === "object" && !Array.isArray(m)) return scalarTask(m.task);
+  return "";
+}
+
+function tagsOf(parsed) {
+  if (Array.isArray(parsed.tags)) return parsed.tags.map(String);
+  if (typeof parsed.tags === "string" && parsed.tags) {
+    const seq = parseFlowSeq(parsed.tags);
+    if (seq) return seq.map(String);
+    return [parsed.tags];
+  }
+  return [];
+}
+
+function firstH1(body) {
+  const m = String(body).match(/^#\s+(.+?)\s*$/m);
+  return m ? m[1].replace(/\s+#+\s*$/, "").trim() : "";
+}
+
+function firstSummary(body) {
+  const lines = String(body).split(/\r?\n/);
+  let pastH1 = false;
+  for (const line of lines) {
+    const t = line.trim();
+    if (!pastH1) {
+      if (/^#\s+/.test(t)) pastH1 = true;
+      continue;
+    }
+    if (!t) continue;
+    if (/^#/.test(t) || /^```/.test(t) || /^<!--/.test(t) || /^---/.test(t)) continue;
+    return oneLine(t);
+  }
+  return "";
+}
+
+function parseMarkdown(raw) {
+  const src = String(raw ?? "");
+  const split = splitFrontmatter(src);
+  if (!split.ok) return { parsed: {}, body: src };
+  return { parsed: parseYamlDoc(split.fm), body: split.body };
+}
+
+function listSkillDirs(ws) {
+  const root = path.join(ws, SKILLS_REL);
+  let names;
+  try {
+    names = fs.readdirSync(root, { withFileTypes: true });
+  } catch (err) {
+    if (err && err.code === "ENOENT") return [];
+    throw err;
+  }
+  const out = [];
+  for (const ent of names) {
+    if (!ent.isDirectory() || ent.name.startsWith(".")) continue;
+    const skillAbs = path.join(root, ent.name, "SKILL.md");
+    const st = lstat(skillAbs);
+    if (st && st.isFile()) out.push({ name: ent.name, abs: skillAbs });
+  }
+  out.sort((a, b) => a.name.localeCompare(b.name));
+  return out;
+}
+
+function walkRefMd(dir, relBase, acc) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch (err) {
+    if (err && err.code === "ENOENT") return acc;
+    throw err;
+  }
+  for (const ent of entries) {
+    if (ent.name.startsWith(".")) continue;
+    const abs = path.join(dir, ent.name);
+    const rel = relBase ? posixRel(relBase, ent.name) : posixRel(REFS_REL, ent.name);
+    if (ent.isDirectory()) {
+      walkRefMd(abs, rel, acc);
+      continue;
+    }
+    if (!ent.isFile() || !ent.name.endsWith(".md")) continue;
+    if (SKIP_REF_NAMES.has(ent.name)) continue;
+    acc.push({ abs, rel });
+  }
+  return acc;
+}
+
+function packagedSkillExists(ws, name) {
+  const abs = path.join(ws, PACKAGED_SKILLS_REL, name, "SKILL.md");
+  const st = lstat(abs);
+  return Boolean(st && st.isFile());
+}
+
+function skillFields(ws, skill) {
+  const raw = readText(skill.abs);
+  if (raw == null) return null;
+  const { parsed, body } = parseMarkdown(raw);
+  const name = parsed.name != null && parsed.name !== "" ? String(parsed.name) : skill.name;
+  const descSrc =
+    parsed.description != null && parsed.description !== "" ? parsed.description : firstSummary(body);
+  const commandPath = parsed.commandPath != null ? String(parsed.commandPath) : "";
+  const refs = mapRefs(parsed).join(", ");
+  const task = mapTask(parsed);
+  const origin = packagedSkillExists(ws, skill.name) ? "grunt" : "local";
+  return { name, origin, descSrc, commandPath, refs, task };
+}
+
+function skillRowFromFields(f) {
+  return `| ${cell(f.name)} | ${cell(f.origin)} | ${cell(f.descSrc)} | ${cell(f.task)} | ${cell(f.commandPath)} | ${cell(f.refs)} |`;
+}
+
+function refRow(file) {
+  const st = lstat(file.abs);
+  if (!st || !st.isFile()) return null;
+  const fallbackTitle = path.basename(file.rel, ".md");
+  if (st.size > HUGE_BYTES) {
+    return `| ${cell(file.rel)} | ${cell(fallbackTitle)} |  |  |`;
+  }
+  const raw = readText(file.abs);
+  if (raw == null || raw.includes("\0")) {
+    return `| ${cell(file.rel)} | ${cell(fallbackTitle)} |  |  |`;
+  }
+  const { parsed, body } = parseMarkdown(raw);
+  const title = firstH1(body) || fallbackTitle;
+  const tags = tagsOf(parsed).join(", ");
+  const summary = firstSummary(body);
+  return `| ${cell(file.rel)} | ${cell(title)} | ${cell(tags)} | ${cell(summary)} |`;
+}
+
+function skillsTable(rows) {
+  return [
+    "| name | origin | description | task | commandPath | refs |",
+    "| --- | --- | --- | --- | --- | --- |",
+    ...rows,
+  ].join("\n");
+}
+
+function refsTable(rows) {
+  return [
+    "| path | title | tags | summary |",
+    "| --- | --- | --- | --- |",
+    ...rows,
+  ].join("\n");
+}
+
+function renderSkillsMap(rows) {
+  return `${BANNER}\n# Skills map\n\n${skillsTable(rows)}\n`;
+}
+
+function renderRefsMap(rows) {
+  return `${BANNER}\n# Refs map\n\n${refsTable(rows)}\n`;
+}
+
+function readLawBody(ws) {
+  const abs = path.join(ws, LAW_REL);
+  const st = lstat(abs);
+  if (!st || !st.isFile()) {
+    return { ok: false, error: `missing: ${LAW_REL}` };
+  }
+  const raw = readText(abs);
+  if (raw == null) {
+    return { ok: false, error: `missing: ${LAW_REL}` };
+  }
+  const { body } = parseMarkdown(raw);
+  return { ok: true, body: String(body ?? "").replace(/^\uFEFF/, "").replace(/\s+$/, "") };
+}
+
+function renderIndex(lawBody, skillRows, refRows) {
+  return `${BANNER}\n${lawBody}\n\n# Skills\n\n${skillsTable(skillRows)}\n\n# Refs\n\n${refsTable(refRows)}\n`;
+}
+
+function desiredFiles(ws) {
+  const law = readLawBody(ws);
+  if (!law.ok) return law;
+  const fields = listSkillDirs(ws).map((s) => skillFields(ws, s)).filter(Boolean);
+  const skills = fields.map((f) => skillRowFromFields(f));
+  const refs = walkRefMd(path.join(ws, REFS_REL), "", [])
+    .sort((a, b) => a.rel.localeCompare(b.rel))
+    .map(refRow)
+    .filter(Boolean);
+  return {
+    ok: true,
+    files: [
+      { rel: INDEX_REL, text: renderIndex(law.body, skills, refs) },
+      { rel: SKILLS_MAP_REL, text: renderSkillsMap(skills) },
+      { rel: REFS_MAP_REL, text: renderRefsMap(refs) },
+    ],
+  };
+}
+
+export function emitMaps({ workspaceRoot, check = false } = {}) {
+  const ws = workspaceRoot || process.cwd();
+  const rulesync = path.join(ws, ".rulesync");
+  const st = lstat(rulesync);
+  if (!st || !st.isDirectory()) {
+    return { ok: true, check, skipped: true };
+  }
+
+  const desired = desiredFiles(ws);
+  if (!desired.ok) {
+    return { ok: false, check, error: desired.error };
+  }
+  const files = desired.files;
+  if (check) {
+    const drift = [];
+    for (const f of files) {
+      const disk = readText(path.join(ws, f.rel));
+      if (disk !== f.text) drift.push(f.rel);
+    }
+    if (drift.length) {
+      return { ok: false, check: true, error: `drift: ${drift.join(", ")}`, drift };
+    }
+    return { ok: true, check: true, drift: [] };
+  }
+
+  for (const f of files) {
+    const abs = path.join(ws, f.rel);
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, f.text);
+  }
+  return { ok: true, check: false };
+}
+
+function main() {
+  try {
+    const parsed = parseArgv(process.argv.slice(2));
+    if (!parsed.ok) {
+      process.stderr.write((parsed.error || "invalid argv") + "\n");
+      return 1;
+    }
+    const result = emitMaps({
+      workspaceRoot: process.cwd(),
+      check: parsed.check,
+    });
+    if (!result.ok) {
+      process.stderr.write((result.error || "emit failed") + "\n");
+      return 1;
+    }
+    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/gate-fat-tools.mjs

@@ -439,7 +439,7 @@ function resolveWriteAbs(filePath, workspaceRoot) {
 
 function isUnderPlansDir(abs, workspaceRoot) {
   if (!abs || !workspaceRoot) return false;
-  const dir = path.resolve(workspaceRoot, ".tmp", "plans");
+  const dir = path.resolve(workspaceRoot, ".tmp", "grunt", "plans");
   if (abs === dir) return true;
   const rel = path.relative(dir, abs);
   return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel);
@@ -487,7 +487,7 @@ function inProgressStatus(text) {
 }
 
 function loadInProgressPlans(workspaceRoot) {
-  const dir = path.resolve(workspaceRoot, ".tmp", "plans");
+  const dir = path.resolve(workspaceRoot, ".tmp", "grunt", "plans");
   let names;
   try {
     names = fs.readdirSync(dir);

package/scripts/grunt-config.mjs

@@ -0,0 +1,50 @@
+/** Load leftoverGate + spawnMode from `.rulesync/grunt.config.jsonc`. leftover fail-closed `"ask"`; spawn fail-closed `"cascade"`. Keys independent. */
+import fs from "node:fs";
+import path from "node:path";
+
+export const CONFIG_REL = ".rulesync/grunt.config.jsonc";
+export const LEFTOVER_GATES = new Set(["auto", "ask"]);
+export const SPAWN_MODES = new Set(["solo", "cascade"]);
+
+export function stripJsonc(text) {
+  return String(text ?? "")
+    .replace(/\/\*[\s\S]*?\*\//g, "")
+    .replace(/\/\/.*$/gm, "");
+}
+
+function readConfigObject(workspaceRoot) {
+  if (!workspaceRoot) return null;
+  const raw = fs.readFileSync(path.join(workspaceRoot, CONFIG_REL), "utf8");
+  const obj = JSON.parse(stripJsonc(raw));
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return null;
+  if (obj.version !== 1) return null;
+  return obj;
+}
+
+/** @returns {"auto"|"ask"} */
+export function loadLeftoverGate(workspaceRoot) {
+  try {
+    const obj = readConfigObject(workspaceRoot);
+    if (!obj) return "ask";
+    if (obj.leftoverGate === "auto" || obj.leftoverGate === "ask") {
+      return obj.leftoverGate;
+    }
+    return "ask";
+  } catch {
+    return "ask";
+  }
+}
+
+/** @returns {"solo"|"cascade"} */
+export function loadSpawnMode(workspaceRoot) {
+  try {
+    const obj = readConfigObject(workspaceRoot);
+    if (!obj) return "cascade";
+    if (obj.spawnMode === "solo" || obj.spawnMode === "cascade") {
+      return obj.spawnMode;
+    }
+    return "cascade";
+  } catch {
+    return "cascade";
+  }
+}

package/scripts/guarded-roots.mjs

@@ -11,10 +11,7 @@ import {
   snapshotGuardedRoots,
   withGuardedCheckInteriors,
 } from "../cli/init.mjs";
-
-const GENERATE_RAW = "rulesync:generate:raw";
-const CHECK_RAW = "rulesync:check:raw";
-const WATCH_RAW = "rulesync:watch:raw";
+import { runPipeline } from "./pipeline.mjs";
 
 export function attachGuardedRootWatchers(cwd, heal) {
   const w = fs.watch(cwd, (_event, filename) => {
@@ -36,7 +33,7 @@ export function runGuardedRoots(mode, { cwd = process.cwd(), exec = execSync, at
   if (mode === "generate") {
     const snap = snapshotGuardedRoots(cwd);
     try {
-      exec(`npm run ${GENERATE_RAW}`, { cwd, stdio: "inherit", shell: true });
+      runPipeline("generate", { cwd, exec });
     } finally {
       remergeGuardedRoots(cwd, snap);
     }
@@ -44,7 +41,7 @@ export function runGuardedRoots(mode, { cwd = process.cwd(), exec = execSync, at
   }
   if (mode === "check") {
     withGuardedCheckInteriors(cwd, () => {
-      exec(`npm run ${CHECK_RAW}`, { cwd, stdio: "inherit", shell: true });
+      runPipeline("check", { cwd, exec });
     });
     return;
   }
@@ -54,7 +51,7 @@ export function runGuardedRoots(mode, { cwd = process.cwd(), exec = execSync, at
     const attach = attachWatchers || ((opts) => attachGuardedRootWatchers(opts.cwd, opts.heal));
     const stop = attach({ cwd, snap, heal });
     try {
-      exec(`npm run ${WATCH_RAW}`, { cwd, stdio: "inherit", shell: true });
+      runPipeline("watch", { cwd, exec });
     } finally {
       try {
         stop?.();