@lovrozagar/grunt 0.5.0 → 0.6.0

package/cli/init.test.ts

@@ -1,16 +1,27 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import {
   MAX_GUARDED_MARKDOWN_BYTES,
   composeGuardedMarkdown,
   destAlreadyInited,
   extractGruntBody,
+  extractUserMarkdown,
   GUARDED_ROOT_FILES,
+  SENTINEL_BEGIN,
+  SENTINEL_END,
   guardedMarkdownDrift,
   healGuardedRootFile,
   init,
+  pruneRetired,
+  RETIRED_SKILLS,
+  RETIRED_AGENTS,
+  RETIRED_SCRIPTS,
+  RETIRED_PATHS,
+  RESERVED_SKILLS,
+  LAUNCH_SCRIPTS,
   mergeClaudeSettings,
   mergeGitignore,
   mergeGuardedContent,
@@ -20,6 +31,7 @@ import {
   samePath,
   shouldAutoSkipGlobals,
   snapshotGuardedRoots,
+  toGruntScriptName,
   withGuardedCheckInteriors,
   writeMergedGuardedFile,
 } from "./init.mjs";
@@ -53,12 +65,18 @@ const PRODUCT_FILES = [
   "grunt-job.mjs",
   "parse-need.mjs",
   "persist-handoff.mjs",
+  "persist-implementation.mjs",
+  "persist-tmp.mjs",
   "persist-plan.mjs",
   "purge-global-mcps.mjs",
   "scrub-spawn-prompt.mjs",
   "scrub-text-lib.mjs",
   "sync-global-settings.mjs",
   "browser.mjs",
+  "speak.mjs",
+  "listen.mjs",
+  "google-workspace.mjs",
+  "setup.mjs",
   "doctor.mjs",
   "skill-conflicts.mjs",
 ];
@@ -154,18 +172,22 @@ describe("samePath", () => {
   });
 });
 
