@lovrozagar/grunt 0.9.5 → 0.10.1

package/cli/grunt.mjs

@@ -3,7 +3,7 @@ import { readFileSync } from "node:fs"
 import path from "node:path"
 import { fileURLToPath } from "node:url"
 import { destAlreadyInited, init, RESERVED_SKILLS, toGruntScriptName } from "./init.mjs"
-import { confirm, isInteractive, select, spinner } from "./prompt.mjs"
+import { confirm, isInteractive, multiselect, select, spinner } from "./prompt.mjs"
 import { selfUpdate } from "./self-update.mjs"
 import {
   PACKAGE_MANAGER_ASK,
@@ -14,6 +14,7 @@ import {
   runScriptArgs,
 } from "../scripts/package-manager.mjs"
 import { mapCommand } from "../scripts/folder-map.mjs"
+import { PACK_OPTIONS, parsePacksFlag, selectedPacks } from "../scripts/feature-packs.mjs"
 
 const PKG_ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), "..")
 
@@ -28,7 +29,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
@@ -42,6 +43,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 MENU_OPTIONS = [
@@ -94,6 +96,8 @@ export function parseArgv(argv) {
   let hostError = false
   let pm
   let pmError = false
+  let packs
+  let packsError = false
   const positionals = []
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i]
@@ -141,6 +145,28 @@ export function parseArgv(argv) {
       else pm = pm.toLowerCase()
       continue
     }
+    if (a === "--packs") {
+      const v = argv[i + 1]
+      if (v == null || String(v).startsWith("--")) {
+        packsError = true
+        continue
+      }
+      try {
+        packs = parsePacksFlag(v)
+      } catch {
+        packsError = true
+      }
+      i += 1
+      continue
+    }
+    if (typeof a === "string" && a.startsWith("--packs=")) {
+      try {
+        packs = parsePacksFlag(a.slice("--packs=".length))
+      } catch {
+        packsError = true
+      }
+      continue
+    }
     positionals.push(a)
   }
   return {
@@ -153,6 +179,8 @@ export function parseArgv(argv) {
     hostError,
     pm,
     pmError,
+    packs,
+    packsError,
   }
 }
 
@@ -184,9 +212,29 @@ export async function resolveCliPackageManager({ cwd, env, override, interactive
   return null
 }
 
-async function runInit(cwd, { skipGlobals, interactive, packageManager }) {
+async function askPacks(cwd) {
+  return await multiselect({
+    message: "Optional packs",
+    options: PACK_OPTIONS,
+    initialValues: selectedPacks(cwd),
+    required: false,
+  })
+}
+
+function initOpts(base, packs) {
+  if (packs === undefined) return base
+  return { ...base, packs }
+}
+
+async function runInit(cwd, { skipGlobals, interactive, packageManager, packs, packsOnly = false }) {
+  let selected = packs
+  if (packsOnly) {
+    if (selected === undefined && interactive) selected = await askPacks(cwd)
+    init(cwd, initOpts({ skipGlobals, packageManager }, selected))
+    return
+  }
   if (!interactive) {
-    init(cwd, { skipGlobals, packageManager })
+    init(cwd, initOpts({ skipGlobals, packageManager }, selected))
     return
   }
   if (destAlreadyInited(cwd)) {
@@ -196,16 +244,17 @@ async function runInit(cwd, { skipGlobals, interactive, packageManager }) {
     })
     if (!again) return
   }
+  if (selected === undefined) selected = await askPacks(cwd)
   const applyGlobals = await confirm({
     message: APPLY_GLOBALS_CONFIRM,
     initialValue: !skipGlobals,
   })
-  init(cwd, {
+  init(cwd, initOpts({
     skipGlobals: !applyGlobals,
     applyGlobals,
     onPhase: bindSpinner(),
     packageManager,
-  })
+  }, selected))
 }
 
 async function dispatch(cmd, flags, interactive, pm) {
@@ -222,6 +271,7 @@ async function dispatch(cmd, flags, interactive, pm) {
       skipGlobals: flags.skipGlobals,
       interactive: interactive && (!cmd || cmd === "init"),
       packageManager: pm,
+      packs: flags.packs,
     })
     return
   }
@@ -270,8 +320,10 @@ async function dispatch(cmd, flags, interactive, pm) {
     }
     await runInit(process.cwd(), {
       skipGlobals: flags.skipGlobals,
-      interactive: false,
+      interactive,
+      packsOnly: true,
       packageManager: pm,
+      packs: flags.packs,
     })
     process.stdout.write(`reserved: ${RESERVED_SKILLS.join(" ")}\n`)
     return
@@ -286,7 +338,7 @@ function commandNeedsPackageManager(cmd) {
 
 export async function start() {
   const flags = parseArgv(process.argv.slice(2))
-  if (flags.hostError || flags.pmError) {
+  if (flags.hostError || flags.pmError || flags.packsError) {
     process.stdout.write(USAGE)
     process.exitCode = 1
     return

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.1",
   "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",