@lovrozagar/grunt 0.9.5 → 0.10.0

package/cli/grunt.test.ts

@@ -14,7 +14,9 @@ const detectPackageManager = vi.hoisted(() => vi.fn());
 const actualDetect = vi.hoisted(() => ({ fn: null as null | ((...args: unknown[]) => unknown) }));
 const isInteractive = vi.hoisted(() => vi.fn(() => false));
 const select = vi.hoisted(() => vi.fn());
+const multiselect = vi.hoisted(() => vi.fn(async () => []));
 const confirm = vi.hoisted(() => vi.fn());
+const selectedPacks = vi.hoisted(() => vi.fn(() => [] as string[]));
 const spinner = vi.hoisted(() =>
   vi.fn(() => ({ start: vi.fn(), stop: vi.fn() })),
 );
@@ -46,10 +48,15 @@ vi.mock("../scripts/package-manager.mjs", async (importOriginal) => {
 vi.mock("./prompt.mjs", () => ({
   isInteractive,
   select,
+  multiselect,
   confirm,
   spinner,
   bailIfCancel,
 }));
+vi.mock("../scripts/feature-packs.mjs", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../scripts/feature-packs.mjs")>();
+  return { ...actual, selectedPacks };
+});
 
 import {
   PACKAGE_MANAGER_ASK,
@@ -68,7 +75,7 @@ Commands:
   sync-globals  run grunt:sync:globals (dry-run; --apply to write)
   purge-mcps    run grunt:purge:global-mcps (dry-run; --apply to write)
   doctor        run grunt:doctor
-  setup         run grunt:setup — handheld keys/OAuth (speak, listen, google-workspace, browser)
+  setup         run grunt:setup — handheld keys/OAuth (speak, listen, google-workspace, browser, jev)
   upgrade       Self-update to the latest grunt, then re-init: copy owned files, prune retired names, print reserved skills
   map [dir]     Code-only folder map (git-tracked, no files); dir for depth
   help          Show this help
@@ -82,6 +89,7 @@ Flags:
   --apply            Write for sync-globals / purge-mcps
   --host <id>        sync-globals host
   --pm <name>        npm | yarn | pnpm | bun (else lockfile, then how grunt was launched, then ask)
+  --packs <list>     Optional packs: google-workspace,listen,speak,clasp or none
 `;
 
 const pkgRoot = path.join(path.dirname(fileURLToPath(import.meta.url)), "..");
@@ -125,6 +133,10 @@ describe("start", () => {
     spinner.mockImplementation(() => ({ start: vi.fn(), stop: vi.fn() }));
     bailIfCancel.mockReset();
     bailIfCancel.mockImplementation((v) => v);
+    multiselect.mockReset();
+    multiselect.mockResolvedValue([]);
+    selectedPacks.mockReset();
+    selectedPacks.mockReturnValue([]);
   });
 
   afterEach(() => {
@@ -659,6 +671,46 @@ describe("parseArgv --pm", () => {
     });
   });
 
+  it("TTY upgrade asks packs only", async () => {
+    isInteractive.mockReturnValue(true);
+    confirm.mockClear();
+    multiselect.mockClear();
+    init.mockClear();
+    multiselect.mockResolvedValue(["listen", "speak"]);
+    process.argv = ["node", "grunt", "upgrade", "--no-self-update"];
+    await start();
+    expect(confirm).not.toHaveBeenCalled();
+    expect(multiselect).toHaveBeenCalledWith(
+      expect.objectContaining({ message: "Optional packs", required: false, initialValues: [] }),
+    );
+    expect(init).toHaveBeenCalledWith(process.cwd(), {
+      skipGlobals: false,
+      packageManager: "npm",
+      packs: ["listen", "speak"],
+    });
+  });
+
+  it("TTY init pre-checks a saved features file and skips the pack prompt when --packs is set", async () => {
+    isInteractive.mockReturnValue(true);
+    selectedPacks.mockReturnValue(["speak"]);
+    confirm.mockResolvedValue(true);
+    process.argv = ["node", "grunt", "init"];
+    await start();
+    expect(multiselect).toHaveBeenCalledWith(
+      expect.objectContaining({ initialValues: ["speak"], required: false }),
+    );
+    multiselect.mockClear();
+    confirm.mockClear();
+    init.mockClear();
+    process.argv = ["node", "grunt", "init", "--packs", "listen"];
+    await start();
+    expect(multiselect).not.toHaveBeenCalled();
+    expect(init).toHaveBeenCalledWith(
+      process.cwd(),
+      expect.objectContaining({ packs: ["listen"], applyGlobals: true }),
+    );
+  });
+
   it("missing, empty, flag, and unknown are pmError", () => {
     expect(parseArgv(["generate", "--pm"])).toMatchObject({ pmError: true });
     expect(parseArgv(["generate", "--pm="])).toMatchObject({ pmError: true });
@@ -666,3 +718,72 @@ describe("parseArgv --pm", () => {
     expect(parseArgv(["generate", "--pm", "deno"])).toMatchObject({ pmError: true });
   });
 });
+
+describe("parseArgv --packs", () => {
+  it("pair, equals, and none", () => {
+    expect(parseArgv(["init", "--packs", "speak,listen"])).toMatchObject({
+      cmd: "init",
+      packs: ["listen", "speak"],
+      packsError: false,
+    });
+    expect(parseArgv(["init", "--packs=google-workspace,clasp"])).toMatchObject({
+      packs: ["google-workspace", "clasp"],
+      packsError: false,
+    });
+    expect(parseArgv(["init", "--packs", "none"])).toMatchObject({ packs: [], packsError: false });
+    expect(parseArgv(["init", "--packs="])).toMatchObject({ packs: [], packsError: false });
+  });
+
+  it("missing, flag, and unknown are packsError", () => {
+    expect(parseArgv(["init", "--packs"])).toMatchObject({ packsError: true });
+    expect(parseArgv(["init", "--packs", "--yes"])).toMatchObject({ packsError: true });
+    expect(parseArgv(["init", "--packs", "nope"])).toMatchObject({ packsError: true });
+    expect(parseArgv(["init", "--packs=nope"])).toMatchObject({ packsError: true });
+  });
+
+  it("unknown --packs writes usage", async () => {
+    const lines: string[] = [];
+    const stdoutWrite = process.stdout.write;
+    const exitCode = process.exitCode;
+    const argv = process.argv.slice();
+    process.stdout.write = ((buf: string | Uint8Array) => {
+      lines.push(String(buf));
+      return true;
+    }) as typeof process.stdout.write;
+    process.exitCode = 0;
+    process.argv = ["node", "grunt", "init", "--packs", "nope"];
+    init.mockClear();
+    try {
+      await start();
+      expect(lines.join("")).toBe(USAGE);
+      expect(process.exitCode).toBe(1);
+      expect(init).not.toHaveBeenCalled();
+    } finally {
+      process.stdout.write = stdoutWrite;
+      process.exitCode = exitCode;
+      process.argv = argv;
+    }
+  });
+
+  it("TTY upgrade with --packs skips the pack prompt", async () => {
+    isInteractive.mockReturnValue(true);
+    multiselect.mockClear();
+    confirm.mockClear();
+    init.mockClear();
+    process.argv = ["node", "grunt", "upgrade", "--no-self-update", "--packs", "listen"];
+    const stdoutWrite = process.stdout.write;
+    process.stdout.write = (() => true) as typeof process.stdout.write;
+    try {
+      await start();
+      expect(multiselect).not.toHaveBeenCalled();
+      expect(confirm).not.toHaveBeenCalled();
+      expect(init).toHaveBeenCalledWith(process.cwd(), {
+        skipGlobals: false,
+        packageManager: "npm",
+        packs: ["listen"],
+      });
+    } finally {
+      process.stdout.write = stdoutWrite;
+    }
+  });
+});

package/cli/init.mjs

@@ -31,6 +31,14 @@ import {
   runScriptArgs,
 } from "../scripts/package-manager.mjs"
 import { LAW_REL, emitMaps } from "../scripts/emit-maps.mjs"
+import {
+  isUnselectedPackPath,
+  resolvePackSelection,
+  unselectedPackRels,
+  unselectedRefNames,
+  unselectedScriptNames,
+  writePacks,
+} from "../scripts/feature-packs.mjs"
 
 export {
   GUARDED_ROOT_FILES,
@@ -78,9 +86,12 @@ export const PRODUCT_SCRIPTS = [
   "scrub-text-lib.mjs",
   "session-map.mjs",
   "sync-global-settings.mjs",
+  "board.mjs",
   "browser.mjs",
+  "feature-packs.mjs",
   "speak.mjs",
   "listen.mjs",
+  "jev.mjs",
   "google-workspace.mjs",
   "interactive.mjs",
   "prompt.mjs",
@@ -120,6 +131,7 @@ export const RESERVED_SKILLS = [
   "google-workspace",
   "handoff",
   "implement-plan",
+  "jev",
   "listen",
   "pickup",
   "speak",
@@ -388,10 +400,11 @@ export function snapshotReferenceDocs(dest) {
   return snap
 }
 
-export function remergeReferenceDocs(dest, snap, pkgRoot) {
+export function remergeReferenceDocs(dest, snap, pkgRoot, skip = new Set()) {
   const pkgDir = path.join(pkgRoot, REFERENCE_REL)
   const destDir = path.join(dest, REFERENCE_REL)
   for (const [name, existing] of Object.entries(snap)) {
+    if (skip.has(name)) continue
     const pkgFile = path.join(pkgDir, name)
     if (!fs.existsSync(pkgFile)) continue
     const incoming = fs.readFileSync(pkgFile, "utf8")
@@ -555,7 +568,7 @@ export function resolveInitPackageManager(dest, { packageManager, env = process.
   return detected.manager
 }
 
-export function init(dest, { pkgRoot: pkgRootOpt, execFileSync: exec = execFileSync, skipGlobals = false, applyGlobals, onPhase, packageManager, env = process.env } = {}) {
+export function init(dest, { pkgRoot: pkgRootOpt, execFileSync: exec = execFileSync, skipGlobals = false, applyGlobals, onPhase, packageManager, env = process.env, packs } = {}) {
   dest = path.resolve(dest)
   const pkgRoot = path.resolve(pkgRootOpt ?? PKG_ROOT)
   const skipGlobalsApply =
@@ -571,6 +584,9 @@ export function init(dest, { pkgRoot: pkgRootOpt, execFileSync: exec = execFileS
   }
 
   const self = samePath(dest, pkgRoot)
+  const selection = self ? { packs: [], answered: false } : resolvePackSelection(dest, packs)
+  const selected = new Set(selection.packs)
+  const allowPack = (src) => !isUnselectedPackPath(path.relative(pkgRoot, src), selected)
 
   phase("merge", () => {
     const wsSkills = path.join(dest, WORKSPACE_SKILLS_REL)
@@ -597,12 +613,12 @@ export function init(dest, { pkgRoot: pkgRootOpt, execFileSync: exec = execFileS
       fs.mkdirSync(d, { recursive: true })
       if (samePath(src, d)) continue
       if (dir === ".claude") {
-        copyTree(src, d, (s) => path.basename(s) !== "settings.json")
+        copyTree(src, d, (s) => path.basename(s) !== "settings.json" && allowPack(s))
         mergeClaudeSettings(dest, pkgRoot)
       } else if (dir === ".rulesync") {
-        copyTree(src, d, (s) => !GENERATED_MAP_FILES.has(path.basename(s)))
+        copyTree(src, d, (s) => !GENERATED_MAP_FILES.has(path.basename(s)) && allowPack(s))
       } else {
-        copyTree(src, d)
+        copyTree(src, d, allowPack)
       }
     }
 
@@ -613,7 +629,9 @@ export function init(dest, { pkgRoot: pkgRootOpt, execFileSync: exec = execFileS
     }
 
     fs.mkdirSync(path.join(dest, "scripts"), { recursive: true })
+    const skipScripts = unselectedScriptNames(selected)
     for (const name of PRODUCT_SCRIPTS) {
+      if (skipScripts.has(name)) continue
       const src = path.join(pkgRoot, "scripts", name)
       const d = path.join(dest, "scripts", name)
       if (samePath(src, d)) continue
@@ -624,10 +642,14 @@ export function init(dest, { pkgRoot: pkgRootOpt, execFileSync: exec = execFileS
     mergeGitignore(dest)
 
     if (!self) {
-      remergeReferenceDocs(dest, refSnap, pkgRoot)
+      remergeReferenceDocs(dest, refSnap, pkgRoot, unselectedRefNames(selected))
       seedPipelineConfig(dest, destPipelineSrc)
       mergePackageJson(dest, pkgRoot)
       copyRootIfMissing(dest, pkgRoot)
+      for (const rel of unselectedPackRels(selected)) {
+        fs.rmSync(path.join(dest, rel), { recursive: true, force: true })
+      }
+      if (selection.answered) writePacks(dest, selection.packs)
       emitDestMaps(dest)
     }
   })

package/cli/init.test.ts

@@ -1925,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(
@@ -2036,6 +2037,7 @@ describe("init", () => {
       "google-workspace",
       "handoff",
       "implement-plan",
+      "jev",
       "listen",
       "pickup",
       "speak",
@@ -2119,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([
@@ -2132,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-");
@@ -2611,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.5",
+  "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",