@lovrozagar/grunt 0.3.11 → 0.4.1

package/README.md

@@ -5,6 +5,7 @@ Multi-agent orchestrator SoT — deep-merge rulesync trees product scripts and g
 OSS drop-in; merges existing configs; switches default provider flow to Grunt.
 
 - [Install](#install)
+- [Prerequisites](#prerequisites)
 - [Usage](#usage)
 - [CLI](#cli)
 - [Init](#init)
@@ -33,6 +34,29 @@ npx @lovrozagar/grunt
 - Do not `npm test` as a consumer
 - Package: `@lovrozagar/grunt` `0.3.9` MIT · https://github.com/lovrozagar/grunt
 
+## Prerequisites
+
+All OS. Print-only. Never auto-install.
+
+```
+npx grunt doctor
+node scripts/doctor.mjs
+```
+
+Exit 1 if any required missing; 0 if all required ok. Optional `gh` reported only.
+
+| tool | required | install |
+| --- | --- | --- |
+| node ≥22 + npm | yes | https://nodejs.org (≥22) · nvm / OS pkg · win `winget install OpenJS.NodeJS.LTS` |
+| git | yes | linux `sudo apt install git` · mac `brew install git` · win `winget install Git.Git` |
+| rtk | yes | linux/mac `curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/master/install.sh \| sh` or `brew install rtk` · win release zip `rtk.exe` on PATH or WSL curl ([docs](https://www.rtk-ai.app/docs/getting-started/installation/)) |
+| rulesync | yes | `npm i -D rulesync` / npx (PATH or npx-able) |
+| lightpanda | yes | `curl -fsSL https://pkg.lightpanda.io/install.sh \| bash` · mac `brew tap lightpanda-io/browser` · win WSL only |
+| chromium-family | yes | linux `sudo apt install chromium` · mac `brew install --cask chromium` or `google-chrome` · win `winget install Google.Chrome` / `Microsoft.Edge` + PATH |
+| gh | no | report only |
+
+Rulesync schema doctor is separate: `npm run rulesync:doctor`.
+
 ## Usage
 
 - TTY no command → menu (init default; generate check sync-globals purge-mcps doctor help quit)
@@ -48,7 +72,7 @@ npx @lovrozagar/grunt
 - `check` → `npm run rulesync:check`
 - `sync-globals` → `npm run sync:globals` (dry-run); `--apply` → `sync:globals:apply`
 - `purge-mcps` → `npm run purge:global-mcps` (dry-run); `--apply` → `purge:global-mcps:apply`
-- `doctor` → `npm run rulesync:doctor`
+- `doctor` → `npm run doctor` (`node scripts/doctor.mjs`). Rulesync schema: `npm run rulesync:doctor`
 - `help`
 - `version`
 
@@ -81,19 +105,25 @@ SoT: `.rulesync/subagents/{orchestrator grunt implementer thinker}.md`
 
 Emit: `.claude/` `.grok/` `.agents/` `.gemini/`
 
-- **orchestrator** (parent) — always spawn+prompt; user-facing only `[orchestrator]:` (or child role tag) one-line echo. `/parent` one-turn; `/handoff` writes `.tmp/grunt/handoffs/{serial}-{slug}-{stamp}.md`. Small/low router. First token spawn. No parent Read/Bash/Grep. Does not implement, plan, or fetch world facts
+- **orchestrator** (parent) — always spawn+prompt; user-facing `[orchestrator]:` (or child role tag) one-line recap; advise leftover numbered pick each on own line after that recap (do not cram `1. Implement 2. Tweak` onto the recap line). `/parent` one-turn; `/handoff` writes `.tmp/grunt/handoffs/{serial}-{slug}-{stamp}.md`; `/pickup` spawn-first pickup (inverse of `/handoff`; not a mode). `/solo` session escape; `/cascade` restores it. Small/low router. First token spawn. No parent Read/Bash/Grep. Does not implement, plan, or fetch world facts
 - **grunt** — tools: facts/search/exec/git/web/test/low-reason mechanical write. Isolation `verdict:`. Never feature solution. Never spawn. World fact: `job: web`
 - **implementer** — write already-defined solution on allowlisted paths. TDD when spec/plan says tests. Validate + sim after write. Fat dumps via `need:`. Never spawn. Never plan. Id is **implementer** (not Implementor)
-- **thinker** — plan/deep reason; edge cases. Read-only named-file Read of prompt SSOT; trees/search/exec/web/test → `need:`. Never spawn. No bash. Never implement
+- **thinker** — think/plan/advise/recommend/how/why/explain; unsure→thinker; cheap false+; edge cases. Read-only named-file Read of prompt SSOT; trees/search/exec/web/test → `need:`. Never spawn. No bash. Never implement
 
 Children never spawn. Spawn only grunt|implementer|thinker. Omit model on spawn; frontmatter on agent files picks haiku/sonnet/opus vs grok-4.5 / grok-4.6 / other hosts. Voice: `.rulesync/reference/output.md`. Protocol: `.rulesync/reference/cascade.md`. `AGENTS.md`/`CLAUDE.md` spawn-first. `GEMINI.md` → `@AGENTS.md`. Goals: synced configs across grok build claude code codex gemini cli antigravity; max situational speed; superterse token savings; max/min reasoning by role.
 
+## Browser
+
+Lightpanda-first session CLI: `node scripts/browser.mjs nav|snap|click|fill|shot|pdf|stop|doctor|ensure`. Zero MCP. Zero env knobs. Chromium only for `shot`/`pdf`/`trace`, Windows, missing Lightpanda, one probe-fail replay, or paint hosts. Session: `.tmp/grunt/browser/`. Spec: [`.rulesync/reference/browser.md`](.rulesync/reference/browser.md).
+
+`node scripts/browser.mjs doctor` (alias `ensure`) runs the unified doctor (`scripts/doctor.mjs`). Install engines: [Prerequisites](#prerequisites).
+
 ## Skills
 
 Present under `.claude` / `.rulesync` / `.agents`:
 
-- `cascade` `commit` `commit-and-push` `commit-push` `commit-push-deploy` `commit-push-release` `explain` `handoff` `parent` `solo`
-- Grok-only: `write-plan` `implement-plan` (`/write-plan` plan-only → `next: /implement-plan`)
+- `browser` `cascade` `commit` `commit-and-push` `commit-push` `commit-push-deploy` `commit-push-release` `explain` `handoff` `pickup` `parent` `solo`
+- Grok-only: `write-plan` `implement-plan` (`/write-plan` plan-only → `next: /implement-plan`; advise unlock = pick **1. Implement**, not `ok`/`yes`/`go`; slash `/implement-plan` still valid alias)
 
 ## Generate
 
@@ -104,7 +134,7 @@ Pipeline (no `-t geminicli`):
 3. `emit-gemini.mjs` — `GEMINI.md` `.gemini/agents/{id}/agent.md` MCP `.gemini/settings.json`
 4. `emit-agent-shell-tools` — Claude grunt body `Bash`; other hosts `run_terminal_command` (hooks-union)
 
-`check` / `doctor` = rulesync check / doctor.
+`check` = rulesync check. `doctor` = unified prereqs. Schema: `npm run rulesync:doctor`.
 
 Emit writes other-CLI trees from `.rulesync` for the **next** process of that CLI. Not a live hop into another host.
 
@@ -132,7 +162,7 @@ Same topology as the session recap; every legal edge labeled.
 ```
  USER
   │
-  │  session in/out  (parent only; tagged one-line recap)
+  │  session in/out  (parent only; tagged one-line recap; advise leftover 1./2. own lines)
   │  TUI local; completion tokens from Model API (mixed)
   ▼
 ┌──────────────────────── CLI HOST (this process) ────────────────────────┐
@@ -221,7 +251,7 @@ Implementer or thinker that still needs a fat dump **stops** on a `need:` JSON l
 | node | inside host? | local vs AI-server | notes |
 | --- | --- | --- | --- |
 | User | no | mixed | Speaks only to parent session. Never a child edge. |
-| Session in/out / TUI | yes | mixed | TUI is local; recap tokens come from the model. Legal `[role]:` one-line echo only. |
+| Session in/out / TUI | yes | mixed | TUI is local; recap tokens come from the model. Legal `[role]:` one-line recap; advise leftover numbered pick each on own line after (not crammed onto the recap line). |
 | CLI host process | yes (is the box) | local process | Grok Build / Claude Code / Codex / Gemini / Antigravity. Not a peer of another CLI. |
 | Parent orchestrator | yes | AI-server **turn** | Spawn-first low router. No parent Read/Bash/Grep. Lives in this session, not a sidecar. |
 | `grunt` sibling | yes | AI-server **turn** | Facts/tools/mechanical write. Never spawn. Never feature solution. |
@@ -288,7 +318,7 @@ Repo-relative (repository root):
 
 ## Layout
 
-Published (`package.json` `files`): `bin/grunt.js` `cli` `scripts/check-globals.mjs` `scripts/emit-agent-shell-tools.mjs` `scripts/emit-gemini.mjs` `scripts/emit-mcp-policy.mjs` `scripts/gate-fat-tools.mjs` `scripts/hooks-union.mjs` `scripts/grunt-job.mjs` `scripts/parse-need.mjs` `scripts/persist-handoff.mjs` `scripts/persist-plan.mjs` `scripts/purge-global-mcps.mjs` `scripts/scrub-spawn-prompt.mjs` `scripts/scrub-text-lib.mjs` `scripts/sync-global-settings.mjs` `scripts/telemetry.mjs` `scripts/scrub-text` `.rulesync` `.grok` `.codex` `.claude` `.agents` `AGENTS.md` `CLAUDE.md` `.mcp.json` `README.md` `LICENSE`
+Published (`package.json` `files`): `bin/grunt.js` `cli` `scripts/check-globals.mjs` `scripts/emit-agent-shell-tools.mjs` `scripts/emit-gemini.mjs` `scripts/emit-mcp-policy.mjs` `scripts/gate-fat-tools.mjs` `scripts/hooks-union.mjs` `scripts/grunt-job.mjs` `scripts/parse-need.mjs` `scripts/persist-handoff.mjs` `scripts/persist-plan.mjs` `scripts/purge-global-mcps.mjs` `scripts/scrub-spawn-prompt.mjs` `scripts/scrub-text-lib.mjs` `scripts/sync-global-settings.mjs` `scripts/telemetry.mjs` `scripts/browser.mjs` `scripts/doctor.mjs` `scripts/scrub-text` `.rulesync` `.grok` `.codex` `.claude` `.agents` `AGENTS.md` `CLAUDE.md` `.mcp.json` `README.md` `LICENSE`
 
 No `scripts/*.test.ts` `scripts/fixtures/` `docs/` `coverage/` `vitest.config.ts` in `files`.
 
@@ -319,7 +349,7 @@ npm i && npm test
 
 Keep these four flows only:
 
-1. “Create me a react weather app” → thinker plan → implementer write → orchestrator recap
+1. “Create me a react weather app” → thinker plan/recap-stop + pick 1.Implement 2.Tweak → user picks 1 or `/implement-plan` → implementer write → recap
 2. “What is 2+2” → grunt → `[grunt]:` echo
 3. Marvel theatrical next → grunt `job:web` → recap
 4. `.logs` 3/6/2021 tag `framework bug` → grunt local search → recap

package/cli/grunt.mjs

@@ -17,7 +17,7 @@ Commands:
   check         npm run rulesync:check
   sync-globals  npm run sync:globals (dry-run; --apply to write)
   purge-mcps    npm run purge:global-mcps (dry-run; --apply to write)
-  doctor        npm run rulesync:doctor
+  doctor        npm run doctor
   help          Show this help
   version       Print package version
 
@@ -163,7 +163,7 @@ async function dispatch(cmd, flags, interactive) {
     return
   }
   if (cmd === "doctor") {
-    npmRun("rulesync:doctor")
+    npmRun("doctor")
     return
   }
   process.stdout.write(USAGE)

package/cli/grunt.test.ts

@@ -37,7 +37,7 @@ Commands:
   check         npm run rulesync:check
   sync-globals  npm run sync:globals (dry-run; --apply to write)
   purge-mcps    npm run purge:global-mcps (dry-run; --apply to write)
-  doctor        npm run rulesync:doctor
+  doctor        npm run doctor
   help          Show this help
   version       Print package version
 
@@ -236,10 +236,10 @@ describe("start", () => {
     );
   });
 
-  it("doctor npm-runs rulesync:doctor", async () => {
+  it("doctor npm-runs doctor", async () => {
     process.argv = ["node", "grunt", "doctor"];
     await start();
-    expect(execFileSync).toHaveBeenCalledWith("npm", ["run", "rulesync:doctor"], {
+    expect(execFileSync).toHaveBeenCalledWith("npm", ["run", "doctor"], {
       cwd: process.cwd(),
       stdio: "inherit",
     });

package/cli/init.mjs

@@ -9,6 +9,7 @@ const PRODUCT_SCRIPTS = [
   "check-globals.mjs",
   "emit-agent-shell-tools.mjs",
   "emit-gemini.mjs",
+  "guarded-roots.mjs",
   "emit-mcp-policy.mjs",
   "gate-fat-tools.mjs",
   "hooks-union.mjs",
@@ -21,17 +22,23 @@ const PRODUCT_SCRIPTS = [
   "scrub-text-lib.mjs",
   "sync-global-settings.mjs",
   "telemetry.mjs",
+  "browser.mjs",
+  "doctor.mjs",
   "scrub-text",
 ]
 
 const COPY_DIRS = [".rulesync", ".grok", ".codex", ".claude", ".agents"]
 const GUARDED_MD_FILES = ["AGENTS.md", "CLAUDE.md"]
+export const GUARDED_ROOT_FILES = ["AGENTS.md", "CLAUDE.md", "GEMINI.md"]
 // .mcp.json is intentionally not copied here: scripts/emit-mcp-policy.mjs
 // (run via `rulesync:generate`, see mergeClaudeSettings ordering) owns and
 // merges it, so a plain-copy would just be clobbered/redundant.
 const OWNED_HOOK_FILES = ["scrub-spawn-prompt.mjs", "gate-fat-tools.mjs", "orchestrate-parent.js"]
-const SENTINEL_BEGIN = "<!-- grunt:begin -->"
-const SENTINEL_END = "<!-- grunt:end -->"
+export const SENTINEL_BEGIN = "<!-- grunt:begin -->"
+export const SENTINEL_END = "<!-- grunt:end -->"
+export const MAX_GUARDED_MARKDOWN_BYTES = 2 * 1024 * 1024
+const GRUNT_REGION_RE = /<!-- grunt:begin -->\r?\n?[\s\S]*?<!-- grunt:end -->\r?\n?/g
+const GRUNT_INTERIOR_RE = /<!-- grunt:begin -->\r?\n?([\s\S]*?)<!-- grunt:end -->/g
 
 function sortKeys(obj) {
   return Object.fromEntries(Object.keys(obj).sort().map((k) => [k, obj[k]]))
@@ -77,33 +84,199 @@ export function shouldAutoSkipGlobals(dest) {
   return destHasGruntSentinel(dest) || fs.existsSync(path.join(dest, "scripts", "telemetry.mjs"))
 }
 
+function detectNewline(text) {
+  return String(text).includes("\r\n") ? "\r\n" : "\n"
+}
+
+function toNewline(text, nl) {
+  return String(text).replace(/\r\n/g, "\n").replace(/\n/g, nl)
+}
+
+function trimTrailingNewlines(text) {
+  return String(text).replace(/(?:\r?\n)+$/, "")
+}
+
+function normEq(a, b) {
+  return trimTrailingNewlines(String(a).replace(/\r\n/g, "\n")) ===
+    trimTrailingNewlines(String(b).replace(/\r\n/g, "\n"))
+}
+
+function cloneRe(re) {
+  return new RegExp(re.source, re.flags)
+}
+
+function inspectGuardedBuffer(buf) {
+  if (buf.length > MAX_GUARDED_MARKDOWN_BYTES) return "huge"
+  if (buf.includes(0)) return "binary"
+  return null
+}
+
+export function extractUserMarkdown(text) {
+  return String(text).replace(cloneRe(GRUNT_REGION_RE), "")
+}
+
+export function extractGruntBody(text) {
+  const parts = []
+  const re = cloneRe(GRUNT_INTERIOR_RE)
+  let m
+  while ((m = re.exec(String(text)))) {
+    parts.push(trimTrailingNewlines(m[1]))
+  }
+  if (!parts.length) return null
+  return parts.join("\n")
+}
+
+function userRemainderIsBlank(user) {
+  return String(user).replace(/\r\n/g, "\n").replace(/\n/g, "") === ""
+}
+
+export function composeGuardedMarkdown(gruntBody, userRemainder, nl = "\n") {
+  const body = toNewline(trimTrailingNewlines(gruntBody), nl)
+  const block = `${SENTINEL_BEGIN}${nl}${body}${nl}${SENTINEL_END}${nl}`
+  const user = userRemainder == null ? "" : String(userRemainder)
+  if (!user || userRemainderIsBlank(user)) return block
+  return block + toNewline(user, nl)
+}
+
+export function mergeGuardedContent(existingText, gruntBody) {
+  const existing = existingText == null ? "" : String(existingText)
+  const nl = existing.includes("\r\n") || String(gruntBody).includes("\r\n")
+    ? detectNewline(existing || gruntBody)
+    : "\n"
+  if (!existing) return composeGuardedMarkdown(gruntBody, "", nl)
+  const hadSentinel = existing.includes(SENTINEL_BEGIN) && existing.includes(SENTINEL_END)
+  const user = extractUserMarkdown(existing)
+  if (!hadSentinel && normEq(existing, gruntBody)) {
+    return composeGuardedMarkdown(gruntBody, "", nl)
+  }
+  return composeGuardedMarkdown(gruntBody, user, nl)
+}
+
+export function writeMergedGuardedFile(destPath, gruntBody) {
+  if (!fs.existsSync(destPath)) {
+    fs.writeFileSync(destPath, mergeGuardedContent("", gruntBody))
+    return
+  }
+  const buf = fs.readFileSync(destPath)
+  if (inspectGuardedBuffer(buf)) return "aborted-unsafe"
+  fs.writeFileSync(destPath, mergeGuardedContent(buf.toString("utf8"), gruntBody))
+}
+
+export function guardedMarkdownDrift(destPath, gruntBody) {
+  if (!fs.existsSync(destPath)) return true
+  const buf = fs.readFileSync(destPath)
+  if (inspectGuardedBuffer(buf)) return true
+  const text = buf.toString("utf8")
+  const interior = extractGruntBody(text)
+  if (interior == null) return !normEq(text, gruntBody)
+  return !normEq(interior, gruntBody)
+}
+
 export function mergeGuardedMarkdown(dest, pkgRoot, file, { alreadyInited = false } = {}) {
+  void alreadyInited
   const src = path.join(pkgRoot, file)
   const d = path.join(dest, file)
   if (samePath(src, d)) return
   const srcText = fs.readFileSync(src, "utf8")
+  return writeMergedGuardedFile(d, srcText)
+}
 
-  if (!fs.existsSync(d)) {
-    fs.writeFileSync(d, `${SENTINEL_BEGIN}\n${srcText}\n${SENTINEL_END}\n`)
-    return
+export function snapshotGuardedRoots(root) {
+  const snap = {}
+  for (const file of GUARDED_ROOT_FILES) {
+    const p = path.join(root, file)
+    if (!fs.existsSync(p)) continue
+    const buf = fs.readFileSync(p)
+    const unsafe = inspectGuardedBuffer(buf)
+    if (unsafe) {
+      snap[file] = { unsafe, rawBuf: buf }
+      continue
+    }
+    const raw = buf.toString("utf8")
+    snap[file] = { raw, user: extractUserMarkdown(raw) }
   }
+  return snap
+}
 
-  const destText = fs.readFileSync(d, "utf8")
-  const hasSentinel = [SENTINEL_BEGIN, SENTINEL_END].every((marker) => destText.includes(marker))
+export function remergeGuardedRoots(root, snap) {
+  for (const file of GUARDED_ROOT_FILES) {
+    const p = path.join(root, file)
+    const rec = snap[file]
+    if (rec?.unsafe) {
+      fs.writeFileSync(p, rec.rawBuf)
+      continue
+    }
+    if (!fs.existsSync(p)) {
+      if (rec?.raw != null) fs.writeFileSync(p, rec.raw)
+      continue
+    }
+    const buf = fs.readFileSync(p)
+    if (inspectGuardedBuffer(buf)) {
+      if (rec?.raw != null) fs.writeFileSync(p, rec.raw)
+      continue
+    }
+    const current = buf.toString("utf8")
+    if (rec && current === rec.raw) continue
+    const gruntBody = extractGruntBody(current) ?? current
+    const nl = detectNewline((rec && rec.raw) || current)
+    let user = rec ? rec.user : extractUserMarkdown(current)
+    if (rec && !rec.raw.includes(SENTINEL_BEGIN) && normEq(rec.raw, gruntBody)) user = ""
+    if (!rec && extractGruntBody(current) == null && normEq(current, gruntBody)) user = ""
+    fs.writeFileSync(p, composeGuardedMarkdown(gruntBody, user, nl))
+  }
+}
 
-  if (!hasSentinel) {
-    if (alreadyInited) return "skipped-side-file"
-    const gruntFile = file.replace(/\.md$/, ".grunt.md")
-    fs.writeFileSync(path.join(dest, gruntFile), srcText)
-    console.log(`${file} exists without grunt sentinel; wrote ${gruntFile} instead (original untouched)`)
+export function healGuardedRootFile(root, file, snap) {
+  if (!GUARDED_ROOT_FILES.includes(file)) return
+  const p = path.join(root, file)
+  const rec = snap[file]
+  if (!fs.existsSync(p)) return
+  if (rec?.unsafe) {
+    fs.writeFileSync(p, rec.rawBuf)
+    return
+  }
+  const buf = fs.readFileSync(p)
+  if (inspectGuardedBuffer(buf)) {
+    if (rec?.raw != null) fs.writeFileSync(p, rec.raw)
     return
   }
+  const current = buf.toString("utf8")
+  const interior = extractGruntBody(current)
+  if (interior != null) {
+    snap[file] = { raw: current, user: extractUserMarkdown(current) }
+    return
+  }
+  if (rec && current === rec.raw) return
+  const gruntBody = current
+  const nl = detectNewline((rec && rec.raw) || current)
+  let user = rec ? rec.user : extractUserMarkdown(current)
+  if (rec && !rec.raw.includes(SENTINEL_BEGIN) && normEq(rec.raw, gruntBody)) user = ""
+  if (!rec && normEq(current, gruntBody)) user = ""
+  const out = composeGuardedMarkdown(gruntBody, user, nl)
+  fs.writeFileSync(p, out)
+  snap[file] = { raw: out, user }
+}
 
-  const beginIdx = destText.indexOf(SENTINEL_BEGIN)
-  const endIdx = destText.indexOf(SENTINEL_END)
-  const before = destText.slice(0, beginIdx)
-  const after = destText.slice(endIdx + SENTINEL_END.length)
-  fs.writeFileSync(d, `${before}${SENTINEL_BEGIN}\n${srcText}\n${SENTINEL_END}${after}`)
+export function withGuardedCheckInteriors(root, fn) {
+  const snap = snapshotGuardedRoots(root)
+  try {
+    for (const file of GUARDED_ROOT_FILES) {
+      const rec = snap[file]
+      if (!rec || rec.unsafe) continue
+      const body = extractGruntBody(rec.raw)
+      if (body == null) continue
+      const nl = detectNewline(rec.raw)
+      fs.writeFileSync(path.join(root, file), `${toNewline(trimTrailingNewlines(body), nl)}${nl}`)
+    }
+    return fn()
+  } finally {
+    for (const file of GUARDED_ROOT_FILES) {
+      const rec = snap[file]
+      if (!rec) continue
+      if (rec.unsafe) fs.writeFileSync(path.join(root, file), rec.rawBuf)
+      else fs.writeFileSync(path.join(root, file), rec.raw)
+    }
+  }
 }
 
 export function mergeClaudeSettings(destRoot, pkgRoot) {
@@ -220,7 +393,6 @@ export function mergePackageJson(dest, pkgRoot) {
 export function init(dest, { pkgRoot: pkgRootOpt, execFileSync: exec = execFileSync, skipGlobals = false, applyGlobals, onPhase } = {}) {
   dest = path.resolve(dest)
   const pkgRoot = path.resolve(pkgRootOpt ?? PKG_ROOT)
-  const alreadyInited = destAlreadyInited(dest)
   const skipGlobalsApply =
     applyGlobals === true ? false : skipGlobals || shouldAutoSkipGlobals(dest)
 
@@ -253,14 +425,8 @@ export function init(dest, { pkgRoot: pkgRootOpt, execFileSync: exec = execFileS
       }
     }
 
-    let skippedSideFile = false
     for (const file of GUARDED_MD_FILES) {
-      if (mergeGuardedMarkdown(dest, pkgRoot, file, { alreadyInited }) === "skipped-side-file") {
-        skippedSideFile = true
-      }
-    }
-    if (skippedSideFile) {
-      console.log("AGENTS.md/CLAUDE.md lack markers and were left alone")
+      mergeGuardedMarkdown(dest, pkgRoot, file)
     }
 
     fs.mkdirSync(path.join(dest, "scripts"), { recursive: true })
@@ -289,9 +455,13 @@ export function init(dest, { pkgRoot: pkgRootOpt, execFileSync: exec = execFileS
     exec("npm", args, { cwd: dest, stdio: "inherit" })
   }
   runNpm("install", ["install"])
+  const guardedSnap = snapshotGuardedRoots(dest)
   runNpm("generate", ["run", "rulesync:generate"])
+  remergeGuardedRoots(dest, guardedSnap)
   if (!skipGlobalsApply) {
     runNpm("sync-globals", ["run", "sync:globals:apply"])
   }
-  runNpm("check", ["run", "rulesync:check"])
+  withGuardedCheckInteriors(dest, () => {
+    runNpm("check", ["run", "rulesync:check"])
+  })
 }