@lovrozagar/grunt 0.9.4 → 0.10.0

package/cli/init.test.ts

@@ -37,6 +37,14 @@ import {
   RETIRED_PATHS,
   RESERVED_SKILLS,
   LAUNCH_SCRIPTS,
+  HISTORICAL_SCRIPT_DEFAULTS,
+  E2E_VITEST_CONFIGS,
+  extraH2Sections,
+  mergeReferenceMarkdown,
+  snapshotReferenceDocs,
+  remergeReferenceDocs,
+  seedPipelineConfig,
+  PIPELINE_CONFIG_REL,
   mergeClaudeSettings,
   mergeGitignore,
   mergeGuardedContent,
@@ -55,6 +63,7 @@ import {
 } from "./init.mjs";
 import { UNKNOWN_PACKAGE_MANAGER } from "../scripts/package-manager.mjs";
 import { runGuardedRoots } from "../scripts/guarded-roots.mjs";
+import { COMMANDS as PIPELINE_COMMANDS } from "../scripts/pipeline.mjs";
 
 const tmpDirs: string[] = [];
 afterEach(() => {
@@ -1714,6 +1723,158 @@ describe("mergePackageJson", () => {
       expect(pkg.scripts[k]).toBe(v);
     }
   });
+
+  it("keeps customized grunt launchers that are not a known default", () => {
+    const pkgRoot = stubPkgRoot();
+    const dest = tmp("pj-keep-custom-launch-");
+    const wrapped = {
+      "grunt:antigravity": "node scripts/with-env.mjs agy --dangerously-skip-permissions",
+      "grunt:claude": "node scripts/with-env.mjs claude --dangerously-skip-permissions",
+      "grunt:codex": "node scripts/with-env.mjs codex --dangerously-bypass-approvals-and-sandbox",
+      "grunt:gemini": "node scripts/with-env.mjs gemini --yolo",
+      "grunt:grok": "node scripts/with-env.mjs grok --yolo",
+    };
+    fs.writeFileSync(path.join(dest, "package.json"), JSON.stringify({ scripts: wrapped }));
+    mergePackageJson(dest, pkgRoot);
+    const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
+    expect(out.scripts["grunt:antigravity"]).toBe(wrapped["grunt:antigravity"]);
+    expect(out.scripts["grunt:claude"]).toBe(wrapped["grunt:claude"]);
+    expect(out.scripts["grunt:codex"]).toBe(wrapped["grunt:codex"]);
+    expect(out.scripts["grunt:gemini"]).toBe(wrapped["grunt:gemini"]);
+    expect(out.scripts["grunt:grok"]).toBe(wrapped["grunt:grok"]);
+  });
+
+  it("migrates a historical bare launcher to the current default", () => {
+    const pkgRoot = stubPkgRoot();
+    const dest = tmp("pj-hist-launch-");
+    fs.writeFileSync(
+      path.join(dest, "package.json"),
+      JSON.stringify({ scripts: { "grunt:antigravity": "antigravity" } }),
+    );
+    mergePackageJson(dest, pkgRoot);
+    const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
+    expect(out.scripts["grunt:antigravity"]).toBe(LAUNCH_SCRIPTS.antigravity);
+    expect(HISTORICAL_SCRIPT_DEFAULTS.antigravity).toContain("antigravity");
+  });
+
+  it("does not add grunt:test:e2e when dest has no e2e vitest config", () => {
+    const dest = tmp("pj-noe2e-");
+    fs.writeFileSync(path.join(dest, "package.json"), JSON.stringify({ name: "app", scripts: {} }));
+    mergePackageJson(dest, PKG_ROOT);
+    const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
+    expect(out.scripts["grunt:test:e2e"]).toBeUndefined();
+    expect(out.scripts["grunt:rulesync:check"]).toBe("node ./scripts/guarded-roots.mjs check");
+  });
+
+  it("adds grunt:test:e2e when dest has a vitest e2e config", () => {
+    const dest = tmp("pj-e2e-");
+    fs.writeFileSync(path.join(dest, "package.json"), JSON.stringify({ name: "app", scripts: {} }));
+    fs.writeFileSync(path.join(dest, E2E_VITEST_CONFIGS[0]), "export default {}\n");
+    mergePackageJson(dest, PKG_ROOT);
+    const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
+    expect(out.scripts["grunt:test:e2e"]).toBe("vitest run -c vitest.e2e.config.ts");
+  });
+
+  it("keeps an existing grunt:test:e2e even without an e2e config", () => {
+    const dest = tmp("pj-e2e-keep-");
+    fs.writeFileSync(
+      path.join(dest, "package.json"),
+      JSON.stringify({ scripts: { "grunt:test:e2e": "node scripts/e2e.mjs" } }),
+    );
+    mergePackageJson(dest, PKG_ROOT);
+    const out = JSON.parse(fs.readFileSync(path.join(dest, "package.json"), "utf8"));
+    expect(out.scripts["grunt:test:e2e"]).toBe("node scripts/e2e.mjs");
+  });
+});
+
+describe("reference markdown merge", () => {
+  it("extraH2Sections keeps titles incoming does not have, including CRLF", () => {
+    const existing = "# Law\r\n\r\n## Skills naming\r\n\r\nstock\r\n\r\n## Autorun\r\n\r\ngo-live\r\n";
+    const incoming = "# Law\n\n## Skills naming\n\nstock plus su\n";
+    expect(extraH2Sections(existing, incoming)).toBe("## Autorun\n\ngo-live");
+    expect(extraH2Sections("# Law\n\nno headings\n", incoming)).toBe("");
+    expect(extraH2Sections("## \nempty title\n## Autorun\nkeep\n", incoming)).toBe("## Autorun\nkeep");
+  });
+
+  it("mergeReferenceMarkdown appends extras and normalizes a trailing newline", () => {
+    const incoming = "# Law\n\n## Skills naming\n\nstock";
+    expect(mergeReferenceMarkdown("", incoming)).toBe("# Law\n\n## Skills naming\n\nstock\n");
+    expect(mergeReferenceMarkdown("# Law\n\n## Skills naming\n\nstock\n\n## Autorun\n\nX\n", incoming)).toBe(
+      "# Law\n\n## Skills naming\n\nstock\n\n## Autorun\n\nX\n",
+    );
+  });
+
+  it("snapshotReferenceDocs skips generated maps, non-md, and directories", () => {
+    const dest = tmp("ref-snap-");
+    expect(snapshotReferenceDocs(dest)).toEqual({});
+    const dir = path.join(dest, ".rulesync", "reference");
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, "law.md"), "# Law\n");
+    fs.writeFileSync(path.join(dir, "INDEX.md"), "generated\n");
+    fs.writeFileSync(path.join(dir, "notes.txt"), "nope\n");
+    fs.mkdirSync(path.join(dir, "nested.md"));
+    expect(snapshotReferenceDocs(dest)).toEqual({ "law.md": "# Law\n" });
+  });
+
+  it("remergeReferenceDocs writes extras for packaged refs and leaves consumer-only files", () => {
+    const pkgRoot = stubPkgRoot();
+    const pkgRef = path.join(pkgRoot, ".rulesync", "reference");
+    fs.mkdirSync(pkgRef, { recursive: true });
+    fs.writeFileSync(path.join(pkgRef, "law.md"), "# Law\n\n## Skills naming\n\nstock\n");
+    const dest = tmp("ref-remerge-");
+    const destRef = path.join(dest, ".rulesync", "reference");
+    fs.mkdirSync(destRef, { recursive: true });
+    fs.writeFileSync(
+      path.join(destRef, "law.md"),
+      "# Law\n\n## Skills naming\n\nold\n\n## Autorun\n\nkeep\n",
+    );
+    fs.writeFileSync(path.join(destRef, "stripe.md"), "# Stripe\n");
+    remergeReferenceDocs(
+      dest,
+      {
+        "law.md": fs.readFileSync(path.join(destRef, "law.md"), "utf8"),
+        "stripe.md": "# Stripe\n",
+      },
+      pkgRoot,
+    );
+    expect(fs.readFileSync(path.join(destRef, "law.md"), "utf8")).toBe(
+      "# Law\n\n## Skills naming\n\nstock\n\n## Autorun\n\nkeep\n",
+    );
+    expect(fs.readFileSync(path.join(destRef, "stripe.md"), "utf8")).toBe("# Stripe\n");
+  });
+});
+
+describe("pipeline seed", () => {
+  it("writes skip overlay from dest pipeline and does not overwrite an existing file", () => {
+    const dest = tmp("pipe-seed-");
+    const skipped = PIPELINE_COMMANDS.check[1];
+    const src = `export const COMMANDS = {
+  check: [
+    ${PIPELINE_COMMANDS.check.filter((c) => c !== skipped).map((c) => JSON.stringify(c)).join(",\n    ")}
+  ],
+};
+`;
+    expect(seedPipelineConfig(dest, src)).toBe(true);
+    const cfg = path.join(dest, PIPELINE_CONFIG_REL);
+    expect(JSON.parse(fs.readFileSync(cfg, "utf8"))).toEqual({ check: { skip: [skipped] } });
+    fs.writeFileSync(cfg, '{"check":{"skip":["keep"]}}\n');
+    expect(seedPipelineConfig(dest, src)).toBe(false);
+    expect(JSON.parse(fs.readFileSync(cfg, "utf8"))).toEqual({ check: { skip: ["keep"] } });
+  });
+
+  it("skips seed when dest is not a COMMANDS module or matches stock", () => {
+    const dest = tmp("pipe-seed-skip-");
+    expect(seedPipelineConfig(dest, "")).toBe(false);
+    expect(seedPipelineConfig(dest, "console.log(1)\n")).toBe(false);
+    const stock = `export const COMMANDS = {
+  generate: [${PIPELINE_COMMANDS.generate.map((c) => JSON.stringify(c)).join(", ")}],
+  check: [${PIPELINE_COMMANDS.check.map((c) => JSON.stringify(c)).join(", ")}],
+  watch: [${PIPELINE_COMMANDS.watch.map((c) => JSON.stringify(c)).join(", ")}],
+};
+`;
+    expect(seedPipelineConfig(dest, stock)).toBe(false);
+    expect(fs.existsSync(path.join(dest, PIPELINE_CONFIG_REL))).toBe(false);
+  });
 });
 
 describe("init", () => {
@@ -1764,7 +1925,8 @@ describe("init", () => {
     expect(fs.existsSync(path.join(dest, ".mcp.json"))).toBe(false);
 
     for (const name of PRODUCT_FILES) {
-      expect(fs.statSync(path.join(dest, "scripts", name)).isFile()).toBe(true);
+      const optional = ["speak.mjs", "listen.mjs", "google-workspace.mjs"].includes(name);
+      expect(fs.existsSync(path.join(dest, "scripts", name)), name).toBe(!optional);
     }
     expect(fs.statSync(path.join(dest, "scripts", "scrub-text")).isDirectory()).toBe(true);
     expect(fs.readFileSync(path.join(dest, "scripts", "scrub-text", "inside"), "utf8")).toBe(
@@ -1875,6 +2037,7 @@ describe("init", () => {
       "google-workspace",
       "handoff",
       "implement-plan",
+      "jev",
       "listen",
       "pickup",
       "speak",
@@ -1958,9 +2121,13 @@ describe("init", () => {
     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, "scripts", "speak.mjs"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, "scripts", "listen.mjs"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, "scripts", "google-workspace.mjs"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, ".rulesync", "skills", "clasp"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, ".rulesync", "skills", "browser"))).toBe(true);
+    expect(fs.existsSync(path.join(dest, ".rulesync", "reference", "listen.md"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, ".rulesync", "grunt.features.jsonc"))).toBe(false);
     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([
@@ -1971,6 +2138,84 @@ describe("init", () => {
     ]);
   });
 
+  function writeSkill(root: string, name: string) {
+    for (const dir of [".rulesync/skills", ".grok/skills", ".claude/skills", ".agents/skills"]) {
+      fs.mkdirSync(path.join(root, dir, name), { recursive: true });
+      fs.writeFileSync(path.join(root, dir, name, "SKILL.md"), `${name}\n`);
+    }
+  }
+
+  it("copies only selected packs and drops an unselected ref instead of merging it back", () => {
+    const pkgRoot = stubPkgRoot();
+    writeSkill(pkgRoot, "ask");
+    writeSkill(pkgRoot, "listen");
+    writeSkill(pkgRoot, "speak");
+    writeSkill(pkgRoot, "clasp");
+    fs.mkdirSync(path.join(pkgRoot, ".rulesync", "reference"), { recursive: true });
+    fs.writeFileSync(path.join(pkgRoot, ".rulesync", "reference", "listen.md"), "# Listen\n\npack\n");
+    fs.writeFileSync(path.join(pkgRoot, ".rulesync", "reference", "law.md"), "# Law\n\n## Skills naming\n\nstock\n");
+    const dest = tmp("packs-default-");
+    fs.mkdirSync(path.join(dest, ".rulesync", "reference"), { recursive: true });
+    fs.writeFileSync(
+      path.join(dest, ".rulesync", "reference", "listen.md"),
+      "# Listen\n\npack\n\n## Mine\n\nkeep\n",
+    );
+    fs.writeFileSync(
+      path.join(dest, ".rulesync", "reference", "law.md"),
+      "# Law\n\n## Skills naming\n\nold\n\n## Mine\n\nkeep\n",
+    );
+    fs.mkdirSync(path.join(dest, ".grok", "skills", "clasp"), { recursive: true });
+    fs.writeFileSync(path.join(dest, ".grok", "skills", "clasp", "SKILL.md"), "old clasp\n");
+    const exec = vi.fn();
+    init(dest, { pkgRoot, execFileSync: exec, packageManager: "npm" });
+    expect(fs.readFileSync(path.join(dest, ".rulesync", "skills", "ask", "SKILL.md"), "utf8")).toBe("ask\n");
+    expect(fs.existsSync(path.join(dest, ".rulesync", "skills", "listen"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, ".grok", "skills", "speak"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, ".claude", "skills", "clasp"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, ".agents", "skills", "listen"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, ".grok", "skills", "clasp"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, "scripts", "listen.mjs"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, "scripts", "speak.mjs"))).toBe(false);
+    expect(fs.existsSync(path.join(dest, ".rulesync", "reference", "listen.md"))).toBe(false);
+    expect(fs.readFileSync(path.join(dest, ".rulesync", "reference", "law.md"), "utf8")).toContain("## Mine");
+    expect(fs.existsSync(path.join(dest, ".rulesync", "grunt.features.jsonc"))).toBe(false);
+
+    const picked = tmp("packs-listen-");
+    init(picked, { pkgRoot, execFileSync: exec, packageManager: "npm", packs: ["listen"] });
+    expect(fs.readFileSync(path.join(picked, ".rulesync", "skills", "listen", "SKILL.md"), "utf8")).toBe("listen\n");
+    expect(fs.readFileSync(path.join(picked, "scripts", "listen.mjs"), "utf8")).toBe("listen.mjs");
+    expect(fs.existsSync(path.join(picked, ".rulesync", "reference", "listen.md"))).toBe(true);
+    expect(fs.existsSync(path.join(picked, ".rulesync", "skills", "speak"))).toBe(false);
+    expect(fs.existsSync(path.join(picked, "scripts", "speak.mjs"))).toBe(false);
+    expect(JSON.parse(fs.readFileSync(path.join(picked, ".rulesync", "grunt.features.jsonc"), "utf8"))).toEqual({
+      packs: ["listen"],
+    });
+
+    const saved = tmp("packs-saved-");
+    fs.mkdirSync(path.join(saved, ".rulesync"), { recursive: true });
+    fs.writeFileSync(
+      path.join(saved, ".rulesync", "grunt.features.jsonc"),
+      '{"packs":["speak"]}\n',
+    );
+    init(saved, { pkgRoot, execFileSync: exec, packageManager: "npm" });
+    expect(fs.existsSync(path.join(saved, ".rulesync", "skills", "speak"))).toBe(true);
+    expect(fs.existsSync(path.join(saved, "scripts", "listen.mjs"))).toBe(false);
+    expect(fs.readFileSync(path.join(saved, ".rulesync", "grunt.features.jsonc"), "utf8")).toBe(
+      '{"packs":["speak"]}\n',
+    );
+
+    const pkgSelf = stubPkgRoot();
+    writeSkill(pkgSelf, "clasp");
+    fs.writeFileSync(path.join(pkgSelf, "scripts", "speak.mjs"), "keep-speak\n");
+    init(pkgSelf, { pkgRoot: pkgSelf, execFileSync: exec, packs: [] });
+    expect(fs.readFileSync(path.join(pkgSelf, ".rulesync", "skills", "clasp", "SKILL.md"), "utf8")).toBe("clasp\n");
+    expect(fs.readFileSync(path.join(pkgSelf, "scripts", "speak.mjs"), "utf8")).toBe("keep-speak\n");
+    expect(fs.existsSync(path.join(pkgSelf, ".rulesync", "grunt.features.jsonc"))).toBe(false);
+    expect(() => init(tmp("packs-bad-"), { pkgRoot, execFileSync: exec, packageManager: "npm", packs: ["nope"] })).toThrow(
+      /unknown pack/,
+    );
+  });
+
   it("--skip-globals skips sync:globals:apply", () => {
     const pkgRoot = stubPkgRoot();
     const dest = tmp("grunt-skip-globals-");
@@ -2220,6 +2465,43 @@ describe("init", () => {
     ).toThrow("emit-maps failed");
   });
 
+  it("keeps extra ## sections in dest law.md and INDEX", () => {
+    const dest = tmp("grunt-law-extra-");
+    fs.mkdirSync(path.join(dest, ".rulesync", "reference"), { recursive: true });
+    const pkgLaw = fs.readFileSync(path.join(PKG_ROOT, ".rulesync", "reference", "law.md"), "utf8");
+    fs.writeFileSync(
+      path.join(dest, ".rulesync", "reference", "law.md"),
+      `${pkgLaw.trimEnd()}\n\n## Autorun\n\npush → go-live/\n`,
+    );
+    init(dest, { execFileSync: vi.fn(), skipGlobals: true, packageManager: "npm" });
+    const law = fs.readFileSync(path.join(dest, ".rulesync", "reference", "law.md"), "utf8");
+    expect(law).toMatch(/## Skills naming/);
+    expect(law).toMatch(/## Autorun/);
+    expect(law).toMatch(/push → go-live\//);
+    const index = fs.readFileSync(path.join(dest, ".rulesync", "reference", "INDEX.md"), "utf8");
+    expect(index).toMatch(/## Autorun/);
+    expect(index).toMatch(/push → go-live\//);
+  });
+
+  it("seeds grunt.pipeline.jsonc from dest pipeline omissions during init", () => {
+    const dest = tmp("grunt-pipe-init-");
+    fs.mkdirSync(path.join(dest, "scripts"), { recursive: true });
+    const skipped = PIPELINE_COMMANDS.check.find((c) => c.includes("subagents"));
+    const src = `export const COMMANDS = {
+  check: [
+    ${PIPELINE_COMMANDS.check.filter((c) => c !== skipped).map((c) => JSON.stringify(c)).join(",\n    ")}
+  ],
+};
+`;
+    fs.writeFileSync(path.join(dest, "scripts", "pipeline.mjs"), src);
+    init(dest, { execFileSync: vi.fn(), skipGlobals: true, packageManager: "npm" });
+    const cfg = JSON.parse(fs.readFileSync(path.join(dest, PIPELINE_CONFIG_REL), "utf8"));
+    expect(cfg.check.skip).toEqual([skipped]);
+    expect(fs.readFileSync(path.join(dest, "scripts", "pipeline.mjs"), "utf8")).toContain(
+      "subagents --check",
+    );
+  });
+
   it("does not stamp package INDEX over dest; re-emits union", () => {
     const dest = tmp("grunt-index-keep-");
     fs.mkdirSync(path.join(dest, ".rulesync", "reference"), { recursive: true });
@@ -2413,16 +2695,31 @@ describe("product scripts are consumer-safe", () => {
     expect(fs.existsSync(path.join(dest, "cli"))).toBe(false);
     expect(fs.existsSync(path.join(dest, "scripts", "guarded-roots.mjs"))).toBe(true);
 
+    const optionalScripts = new Set(["speak.mjs", "listen.mjs", "google-workspace.mjs"]);
     for (const name of PRODUCT_FILES) {
       const file = path.join(dest, "scripts", name);
+      if (optionalScripts.has(name)) {
+        expect(fs.existsSync(file), name).toBe(false);
+        continue;
+      }
       expect(fs.existsSync(file), name).toBe(true);
       const text = fs.readFileSync(file, "utf8");
       for (const spec of relativeSpecs(text, RELATIVE_IMPORT_RE)) {
         const resolved = path.resolve(path.dirname(file), spec);
-        expect(fs.existsSync(resolved), `${name} -> ${spec}`).toBe(true);
+        const optional = optionalScripts.has(path.basename(resolved));
+        expect(fs.existsSync(resolved), `${name} -> ${spec}`).toBe(!optional);
       }
     }
 
+    const setupRun = spawnDest(dest, ["./scripts/setup.mjs"], {
+      ...process.env,
+      CI: "1",
+      PATH: ["/usr/bin", "/bin"].join(path.delimiter),
+    });
+    expect(`${setupRun.stdout}${setupRun.stderr}`).not.toMatch(/ERR_MODULE_NOT_FOUND/);
+    expect(setupRun.status).toBe(1);
+    expect(`${setupRun.stdout}${setupRun.stderr}`).toContain("usage: setup");
+
     const loaded = spawnDest(dest, ["./scripts/guarded-roots.mjs"]);
     expect(loaded.status).toBe(1);
     expect(loaded.stderr).toBe("usage: guarded-roots.mjs generate|check|watch\n");

package/cli/prompt.mjs

@@ -2,6 +2,7 @@ export {
   bailIfCancel,
   confirm,
   isInteractive,
+  multiselect,
   password,
   select,
   spinner,

package/cli/prompt.test.ts

@@ -1,6 +1,7 @@
 import { afterEach, describe, expect, it, vi } from "vitest";
 
 const clackSelect = vi.hoisted(() => vi.fn());
+const clackMultiselect = vi.hoisted(() => vi.fn());
 const clackConfirm = vi.hoisted(() => vi.fn());
 const clackText = vi.hoisted(() => vi.fn());
 const clackPassword = vi.hoisted(() => vi.fn());
@@ -10,6 +11,7 @@ const clackCancel = vi.hoisted(() => vi.fn());
 
 vi.mock("@clack/prompts", () => ({
   select: clackSelect,
+  multiselect: clackMultiselect,
   confirm: clackConfirm,
   text: clackText,
   password: clackPassword,
@@ -23,6 +25,7 @@ import {
   confirm,
   isInteractive,
   password,
+  multiselect,
   select,
   spinner,
   text,
@@ -164,12 +167,38 @@ describe("bailIfCancel", () => {
 describe("clack wrappers", () => {
   afterEach(() => {
     clackSelect.mockReset();
+    clackMultiselect.mockReset();
     clackConfirm.mockReset();
     clackSpinner.mockReset();
     clackIsCancel.mockReset();
     clackCancel.mockReset();
   });
 
+  it("multiselect returns the chosen packs", async () => {
+    clackMultiselect.mockResolvedValue(["listen"]);
+    clackIsCancel.mockReturnValue(false);
+    await expect(
+      multiselect({ message: "Optional packs", options: [], required: false }),
+    ).resolves.toEqual(["listen"]);
+    expect(clackMultiselect).toHaveBeenCalledWith({
+      message: "Optional packs",
+      options: [],
+      required: false,
+    });
+  });
+
+  it("multiselect cancel exits 0", async () => {
+    clackMultiselect.mockResolvedValue(Symbol("cancel"));
+    clackIsCancel.mockReturnValue(true);
+    const exit = vi.spyOn(process, "exit").mockImplementation((() => {
+      throw new Error("EXIT");
+    }) as typeof process.exit);
+    await expect(multiselect({})).rejects.toThrow("EXIT");
+    expect(clackCancel).toHaveBeenCalledWith("Aborted");
+    expect(exit).toHaveBeenCalledWith(0);
+    exit.mockRestore();
+  });
+
   it("select bails then returns", async () => {
     clackSelect.mockResolvedValue("init");
     clackIsCancel.mockReturnValue(false);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lovrozagar/grunt",
-  "version": "0.9.4",
+  "version": "0.10.0",
   "description": "Multi-agent orchestrator SoT — deep-merge rulesync trees, product scripts, and generate pipeline into a consumer repo",
   "keywords": [
     "agents",
@@ -48,9 +48,12 @@
     "scripts/scrub-text-lib.mjs",
     "scripts/session-map.mjs",
     "scripts/sync-global-settings.mjs",
+    "scripts/board.mjs",
     "scripts/browser.mjs",
+    "scripts/feature-packs.mjs",
     "scripts/speak.mjs",
     "scripts/listen.mjs",
+    "scripts/jev.mjs",
     "scripts/google-workspace.mjs",
     "scripts/interactive.mjs",
     "scripts/prompt.mjs",