+const GI_TMP = ".tmp/\n";
+
 describe("mergeGitignore", () => {
   it("creates .tmp/ when missing", () => {
     const dest = tmp("gi-miss-");
     mergeGitignore(dest);
-    expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe(".tmp/\n");
+    expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe(GI_TMP);
   });
 
-  it("noop when .tmp/ present", () => {
+  it("noop when .tmp/ already present", () => {
     const dest = tmp("gi-slash-");
     fs.writeFileSync(path.join(dest, ".gitignore"), "foo\n.tmp/\nbar\n");
     mergeGitignore(dest);
-    expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe("foo\n.tmp/\nbar\n");
+    expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe(
+      "foo\n.tmp/\nbar\n",
+    );
   });
 
   it("noop when .tmp present", () => {
@@ -175,12 +197,21 @@ describe("mergeGitignore", () => {
     expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe(".tmp\n");
   });
 
+  it("noop when .tmp/ present in mixed file", () => {
+    const dest = tmp("gi-both-");
+    fs.writeFileSync(path.join(dest, ".gitignore"), `foo\n${GI_TMP}bar\n`);
+    mergeGitignore(dest);
+    expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe(
+      `foo\n${GI_TMP}bar\n`,
+    );
+  });
+
   it("appends after trailing newline", () => {
     const dest = tmp("gi-nl-");
     fs.writeFileSync(path.join(dest, ".gitignore"), "node_modules/\n");
     mergeGitignore(dest);
     expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe(
-      "node_modules/\n.tmp/\n",
+      `node_modules/\n${GI_TMP}`,
     );
   });
 
@@ -189,7 +220,7 @@ describe("mergeGitignore", () => {
     fs.writeFileSync(path.join(dest, ".gitignore"), "node_modules/");
     mergeGitignore(dest);
     expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe(
-      "node_modules/\n.tmp/\n",
+      `node_modules/\n${GI_TMP}`,
     );
   });
 
@@ -197,7 +228,7 @@ describe("mergeGitignore", () => {
     const dest = tmp("gi-empty-");
     fs.writeFileSync(path.join(dest, ".gitignore"), "");
     mergeGitignore(dest);
-    expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe(".tmp/\n");
+    expect(fs.readFileSync(path.join(dest, ".gitignore"), "utf8")).toBe(GI_TMP);
   });
 });
 
@@ -290,6 +321,67 @@ describe("mergeGuardedMarkdown", () => {
     );
   });
 
+  it("already-guarded package src stays begin=1 end=1", () => {
+    const pkgRoot = stubPkgRoot();
+    fs.writeFileSync(
+      path.join(pkgRoot, "CLAUDE.md"),
+      "<!-- grunt:begin -->\nCLAUDE.md content\n<!-- grunt:end -->\n",
+    );
+    const dest = tmp("md-wrapped-src-");
+    mergeGuardedMarkdown(dest, pkgRoot, "CLAUDE.md");
+    const out = fs.readFileSync(path.join(dest, "CLAUDE.md"), "utf8");
+    expect(out).toBe("<!-- grunt:begin -->\nCLAUDE.md content\n<!-- grunt:end -->\n");
+    expect(out.split("<!-- grunt:begin -->")).toHaveLength(2);
+    expect(out.split("<!-- grunt:end -->")).toHaveLength(2);
+  });
+
+  it("merge heals dest with trailing orphan grunt:end", () => {
+    const pkgRoot = stubPkgRoot();
+    const dest = tmp("md-orphan-end-");
+    fs.writeFileSync(
+      path.join(dest, "CLAUDE.md"),
+      "<!-- grunt:begin -->\nold\n<!-- grunt:end -->\n<!-- grunt:end -->\n",
+    );
+    mergeGuardedMarkdown(dest, pkgRoot, "CLAUDE.md");
+    const out = fs.readFileSync(path.join(dest, "CLAUDE.md"), "utf8");
+    expect(out).toBe("<!-- grunt:begin -->\nCLAUDE.md content\n<!-- grunt:end -->\n");
+    expect(out.split("<!-- grunt:end -->")).toHaveLength(2);
+  });
+
+  it("dest stacked researcher shape heals to exactly one pair", () => {
+    const pkgRoot = stubPkgRoot();
+    fs.writeFileSync(
+      path.join(pkgRoot, "CLAUDE.md"),
+      "<!-- grunt:begin -->\nCLAUDE.md content\n<!-- grunt:end -->\n",
+    );
+    const dest = tmp("md-stacked-");
+    fs.writeFileSync(
+      path.join(dest, "CLAUDE.md"),
+      "<!-- grunt:begin -->\n<!-- grunt:begin -->\nBODY\n<!-- grunt:end -->\n<!-- grunt:end -->\n",
+    );
+    mergeGuardedMarkdown(dest, pkgRoot, "CLAUDE.md");
+    const out = fs.readFileSync(path.join(dest, "CLAUDE.md"), "utf8");
+    expect(out).toBe("<!-- grunt:begin -->\nCLAUDE.md content\n<!-- grunt:end -->\n");
+    expect(out.split("<!-- grunt:begin -->")).toHaveLength(2);
+    expect(out.split("<!-- grunt:end -->")).toHaveLength(2);
+  });
+
+  it("dest stacked keeps user prefix/suffix outside the pair", () => {
+    const pkgRoot = stubPkgRoot();
+    const dest = tmp("md-stacked-user-");
+    fs.writeFileSync(
+      path.join(dest, "CLAUDE.md"),
+      "prefix\n<!-- grunt:begin -->\n<!-- grunt:begin -->\nBODY\n<!-- grunt:end -->\n<!-- grunt:end -->\nsuffix\n",
+    );
+    mergeGuardedMarkdown(dest, pkgRoot, "CLAUDE.md");
+    const out = fs.readFileSync(path.join(dest, "CLAUDE.md"), "utf8");
+    expect(out).toBe(
+      "<!-- grunt:begin -->\nCLAUDE.md content\n<!-- grunt:end -->\nprefix\nsuffix\n",
+    );
+    expect(out.split("<!-- grunt:begin -->")).toHaveLength(2);
+    expect(out.split("<!-- grunt:end -->")).toHaveLength(2);
+  });
+
   it("does not fuzzy-dedupe unmarked protocol-looking user text", () => {
     const pkgRoot = stubPkgRoot();
     const dest = tmp("md-proto-");
@@ -363,6 +455,23 @@ describe("snapshot/remerge guarded roots", () => {
     );
   });
 
+  it("remerge after wrapped-src merge+generate does not reattach orphan end", () => {
+    const pkgRoot = stubPkgRoot();
+    fs.writeFileSync(
+      path.join(pkgRoot, "AGENTS.md"),
+      "<!-- grunt:begin -->\nAGENTS.md content\n<!-- grunt:end -->\n",
+    );
+    const dest = tmp("snap-wrap-src-");
+    mergeGuardedMarkdown(dest, pkgRoot, "AGENTS.md");
+    const snap = snapshotGuardedRoots(dest);
+    fs.writeFileSync(path.join(dest, "AGENTS.md"), "generated agents\n");
+    remergeGuardedRoots(dest, snap);
+    const out = fs.readFileSync(path.join(dest, "AGENTS.md"), "utf8");
+    expect(out).toBe("<!-- grunt:begin -->\ngenerated agents\n<!-- grunt:end -->\n");
+    expect(out.split("<!-- grunt:begin -->")).toHaveLength(2);
+    expect(out.split("<!-- grunt:end -->")).toHaveLength(2);
+  });
+
   it("withGuardedCheckInteriors is restored even if check throws", () => {
     const dest = tmp("check-int-");
     const live =
@@ -378,6 +487,22 @@ describe("snapshot/remerge guarded roots", () => {
   });
 
   it("compose/extract/drift/write helpers cover remaining branches", () => {
+    expect(
+      extractUserMarkdown(
+        "<!-- grunt:begin -->\nbody\n<!-- grunt:end -->\n<!-- grunt:end -->\n",
+      ),
+    ).toBe("");
+    expect(
+      extractUserMarkdown(
+        "<!-- grunt:begin -->\nbody\n<!-- grunt:end -->\nkeep\n<!-- grunt:end -->\n",
+      ),
+    ).toBe("keep\n");
+    expect(
+      composeGuardedMarkdown(
+        "<!-- grunt:begin -->\nbody\n<!-- grunt:end -->\n",
+        "<!-- grunt:end -->\n",
+      ),
+    ).toBe("<!-- grunt:begin -->\nbody\n<!-- grunt:end -->\n");
     expect(composeGuardedMarkdown("body", null)).toBe(
       "<!-- grunt:begin -->\nbody\n<!-- grunt:end -->\n",
     );
@@ -402,7 +527,9 @@ describe("snapshot/remerge guarded roots", () => {
     expect(mergeGuardedContent("keep\n", "g\r\n")).toBe(
       "<!-- grunt:begin -->\ng\n<!-- grunt:end -->\nkeep\n",
     );
-    expect(mergeGuardedContent("<!-- grunt:begin --> only", "g")).toContain("only");
+    expect(mergeGuardedContent("<!-- grunt:begin --> only", "g")).toBe(
+      "<!-- grunt:begin -->\ng\n<!-- grunt:end -->\n",
+    );
     const dest = tmp("md-helpers-");
     const missing = path.join(dest, "nope.md");
     expect(guardedMarkdownDrift(missing, "g")).toBe(true);
@@ -423,6 +550,73 @@ describe("snapshot/remerge guarded roots", () => {
     expect(writeMergedGuardedFile(huge, "g")).toBe("aborted-unsafe");
   });
 
+  it("unclosed begin unwraps interior; inline orphan end is stripped", () => {
+    expect(extractGruntBody("<!-- grunt:begin -->\nhello")).toBe("hello");
+    const composed = composeGuardedMarkdown("<!-- grunt:begin -->\nhello", "");
+    expect(composed).toBe("<!-- grunt:begin -->\nhello\n<!-- grunt:end -->\n");
+    expect(composed.split(SENTINEL_BEGIN)).toHaveLength(2);
+    expect(composed.split(SENTINEL_END)).toHaveLength(2);
+    expect(composed).not.toContain(`${SENTINEL_BEGIN}\n${SENTINEL_BEGIN}`);
+    expect(mergeGuardedContent("note\n<!-- grunt:begin -->\nstale", "new")).toBe(
+      "<!-- grunt:begin -->\nnew\n<!-- grunt:end -->\nnote\n",
+    );
+    expect(extractUserMarkdown("keep <!-- grunt:end --> me")).not.toContain(SENTINEL_END);
+    expect(extractUserMarkdown("keep <!-- grunt:end --> me")).toBe("keep  me");
+    expect(extractUserMarkdown("keep\n<!-- grunt:end -->\nme")).toBe("keep\nme");
+    expect(extractUserMarkdown("keep\n  <!-- grunt:end -->  \nme")).toBe("keep\nme");
+    expect(extractGruntBody("<!-- grunt:begin -->\r\nhello")).toBe("hello");
+    expect(extractGruntBody("<!-- grunt:begin -->")).toBe("");
+    const emptyWrap = composeGuardedMarkdown("<!-- grunt:begin -->", "");
+    expect(emptyWrap.split(SENTINEL_BEGIN)).toHaveLength(2);
+    expect(emptyWrap).toBe("<!-- grunt:begin -->\n\n<!-- grunt:end -->\n");
+    const mixed =
+      "<!-- grunt:begin -->\nok\n<!-- grunt:end -->\nuser bit\n<!-- grunt:begin -->\nstale";
+    expect(extractGruntBody(mixed)).toBe("ok");
+    expect(extractUserMarkdown(mixed)).toBe("user bit\n");
+    expect(
+      composeGuardedMarkdown("<!-- grunt:begin -->\nbody\n<!-- grunt:end -->\n", ""),
+    ).toBe("<!-- grunt:begin -->\nbody\n<!-- grunt:end -->\n");
+  });
+
+  it("extract/compose peel stacked dest and trailing orphan end", () => {
+    const stacked =
+      "<!-- grunt:begin -->\n<!-- grunt:begin -->\nBODY\n<!-- grunt:end -->\n<!-- grunt:end -->\n";
+    expect(extractGruntBody(stacked)).toBe("BODY");
+    const stackedOut = composeGuardedMarkdown(stacked, "");
+    expect(stackedOut).toBe("<!-- grunt:begin -->\nBODY\n<!-- grunt:end -->\n");
+    expect(stackedOut.split(SENTINEL_BEGIN)).toHaveLength(2);
+    expect(stackedOut.split(SENTINEL_END)).toHaveLength(2);
+    expect(composeGuardedMarkdown("BODY\n<!-- grunt:end -->\n", "")).toBe(
+      "<!-- grunt:begin -->\nBODY\n<!-- grunt:end -->\n",
+    );
+    expect(extractGruntBody("BODY\n\n<!-- grunt:end -->")).toBe("BODY");
+    expect(mergeGuardedContent(stacked, "SRC")).toBe(
+      "<!-- grunt:begin -->\nSRC\n<!-- grunt:end -->\n",
+    );
+    expect(mergeGuardedContent("keep\n<!-- grunt:end -->\n", "SRC")).toBe(
+      "<!-- grunt:begin -->\nSRC\n<!-- grunt:end -->\nkeep\n",
+    );
+    expect(
+      extractGruntBody("<!-- grunt:begin --> \nBODY\n<!-- grunt:end --> \n"),
+    ).toBe("BODY");
+    expect(
+      extractGruntBody("  <!-- grunt:begin -->\nBODY\n  <!-- grunt:end -->\n"),
+    ).toBe("BODY");
+    expect(extractGruntBody("<!-- grunt:begin -->\n<!-- grunt:end -->")).toBe("");
+    expect(
+      extractGruntBody(
+        "<!-- grunt:begin -->\nsee <!-- grunt:end --> here\n<!-- grunt:end -->\n",
+      ),
+    ).toBe("see <!-- grunt:end --> here");
+    const midLine =
+      "<!-- grunt:begin -->\nBODY\n<!-- grunt:end -->\nstill user\n<!-- grunt:end -->\n";
+    expect(extractGruntBody(midLine)).toBe("BODY");
+    expect(extractUserMarkdown(midLine)).toBe("still user\n");
+    expect(composeGuardedMarkdown(extractGruntBody(midLine) ?? "", extractUserMarkdown(midLine))).toBe(
+      "<!-- grunt:begin -->\nBODY\n<!-- grunt:end -->\nstill user\n",
+    );
+  });
+
   it("remerge restores unsafe, missing, binary current, and created files", () => {
     const dest = tmp("remerge-edges-");
     const agents = path.join(dest, "AGENTS.md");
@@ -786,6 +980,13 @@ describe("mergeClaudeSettings", () => {
   });
 });
 
+describe("toGruntScriptName", () => {
+  it("prefixes unprefixed keys and does not double-prefix", () => {
+    expect(toGruntScriptName("rulesync:generate")).toBe("grunt:rulesync:generate");
+    expect(toGruntScriptName("grunt:doctor")).toBe("grunt:doctor");
+  });
+});
+
 describe("mergePackageJson", () => {
   it("creates {} dest and merges scripts skipping test, injects deps, sorts keys", () => {
     const pkgRoot = stubPkgRoot();
@@ -793,11 +994,25 @@ describe("mergePackageJson", () => {
     mergePackageJson(dest, pkgRoot);
     const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
     expect(out.scripts).toEqual({
-      alpha: "a",
-      "rulesync:generate": "gen",
-      zeta: "z",
+      "grunt:alpha": "a",
+      "grunt:antigravity": LAUNCH_SCRIPTS.antigravity,
+      "grunt:claude": LAUNCH_SCRIPTS.claude,
+      "grunt:codex": LAUNCH_SCRIPTS.codex,
+      "grunt:gemini": LAUNCH_SCRIPTS.gemini,
+      "grunt:grok": LAUNCH_SCRIPTS.grok,
+      "grunt:rulesync:generate": "gen",
+      "grunt:zeta": "z",
     });
-    expect(Object.keys(out.scripts)).toEqual(["alpha", "rulesync:generate", "zeta"]);
+    expect(Object.keys(out.scripts)).toEqual([
+      "grunt:alpha",
+      "grunt:antigravity",
+      "grunt:claude",
+      "grunt:codex",
+      "grunt:gemini",
+      "grunt:grok",
+      "grunt:rulesync:generate",
+      "grunt:zeta",
+    ]);
     expect(out.devDependencies).toEqual({
       rulesync: "latest",
       "smol-toml": "^1.8.0",
@@ -817,14 +1032,21 @@ describe("mergePackageJson", () => {
         devDependencies: { lodash: "4" },
       }),
     );
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
     mergePackageJson(dest, pkgRoot);
     const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
     expect(out.scripts.test).toBe("jest");
     expect(out.scripts.alpha).toBe("old");
+    expect(out.scripts["grunt:alpha"]).toBe("a");
+    expect(out.scripts["grunt:zeta"]).toBe("z");
     expect(out.scripts.foo).toBe("bar");
     expect(out.devDependencies.lodash).toBe("4");
     expect(out.devDependencies["smol-toml"]).toBe("^1.8.0");
     expect(out.devDependencies.rulesync).toBe("latest");
+    expect(warnSpy.mock.calls.some((c) => String(c[0]).includes("alpha") && String(c[0]).includes("untouched"))).toBe(
+      true,
+    );
+    warnSpy.mockRestore();
   });
 
   it("preserves dest suffix after an upgraded grunt script prefix", () => {
@@ -844,9 +1066,10 @@ describe("mergePackageJson", () => {
     );
     mergePackageJson(dest, pkgRoot);
     const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
-    expect(out.scripts["rulesync:generate"]).toBe(
+    expect(out.scripts["grunt:rulesync:generate"]).toBe(
       "rulesync generate -t bar && node scripts/codex-sync.mjs",
     );
+    expect(out.scripts["rulesync:generate"]).toBeUndefined();
   });
 
   it("preserves suffix after a multi-command grunt script upgrade", () => {
@@ -869,7 +1092,7 @@ describe("mergePackageJson", () => {
     );
     mergePackageJson(dest, pkgRoot);
     const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
-    expect(out.scripts["rulesync:generate"]).toBe(
+    expect(out.scripts["grunt:rulesync:generate"]).toBe(
       "rulesync generate -t bar && node scripts/emit.mjs && node scripts/codex-sync.mjs",
     );
   });
@@ -889,6 +1112,7 @@ describe("mergePackageJson", () => {
     mergePackageJson(dest, pkgRoot);
     const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
     expect(out.scripts.alpha).toBe("echo custom && extra");
+    expect(out.scripts["grunt:alpha"]).toBe("a");
     expect(warnSpy).toHaveBeenCalled();
     warnSpy.mockRestore();
   });
@@ -910,6 +1134,7 @@ describe("mergePackageJson", () => {
     mergePackageJson(dest, pkgRoot);
     const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
     expect(out.scripts["rulesync:generate"]).toBe("echo custom;echo extra");
+    expect(out.scripts["grunt:rulesync:generate"]).toBe("rulesync generate -t bar");
     expect(warnSpy).toHaveBeenCalled();
     warnSpy.mockRestore();
   });
@@ -927,7 +1152,8 @@ describe("mergePackageJson", () => {
     );
     mergePackageJson(dest, pkgRoot);
     const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
-    expect(out.scripts["rulesync:generate"]).toBe("rulesync generate -t bar");
+    expect(out.scripts["grunt:rulesync:generate"]).toBe("rulesync generate -t bar");
+    expect(out.scripts["rulesync:generate"]).toBeUndefined();
   });
 
   it("keeps dest when it already starts with the new src value plus suffix", () => {
@@ -941,7 +1167,8 @@ describe("mergePackageJson", () => {
     fs.writeFileSync(path.join(dest, "package.json"), JSON.stringify({ scripts: { "rulesync:generate": cur } }));
     mergePackageJson(dest, pkgRoot);
     const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
-    expect(out.scripts["rulesync:generate"]).toBe(cur);
+    expect(out.scripts["grunt:rulesync:generate"]).toBe(cur);
+    expect(out.scripts["rulesync:generate"]).toBeUndefined();
   });
 
   it("keeps unrelated custom script values and dest-only keys, warns on skip", () => {
@@ -957,9 +1184,11 @@ describe("mergePackageJson", () => {
     mergePackageJson(dest, pkgRoot);
     const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
     expect(out.scripts.alpha).toBe("echo custom");
+    expect(out.scripts["grunt:alpha"]).toBe("a");
     expect(out.scripts.foo).toBe("bar");
     expect(out.scripts.test).toBe("jest");
-    expect(out.scripts.zeta).toBe("z");
+    expect(out.scripts["grunt:zeta"]).toBe("z");
+    expect(out.scripts.zeta).toBeUndefined();
     expect(warnSpy.mock.calls.some((c) => String(c[0]).includes("alpha") && String(c[0]).includes("untouched"))).toBe(
       true,
     );
@@ -980,7 +1209,8 @@ describe("mergePackageJson", () => {
     const dest = tmp("pj-raw-src-");
     mergePackageJson(dest, pkgRoot);
     const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
-    expect(out.scripts["rulesync:generate"]).toBe("node ./scripts/guarded-roots.mjs generate");
+    expect(out.scripts["grunt:rulesync:generate"]).toBe("node ./scripts/guarded-roots.mjs generate");
+    expect(out.scripts["rulesync:generate"]).toBeUndefined();
     expect(out.scripts["rulesync:generate:raw"]).toBeUndefined();
     expect(out.scripts["rulesync:check:raw"]).toBeUndefined();
     expect(out.scripts["rulesync:watch:raw"]).toBeUndefined();
@@ -1001,7 +1231,7 @@ describe("mergePackageJson", () => {
     );
     mergePackageJson(dest, pkgRoot);
     const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
-    expect(out.scripts["rulesync:generate"]).toBe("node ./scripts/guarded-roots.mjs generate");
+    expect(out.scripts["grunt:rulesync:generate"]).toBe("node ./scripts/guarded-roots.mjs generate");
     expect(out.scripts["rulesync:generate:raw"]).toBe("echo consumer-raw");
   });
 
@@ -1020,7 +1250,9 @@ describe("mergePackageJson", () => {
     );
     mergePackageJson(dest, pkgRoot);
     const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
-    expect(out.scripts["rulesync:generate"]).toBe("rulesync generate -t bar");
+    expect(out.scripts["grunt:rulesync:generate"]).toBe("rulesync generate -t bar");
+    expect(out.scripts["grunt:sync:globals:apply"]).toBe("node scripts/sync-global-settings.mjs --apply");
+    expect(out.scripts["rulesync:generate"]).toBeUndefined();
   });
 
   it("early return when name is @lovrozagar/grunt", () => {
@@ -1040,9 +1272,257 @@ describe("mergePackageJson", () => {
     const dest = tmp("pj-noscripts-");
     mergePackageJson(dest, pkgRoot);
     const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
-    expect(out.scripts).toEqual({});
+    expect(out.scripts).toEqual({
+      "grunt:antigravity": LAUNCH_SCRIPTS.antigravity,
+      "grunt:claude": LAUNCH_SCRIPTS.claude,
+      "grunt:codex": LAUNCH_SCRIPTS.codex,
+      "grunt:gemini": LAUNCH_SCRIPTS.gemini,
+      "grunt:grok": LAUNCH_SCRIPTS.grok,
+    });
     expect(out.devDependencies).toEqual({ rulesync: "2", "smol-toml": "1" });
   });
+
+  it("golden autorun-apps: suffix keep, doctor move, check npm run rewrite, old keys gone", () => {
+    const pkgRoot = stubPkgRoot({
+      name: "fixture-pkg",
+      scripts: {
+        "rulesync:generate": "node ./scripts/guarded-roots.mjs generate",
+        "rulesync:watch": "node ./scripts/guarded-roots.mjs watch",
+        "rulesync:check": "node ./scripts/guarded-roots.mjs check",
+        "hooks:union": "node scripts/hooks-union.mjs",
+        "hooks:check": "node scripts/hooks-union.mjs --check",
+        doctor: "node ./scripts/doctor.mjs",
+        "rulesync:doctor": "rulesync doctor",
+        "sync:globals": "node scripts/sync-global-settings.mjs",
+        "sync:globals:check": "node scripts/check-globals.mjs",
+        "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",
+        test: "vitest run --coverage",
+      },
+      devDependencies: { "smol-toml": "^1.8.0", rulesync: "latest" },
+    });
+    const dest = tmp("pj-autorun-");
+    fs.writeFileSync(
+      path.join(dest, "package.json"),
+      JSON.stringify({
+        scripts: {
+          "apps:doctor": "node scripts/audit.mjs",
+          "apps:mental-model:viewer:build":
+            "npm --prefix scripts/excalidraw/viewer install && npm --prefix scripts/excalidraw/viewer run build",
+          check:
+            "node scripts/portability-check.mjs && npm run rulesync:check && npm run lint && npm test && node scripts/media-fixtures.mjs --check",
+          "codex:sync": "node scripts/codex-sync.mjs",
+          doctor: "node ./scripts/doctor.mjs",
+          "hooks:check": "node scripts/hooks-union.mjs --check",
+          "hooks:union": "node scripts/hooks-union.mjs",
+          lint: "eslint scripts tests eslint.config.mjs",
+          "purge:global-mcps": "node scripts/purge-global-mcps.mjs",
+          "purge:global-mcps:apply": "node scripts/purge-global-mcps.mjs --apply",
+          "rulesync:check": "node ./scripts/guarded-roots.mjs check && node scripts/codex-sync.mjs --check",
+          "rulesync:doctor": "rulesync doctor",
+          "rulesync:generate": "node ./scripts/guarded-roots.mjs generate && node scripts/codex-sync.mjs",
+          "rulesync:watch": "node ./scripts/guarded-roots.mjs watch",
+          "sync:globals": "node scripts/sync-global-settings.mjs",
+          "sync:globals:apply": "node scripts/sync-global-settings.mjs --apply",
+          "sync:globals:check": "node scripts/check-globals.mjs",
+          test: "node scripts/run-tests.mjs",
+        },
+      }),
+    );
+    mergePackageJson(dest, pkgRoot);
+    const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
+    expect(out.scripts["grunt:rulesync:generate"]).toBe(
+      "node ./scripts/guarded-roots.mjs generate && node scripts/codex-sync.mjs",
+    );
+    expect(out.scripts["grunt:rulesync:check"]).toBe(
+      "node ./scripts/guarded-roots.mjs check && node scripts/codex-sync.mjs --check",
+    );
+    expect(out.scripts["grunt:rulesync:watch"]).toBe("node ./scripts/guarded-roots.mjs watch");
+    expect(out.scripts["grunt:rulesync:doctor"]).toBe("rulesync doctor");
+    expect(out.scripts["grunt:hooks:union"]).toBe("node scripts/hooks-union.mjs");
+    expect(out.scripts["grunt:hooks:check"]).toBe("node scripts/hooks-union.mjs --check");
+    expect(out.scripts["grunt:sync:globals"]).toBe("node scripts/sync-global-settings.mjs");
+    expect(out.scripts["grunt:sync:globals:apply"]).toBe("node scripts/sync-global-settings.mjs --apply");
+    expect(out.scripts["grunt:sync:globals:check"]).toBe("node scripts/check-globals.mjs");
+    expect(out.scripts["grunt:purge:global-mcps"]).toBe("node scripts/purge-global-mcps.mjs");
+    expect(out.scripts["grunt:purge:global-mcps:apply"]).toBe("node scripts/purge-global-mcps.mjs --apply");
+    expect(out.scripts["grunt:doctor"]).toBe("node ./scripts/doctor.mjs");
+    expect(out.scripts.doctor).toBeUndefined();
+    expect(out.scripts["rulesync:generate"]).toBeUndefined();
+    expect(out.scripts["rulesync:check"]).toBeUndefined();
+    expect(out.scripts["rulesync:watch"]).toBeUndefined();
+    expect(out.scripts["hooks:union"]).toBeUndefined();
+    expect(out.scripts["sync:globals"]).toBeUndefined();
+    expect(out.scripts.check).toBe(
+      "node scripts/portability-check.mjs && npm run grunt:rulesync:check && npm run lint && npm test && node scripts/media-fixtures.mjs --check",
+    );
+    expect(out.scripts["apps:doctor"]).toBe("node scripts/audit.mjs");
+    expect(out.scripts["codex:sync"]).toBe("node scripts/codex-sync.mjs");
+    expect(out.scripts.lint).toBe("eslint scripts tests eslint.config.mjs");
+    expect(out.scripts.test).toBe("node scripts/run-tests.mjs");
+  });
+
+  it("leaves custom doctor and writes grunt:doctor from SoT", () => {
+    const pkgRoot = stubPkgRoot({
+      name: "fixture-pkg",
+      scripts: { doctor: "node ./scripts/doctor.mjs" },
+      devDependencies: { "smol-toml": "^1.8.0", rulesync: "latest" },
+    });
+    const dest = tmp("pj-custom-doctor-");
+    fs.writeFileSync(
+      path.join(dest, "package.json"),
+      JSON.stringify({ scripts: { doctor: "node scripts/audit.mjs" } }),
+    );
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    mergePackageJson(dest, pkgRoot);
+    const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
+    expect(out.scripts.doctor).toBe("node scripts/audit.mjs");
+    expect(out.scripts["grunt:doctor"]).toBe("node ./scripts/doctor.mjs");
+    expect(warnSpy).toHaveBeenCalled();
+    warnSpy.mockRestore();
+  });
+
+  it("merges destKey when both prefixed and owned legacy exist, deletes legacy", () => {
+    const pkgRoot = stubPkgRoot({
+      name: "fixture-pkg",
+      scripts: { "rulesync:generate": "rulesync generate -t bar" },
+      devDependencies: { "smol-toml": "^1.8.0", rulesync: "latest" },
+    });
+    const dest = tmp("pj-both-");
+    fs.writeFileSync(
+      path.join(dest, "package.json"),
+      JSON.stringify({
+        scripts: {
+          "rulesync:generate": "rulesync generate -t foo && node scripts/codex-sync.mjs",
+          "grunt:rulesync:generate": "rulesync generate -t old && node scripts/other.mjs",
+        },
+      }),
+    );
+    mergePackageJson(dest, pkgRoot);
+    const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
+    expect(out.scripts["grunt:rulesync:generate"]).toBe(
+      "rulesync generate -t bar && node scripts/other.mjs",
+    );
+    expect(out.scripts["rulesync:generate"]).toBeUndefined();
+  });
+
+  it("does not rewrite npm run rulesync:check:raw when only rulesync:check migrated", () => {
+    const pkgRoot = stubPkgRoot({
+      name: "fixture-pkg",
+      scripts: { "rulesync:check": "node ./scripts/guarded-roots.mjs check" },
+      devDependencies: { "smol-toml": "^1.8.0", rulesync: "latest" },
+    });
+    const dest = tmp("pj-raw-rewrite-");
+    fs.writeFileSync(
+      path.join(dest, "package.json"),
+      JSON.stringify({
+        scripts: {
+          "rulesync:check": "node ./scripts/guarded-roots.mjs check",
+          "rulesync:check:raw": "echo consumer-raw",
+          check: "npm run rulesync:check && npm run rulesync:check:raw",
+        },
+      }),
+    );
+    mergePackageJson(dest, pkgRoot);
+    const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
+    expect(out.scripts["grunt:rulesync:check"]).toBe("node ./scripts/guarded-roots.mjs check");
+    expect(out.scripts["rulesync:check"]).toBeUndefined();
+    expect(out.scripts["rulesync:check:raw"]).toBe("echo consumer-raw");
+    expect(out.scripts.check).toBe("npm run grunt:rulesync:check && npm run rulesync:check:raw");
+  });
+
+  it("skips non-string dest scripts when rewriting npm run refs", () => {
+    const pkgRoot = stubPkgRoot({
+      name: "fixture-pkg",
+      scripts: { "rulesync:check": "node ./scripts/guarded-roots.mjs check" },
+      devDependencies: { "smol-toml": "^1.8.0", rulesync: "latest" },
+    });
+    const dest = tmp("pj-nonstr-");
+    fs.writeFileSync(
+      path.join(dest, "package.json"),
+      JSON.stringify({
+        scripts: {
+          extra: 1,
+          check: "npm run rulesync:check",
+        },
+      }),
+    );
+    mergePackageJson(dest, pkgRoot);
+    const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
+    expect(out.scripts.extra).toBe(1);
+    expect(out.scripts.check).toBe("npm run grunt:rulesync:check");
+    expect(out.scripts["grunt:rulesync:check"]).toBe("node ./scripts/guarded-roots.mjs check");
+  });
+
+  it("emits grunt:claude into a consumer package.json", () => {
+    const pkgRoot = stubPkgRoot();
+    const dest = tmp("pj-launch-emit-");
+    mergePackageJson(dest, pkgRoot);
+    const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
+    expect(out.scripts["grunt:claude"]).toBe(LAUNCH_SCRIPTS.claude);
+  });
+
+  it("leaves a consumer's bare claude launcher untouched, no warn emitted", () => {
+    const pkgRoot = stubPkgRoot();
+    const dest = tmp("pj-consumer-claude-");
+    fs.writeFileSync(
+      path.join(dest, "package.json"),
+      JSON.stringify({ scripts: { claude: "npm run build && claude" } }),
+    );
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    mergePackageJson(dest, pkgRoot);
+    const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
+    expect(out.scripts.claude).toBe("npm run build && claude");
+    expect(out.scripts["grunt:claude"]).toBe(LAUNCH_SCRIPTS.claude);
+    expect(warn).not.toHaveBeenCalled();
+    warn.mockRestore();
+  });
+
+  it("does not rewrite npm run claude inside a consumer script", () => {
+    const pkgRoot = stubPkgRoot();
+    const dest = tmp("pj-npmrun-claude-");
+    fs.writeFileSync(
+      path.join(dest, "package.json"),
+      JSON.stringify({
+        scripts: { claude: "npm run build && claude", start: "npm run claude" },
+      }),
+    );
+    mergePackageJson(dest, pkgRoot);
+    const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
+    expect(out.scripts.start).toBe("npm run claude");
+  });
+
+  it("purges a stale grunt:yolo:claude with the exact old value; an edited variant survives", () => {
+    const pkgRoot = stubPkgRoot();
+    const dest = tmp("pj-purge-stale-");
+    fs.writeFileSync(
+      path.join(dest, "package.json"),
+      JSON.stringify({
+        scripts: {
+          "grunt:yolo:claude": LAUNCH_SCRIPTS.claude,
+          "grunt:yolo:codex": `${LAUNCH_SCRIPTS.codex} --extra`,
+        },
+      }),
+    );
+    mergePackageJson(dest, pkgRoot);
+    const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
+    expect(out.scripts["grunt:yolo:claude"]).toBeUndefined();
+    expect(out.scripts["grunt:claude"]).toBe(LAUNCH_SCRIPTS.claude);
+    expect(out.scripts["grunt:yolo:codex"]).toBe(`${LAUNCH_SCRIPTS.codex} --extra`);
+  });
+
+  it("drift: every bare launcher key in grunt's package.json equals LAUNCH_SCRIPTS[key]", () => {
+    const pkg = JSON.parse(
+      fs.readFileSync(
+        path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "package.json"),
+        "utf8",
+      ),
+    );
+    for (const [k, v] of Object.entries(LAUNCH_SCRIPTS)) {
+      expect(pkg.scripts[k]).toBe(v);
+    }
+  });
 });
 
 describe("init", () => {
@@ -1076,6 +1556,9 @@ describe("init", () => {
       if (d === ".claude") continue;
       expect(fs.readFileSync(path.join(dest, d, "marker"), "utf8")).toBe(d);
     }
+    expect(fs.existsSync(path.join(dest, ".rulesync", "grunt.config.jsonc"))).toBe(false);
+    expect(PRODUCT_FILES).not.toContain("grunt-config.mjs");
+    expect(fs.existsSync(path.join(dest, "scripts", "grunt-config.mjs"))).toBe(false);
     expect(fs.readFileSync(path.join(dest, ".claude", "marker"), "utf8")).toBe(".claude");
     const settings = JSON.parse(
       fs.readFileSync(path.join(dest, ".claude", "settings.json"), "utf8"),
@@ -1103,9 +1586,9 @@ describe("init", () => {
 
     expect(exec.mock.calls.map((c) => [c[0], c[1]])).toEqual([
       ["npm", ["install"]],
-      ["npm", ["run", "rulesync:generate"]],
-      ["npm", ["run", "sync:globals:apply"]],
-      ["npm", ["run", "rulesync:check"]],
+      ["npm", ["run", "grunt:rulesync:generate"]],
+      ["npm", ["run", "grunt:sync:globals:apply"]],
+      ["npm", ["run", "grunt:rulesync:check"]],
     ]);
     for (const call of exec.mock.calls) {
       expect(call[2]).toEqual({ cwd: dest, stdio: "inherit" });
@@ -1149,18 +1632,132 @@ describe("init", () => {
     expect(fs.readFileSync(path.join(pkgRoot, ".gitignore"), "utf8")).toBe(".tmp/\n");
   });
 
+  it("prunes retired 0.5 skills and agents on dest", () => {
+    const pkgRoot = stubPkgRoot();
+    const dest = tmp("grunt-prune-");
+    fs.mkdirSync(path.join(dest, ".rulesync", "skills", "solo"), { recursive: true });
+    fs.writeFileSync(path.join(dest, ".rulesync", "skills", "solo", "SKILL.md"), "old");
+    fs.mkdirSync(path.join(dest, ".rulesync", "skills", "parent"), { recursive: true });
+    fs.mkdirSync(path.join(dest, ".rulesync", "skills", "cascade"), { recursive: true });
+    fs.mkdirSync(path.join(dest, ".claude", "agents"), { recursive: true });
+    fs.writeFileSync(path.join(dest, ".claude", "agents", "implementer.md"), "old");
+    fs.writeFileSync(path.join(dest, ".claude", "agents", "thinker.md"), "old");
+    expect(RETIRED_SKILLS).toEqual(["parent", "solo", "cascade"]);
+    expect(RETIRED_AGENTS).toEqual(["implementer", "thinker"]);
+    expect(RETIRED_SCRIPTS).toEqual(["telemetry.mjs", "grunt-config.mjs"]);
+    expect(RETIRED_PATHS).toEqual([
+      ".grok/parent.md",
+      ".grok/skills/shared",
+      ".rulesync/grunt.config.jsonc",
+      ".rulesync/grunt.config.local.jsonc",
+      ".rulesync/grunt.config.local.jsonc.example",
+    ]);
+    expect(RESERVED_SKILLS).toEqual([
+      "ask",
+      "auto",
+      "browser",
+      "clasp",
+      "commit",
+      "commit-and-push",
+      "commit-push",
+      "commit-push-deploy",
+      "commit-push-release",
+      "explain",
+      "google-workspace",
+      "handoff",
+      "implement-plan",
+      "listen",
+      "pickup",
+      "speak",
+      "tmp",
+      "write-plan",
+    ]);
+    expect(RESERVED_SKILLS).not.toEqual(expect.arrayContaining(RETIRED_SKILLS));
+    init(dest, { pkgRoot, execFileSync: vi.fn() });
+    expect(fs.existsSync(path.join(dest, ".rulesync", "skills", "solo"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, ".rulesync", "skills", "parent"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, ".rulesync", "skills", "cascade"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, ".claude", "agents", "implementer.md"))).toBe(
+      false,
+    );
+    expect(fs.existsSync(path.join(dest, ".claude", "agents", "thinker.md"))).toBe(false);
+    pruneRetired(dest, { pkgRoot });
+  });
+
+  it("prunes retired scripts/paths, reserved-not-packaged skills, and grok roles; keeps consumer extras", () => {
+    const pkgRoot = stubPkgRoot();
+    fs.mkdirSync(path.join(pkgRoot, ".rulesync", "skills", "tmp"), { recursive: true });
+    fs.writeFileSync(path.join(pkgRoot, ".rulesync", "skills", "tmp", "SKILL.md"), "pkg tmp");
+    const dest = tmp("grunt-prune-extra-");
+    fs.mkdirSync(path.join(dest, ".rulesync", "skills", "tmp"), { recursive: true });
+    fs.writeFileSync(path.join(dest, ".rulesync", "skills", "tmp", "SKILL.md"), "old tmp");
+    fs.mkdirSync(path.join(dest, ".rulesync", "skills", "browser"), { recursive: true });
+    fs.writeFileSync(path.join(dest, ".rulesync", "skills", "browser", "SKILL.md"), "stale reserved");
+    fs.mkdirSync(path.join(dest, ".rulesync", "skills", "acme"), { recursive: true });
+    fs.writeFileSync(path.join(dest, ".rulesync", "skills", "acme", "SKILL.md"), "consumer");
+    fs.mkdirSync(path.join(dest, ".grok", "roles"), { recursive: true });
+    fs.writeFileSync(path.join(dest, ".grok", "roles", "implementer.toml"), "old");
+    fs.writeFileSync(path.join(dest, ".grok", "roles", "thinker.toml"), "old");
+    fs.writeFileSync(path.join(dest, ".grok", "parent.md"), "pointer");
+    fs.mkdirSync(path.join(dest, ".grok", "skills", "shared"), { recursive: true });
+    fs.mkdirSync(path.join(dest, "scripts"), { recursive: true });
+    fs.writeFileSync(path.join(dest, "scripts", "telemetry.mjs"), "old telemetry");
+    fs.writeFileSync(path.join(dest, "scripts", "grunt-config.mjs"), "old config");
+    fs.writeFileSync(path.join(dest, "scripts", "mine.mjs"), "keep");
+    fs.writeFileSync(path.join(dest, ".rulesync", "grunt.config.jsonc"), '{"version":1}\n');
+    fs.writeFileSync(path.join(dest, ".rulesync", "grunt.config.local.jsonc"), '{"sessionGate":"ask"}\n');
+    fs.writeFileSync(
+      path.join(dest, ".rulesync", "grunt.config.local.jsonc.example"),
+      '{"sessionGate":"ask"}\n',
+    );
+    fs.mkdirSync(path.join(dest, ".gemini", "agents", "implementer"), { recursive: true });
+    fs.writeFileSync(path.join(dest, ".gemini", "agents", "implementer", "agent.md"), "old");
+    init(dest, { pkgRoot, execFileSync: vi.fn() });
+    expect(fs.readFileSync(path.join(dest, ".rulesync", "skills", "tmp", "SKILL.md"), "utf8")).toBe(
+      "pkg tmp",
+    );
+    expect(fs.existsSync(path.join(dest, ".rulesync", "skills", "browser"))).toBe(false);
+    expect(fs.readFileSync(path.join(dest, ".rulesync", "skills", "acme", "SKILL.md"), "utf8")).toBe(
+      "consumer",
+    );
+    expect(fs.existsSync(path.join(dest, ".grok", "roles", "implementer.toml"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, ".grok", "roles", "thinker.toml"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, ".grok", "parent.md"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, ".grok", "skills", "shared"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, "scripts", "telemetry.mjs"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, "scripts", "grunt-config.mjs"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, ".rulesync", "grunt.config.jsonc"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, ".rulesync", "grunt.config.local.jsonc"))).toBe(false);
+    expect(
+      fs.existsSync(path.join(dest, ".rulesync", "grunt.config.local.jsonc.example")),
+    ).toBe(false);
+    expect(fs.readFileSync(path.join(dest, "scripts", "mine.mjs"), "utf8")).toBe("keep");
+    expect(fs.existsSync(path.join(dest, ".gemini", "agents", "implementer"))).toBe(false);
+  });
+
   it("omitted pkgRoot uses built-in PKG_ROOT; exec mocked", () => {
     const dest = tmp("grunt-realroot-");
     const exec = vi.fn();
     init(dest, { execFileSync: exec });
     expect(fs.existsSync(path.join(dest, "AGENTS.md"))).toBe(true);
+    const agents = fs.readFileSync(path.join(dest, "AGENTS.md"), "utf8");
+    const claude = fs.readFileSync(path.join(dest, "CLAUDE.md"), "utf8");
+    expect(agents.split("<!-- grunt:begin -->")).toHaveLength(2);
+    expect(agents.split("<!-- grunt:end -->")).toHaveLength(2);
+    expect(claude.split("<!-- grunt:begin -->")).toHaveLength(2);
+    expect(claude.split("<!-- grunt:end -->")).toHaveLength(2);
     expect(fs.existsSync(path.join(dest, "scripts", "scrub-text"))).toBe(true);
+    expect(fs.existsSync(path.join(dest, "scripts", "grunt-config.mjs"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, "scripts", "speak.mjs"))).toBe(true);
+    expect(fs.existsSync(path.join(dest, "scripts", "listen.mjs"))).toBe(true);
+    expect(fs.existsSync(path.join(dest, "scripts", "google-workspace.mjs"))).toBe(true);
     expect(fs.existsSync(path.join(dest, ".claude", "settings.json"))).toBe(true);
+    expect(fs.existsSync(path.join(dest, ".rulesync", "grunt.config.jsonc"))).toBe(false);
     expect(exec.mock.calls.map((c) => c[1])).toEqual([
       ["install"],
-      ["run", "rulesync:generate"],
-      ["run", "sync:globals:apply"],
-      ["run", "rulesync:check"],
+      ["run", "grunt:rulesync:generate"],
+      ["run", "grunt:sync:globals:apply"],
+      ["run", "grunt:rulesync:check"],
     ]);
   });
 
@@ -1171,8 +1768,8 @@ describe("init", () => {
     init(dest, { pkgRoot, execFileSync: exec, skipGlobals: true });
     expect(exec.mock.calls.map((c) => [c[0], c[1]])).toEqual([
       ["npm", ["install"]],
-      ["npm", ["run", "rulesync:generate"]],
-      ["npm", ["run", "rulesync:check"]],
+      ["npm", ["run", "grunt:rulesync:generate"]],
+      ["npm", ["run", "grunt:rulesync:check"]],
     ]);
   });
 
@@ -1187,9 +1784,9 @@ describe("init", () => {
     init(dest, { pkgRoot, execFileSync: exec, applyGlobals: true });
     expect(exec.mock.calls.map((c) => c[1])).toEqual([
       ["install"],
-      ["run", "rulesync:generate"],
-      ["run", "sync:globals:apply"],
-      ["run", "rulesync:check"],
+      ["run", "grunt:rulesync:generate"],
+      ["run", "grunt:sync:globals:apply"],
+      ["run", "grunt:rulesync:check"],
     ]);
   });
 
@@ -1204,8 +1801,8 @@ describe("init", () => {
     init(dest, { pkgRoot, execFileSync: exec });
     expect(exec.mock.calls.map((c) => c[1])).toEqual([
       ["install"],
-      ["run", "rulesync:generate"],
-      ["run", "rulesync:check"],
+      ["run", "grunt:rulesync:generate"],
+      ["run", "grunt:rulesync:check"],
     ]);
   });
 
@@ -1242,9 +1839,9 @@ describe("init", () => {
     expect(fs.existsSync(path.join(dest, "AGENTS.grunt.md"))).toBe(false);
     expect(exec.mock.calls.map((c) => c[1])).toEqual([
       ["install"],
-      ["run", "rulesync:generate"],
-      ["run", "sync:globals:apply"],
-      ["run", "rulesync:check"],
+      ["run", "grunt:rulesync:generate"],
+      ["run", "grunt:sync:globals:apply"],
+      ["run", "grunt:rulesync:check"],
     ]);
   });
 
@@ -1255,7 +1852,7 @@ describe("init", () => {
     fs.writeFileSync(path.join(dest, "CLAUDE.md"), "consumer claude\n");
     fs.writeFileSync(path.join(dest, "GEMINI.md"), "consumer gemini\n");
     const exec = vi.fn((_cmd, args) => {
-      if (Array.isArray(args) && args.includes("rulesync:generate")) {
+      if (Array.isArray(args) && args.includes("grunt:rulesync:generate")) {
         fs.writeFileSync(path.join(dest, "AGENTS.md"), "generated agents\n");
         fs.writeFileSync(path.join(dest, "CLAUDE.md"), "generated claude\n");
         fs.writeFileSync(path.join(dest, "GEMINI.md"), "@AGENTS.md\n");
@@ -1280,6 +1877,32 @@ describe("init", () => {
     );
   });
 
+  it("wrapped package src + generate clobber stays begin=1 end=1", () => {
+    const pkgRoot = stubPkgRoot();
+    for (const f of GUARDED_MD_FILES) {
+      fs.writeFileSync(
+        path.join(pkgRoot, f),
+        `<!-- grunt:begin -->\n${f} content\n<!-- grunt:end -->\n`,
+      );
+    }
+    const dest = tmp("grunt-wrap-gen-");
+    const exec = vi.fn((_cmd, args) => {
+      if (Array.isArray(args) && args.includes("grunt:rulesync:generate")) {
+        fs.writeFileSync(path.join(dest, "AGENTS.md"), "generated agents\n");
+        fs.writeFileSync(path.join(dest, "CLAUDE.md"), "generated claude\n");
+      }
+    });
+    init(dest, { pkgRoot, execFileSync: exec });
+    const agents = fs.readFileSync(path.join(dest, "AGENTS.md"), "utf8");
+    const claude = fs.readFileSync(path.join(dest, "CLAUDE.md"), "utf8");
+    expect(agents).toBe("<!-- grunt:begin -->\ngenerated agents\n<!-- grunt:end -->\n");
+    expect(claude).toBe("<!-- grunt:begin -->\ngenerated claude\n<!-- grunt:end -->\n");
+    expect(agents.split("<!-- grunt:begin -->")).toHaveLength(2);
+    expect(agents.split("<!-- grunt:end -->")).toHaveLength(2);
+    expect(claude.split("<!-- grunt:begin -->")).toHaveLength(2);
+    expect(claude.split("<!-- grunt:end -->")).toHaveLength(2);
+  });
+
   it("onPhase merge then npm phases stop before exec", () => {
     const pkgRoot = stubPkgRoot();
     const dest = tmp("grunt-onphase-");
@@ -1300,9 +1923,9 @@ describe("init", () => {
     ]);
     expect(exec.mock.calls.map((c) => c[1])).toEqual([
       ["install"],
-      ["run", "rulesync:generate"],
-      ["run", "sync:globals:apply"],
-      ["run", "rulesync:check"],
+      ["run", "grunt:rulesync:generate"],
+      ["run", "grunt:sync:globals:apply"],
+      ["run", "grunt:rulesync:check"],
     ]);
   });
 
@@ -1318,25 +1941,25 @@ describe("init", () => {
 
   it("warns when dest skill differs from packaged then force-overwrites; keeps extras", () => {
     const pkgRoot = stubPkgRoot();
-    const pkgSkill = path.join(pkgRoot, ".rulesync", "skills", "parent");
+    const pkgSkill = path.join(pkgRoot, ".rulesync", "skills", "explain");
     fs.mkdirSync(pkgSkill, { recursive: true });
-    fs.writeFileSync(path.join(pkgSkill, "SKILL.md"), "grunt-parent\n");
+    fs.writeFileSync(path.join(pkgSkill, "SKILL.md"), "grunt-explain\n");
     const dest = tmp("grunt-sk-conflict-");
-    const destSkill = path.join(dest, ".rulesync", "skills", "parent");
+    const destSkill = path.join(dest, ".rulesync", "skills", "explain");
     const destExtra = path.join(dest, ".rulesync", "skills", "my-extra");
     fs.mkdirSync(destSkill, { recursive: true });
     fs.mkdirSync(destExtra, { recursive: true });
-    fs.writeFileSync(path.join(destSkill, "SKILL.md"), "custom-parent\n");
+    fs.writeFileSync(path.join(destSkill, "SKILL.md"), "custom-explain\n");
     fs.writeFileSync(path.join(destExtra, "SKILL.md"), "keep-me\n");
     const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
     init(dest, { pkgRoot, execFileSync: vi.fn(), skipGlobals: true });
     expect(
       warnSpy.mock.calls.some(
-        (c) => String(c[0]).includes("parent") && String(c[0]).includes("re-init overwrites"),
+        (c) => String(c[0]).includes("explain") && String(c[0]).includes("re-init overwrites"),
       ),
     ).toBe(true);
     warnSpy.mockRestore();
-    expect(fs.readFileSync(path.join(destSkill, "SKILL.md"), "utf8")).toBe("grunt-parent\n");
+    expect(fs.readFileSync(path.join(destSkill, "SKILL.md"), "utf8")).toBe("grunt-explain\n");
     expect(fs.readFileSync(path.join(destExtra, "SKILL.md"), "utf8")).toBe("keep-me\n");
   });
 });