@mthanh/vespercli 1.8.0 → 2.0.0

package/scripts/packs-layout.test.js

@@ -0,0 +1,378 @@
+/**
+ * Epic H — the core + packs catalog layout, as the generator, the plugin manifests, the
+ * marketplace, `assets/manifest.json` and `assets/CATALOG.md` see it. Each test names the
+ * mutation it kills.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, mkdir, writeFile, readFile, readdir, rm, cp } from 'node:fs/promises';
+import { existsSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import {
+  ASSETS_DIR,
+  buildCopilotTree,
+  listPackNames,
+  expectedSharedPackSkillFiles,
+  syncSharedPackSkills,
+  SHARED_PACK_SKILLS,
+  PACK_PLUGIN_PREFIX,
+  SCAN_ROOT_RELATIVE_PATHS,
+  UPSTREAM_RECORD_FILE,
+  isThirdPartySkillDir,
+} from './generate-claude-assets.js';
+
+const PKG_VERSION = JSON.parse(readFileSync(join(ASSETS_DIR, '..', 'package.json'), 'utf-8')).version;
+const manifest = JSON.parse(readFileSync(join(ASSETS_DIR, 'manifest.json'), 'utf-8'));
+const marketplace = JSON.parse(readFileSync(join(ASSETS_DIR, 'claude', '.claude-plugin', 'marketplace.json'), 'utf-8'));
+
+describe('pack plugins and the marketplace', () => {
+  it('ships the seven decided packs — the six stack packs plus the opt-in styles pack (kills: a pack dir dropped or renamed)', async () => {
+    expect(await listPackNames()).toEqual(['backend', 'docs', 'frontend', 'integrations', 'playwright', 'polyglot', 'styles']);
+  });
+
+  it('every pack has a valid plugin.json named vesper-<pack> at the package version (kills: a stale pack version)', async () => {
+    for (const pack of await listPackNames()) {
+      const p = JSON.parse(await readFile(join(ASSETS_DIR, 'claude', 'packs', pack, '.claude-plugin', 'plugin.json'), 'utf-8'));
+      expect(p.name, pack).toBe(`${PACK_PLUGIN_PREFIX}${pack}`);
+      expect(p.version, pack).toBe(PKG_VERSION);
+      expect(typeof p.description).toBe('string');
+    }
+  });
+
+  it('the marketplace lists the core plugin (source ./) and every pack (source ./packs/<pack>), nothing else', async () => {
+    const packs = await listPackNames();
+    const listed = Object.fromEntries(marketplace.plugins.map((p) => [p.name, p.source]));
+    expect(listed.vesper).toBe('./');
+    for (const pack of packs) expect(listed[`vesper-${pack}`], pack).toBe(`./packs/${pack}`);
+    expect(Object.keys(listed).sort()).toEqual(['vesper', ...packs.map((p) => `vesper-${p}`)].sort());
+    for (const p of marketplace.plugins) expect(p.version, p.name).toBe(PKG_VERSION);
+  });
+
+  it('a pack holds only agents/, skills/ and .claude-plugin/ — nothing the core plugin root would double-scan', async () => {
+    for (const pack of await listPackNames()) {
+      const children = (await readdir(join(ASSETS_DIR, 'claude', 'packs', pack))).sort();
+      for (const c of children) expect(['.claude-plugin', 'agents', 'skills'], `${pack}/${c}`).toContain(c);
+    }
+    // The packs root is NOT a standard component dir of the core plugin (agents/, skills/,
+    // commands/, hooks/ …), so Claude Code never loads a pack twice through `vesper`.
+    expect(SCAN_ROOT_RELATIVE_PATHS.packs).toBe('claude/packs');
+    expect(['agents', 'skills', 'commands', 'hooks', 'output-styles', 'workflows', 'themes', 'monitors', 'bin']).not.toContain('packs');
+  });
+});
+
+describe('the manifest carries the pack of every asset', () => {
+  it('lists the packs and a pack (core or a pack name) for EVERY agent and skill (kills: assetPacks dropped)', async () => {
+    expect(manifest.packs).toEqual(await listPackNames());
+    for (const a of manifest.agents) expect(['core', ...manifest.packs], a).toContain(manifest.assetPacks.agents[a]);
+    for (const s of manifest.skills) expect(['core', ...manifest.packs], s).toContain(manifest.assetPacks.skills[s]);
+    expect(Object.keys(manifest.assetPacks.agents).sort()).toEqual([...manifest.agents].sort());
+    expect(Object.keys(manifest.assetPacks.skills).sort()).toEqual([...manifest.skills].sort());
+  });
+
+  it('matches the on-disk pack of each asset (kills: a manifest that says core for a packed asset)', async () => {
+    for (const [name, pack] of Object.entries(manifest.assetPacks.agents)) {
+      const abs = pack === 'core' ? join(ASSETS_DIR, 'claude', 'agents', `${name}.md`) : join(ASSETS_DIR, 'claude', 'packs', pack, 'agents', `${name}.md`);
+      expect(existsSync(abs), `${name} → ${pack}`).toBe(true);
+    }
+    for (const [name, pack] of Object.entries(manifest.assetPacks.skills)) {
+      const abs = pack === 'core' ? join(ASSETS_DIR, 'claude', 'skills', name) : join(ASSETS_DIR, 'claude', 'packs', pack, 'skills', name);
+      expect(existsSync(abs), `${name} → ${pack}`).toBe(true);
+    }
+  });
+
+  it('pins the decided cut (kills: an asset moved to the wrong pack)', () => {
+    const a = manifest.assetPacks.agents;
+    const s = manifest.assetPacks.skills;
+    expect(a['expert-react-frontend-engineer']).toBe('frontend');
+    expect(a['jest-react-test-runner']).toBe('frontend');
+    expect(a['playwright-tester']).toBe('playwright');
+    expect(a['nodejs-express-developer']).toBe('backend');
+    expect(a['firebase-developer']).toBe('backend');
+    expect(a['clickup-agent']).toBe('integrations');
+    for (const core of ['code-reviewer', 'vitest', 'workspace-learner', 'feature-wrap-document', 'principal-software-engineer']) expect(a[core], core).toBe('core');
+    expect(s['agent-fundamentals']).toBe('core');
+    expect(s.reactjs).toBe('frontend');
+    expect(s['chrome-devtools']).toBe('playwright');
+    expect(s['backend-development']).toBe('backend');
+    expect(s.java).toBe('polyglot');
+    expect(s['document-skills']).toBe('docs');
+    expect(s['gitlab-guardrails']).toBe('integrations');
+    expect(s['nodejs-javascript-vitest']).toBe('core');
+    // Epic J: the third-party skills are pack content — the GitLab pair in integrations, the
+    // opt-in styles in their own pack. Never core.
+    expect(s['gitlab-ci-skill']).toBe('integrations');
+    expect(s['github-actions-to-gitlab-ci']).toBe('integrations');
+    expect(s['i-have-adhd']).toBe('styles');
+    expect(s.ponytail).toBe('styles');
+    expect(Object.values(a).filter((p) => p === 'core')).toHaveLength(18);
+    expect(Object.values(s).filter((p) => p === 'core')).toHaveLength(20);
+  });
+});
+
+describe('epic J — third-party skills are pack content with an UPSTREAM.json', () => {
+  const THIRD_PARTY = Object.freeze({
+    'gitlab-ci-skill': 'integrations',
+    'github-actions-to-gitlab-ci': 'integrations',
+    'i-have-adhd': 'styles',
+    ponytail: 'styles',
+  });
+
+  it('every third-party skill ships UPSTREAM.json (git url, 40-hex sha, ISO date, license, path) and its LICENSE; nothing ships under assets/vendor (kills: a record dropped; a snapshot moved back)', async () => {
+    expect(existsSync(join(ASSETS_DIR, 'vendor'))).toBe(false);
+    for (const [skill, pack] of Object.entries(THIRD_PARTY)) {
+      const dir = join(ASSETS_DIR, 'claude', 'packs', pack, 'skills', skill);
+      expect(existsSync(join(dir, 'SKILL.md')), skill).toBe(true);
+      expect(existsSync(join(dir, 'LICENSE')), skill).toBe(true);
+      expect(existsSync(join(dir, 'VENDOR.md')), skill).toBe(false);
+      const rec = JSON.parse(await readFile(join(dir, UPSTREAM_RECORD_FILE), 'utf-8'));
+      expect(rec.upstream, skill).toMatch(/^https:\/\/(gitlab\.com|github\.com)\//);
+      expect(rec.sha, skill).toMatch(/^[0-9a-f]{40}$/);
+      expect(rec.retrieved, skill).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+      expect(rec.license, skill).toBe('MIT');
+      expect(typeof rec.path, skill).toBe('string');
+      expect(isThirdPartySkillDir(dir)).toBe(true);
+    }
+    expect(isThirdPartySkillDir(join(ASSETS_DIR, 'claude', 'packs', 'integrations', 'skills', 'gitlab-guardrails'))).toBe(false);
+  });
+
+  it('the Copilot mirror carries each third-party skill VERBATIM, UPSTREAM.json and LICENSE included, and never an instruction for it (kills: a rendered or scanned third-party file)', async () => {
+    const { files, errors } = await buildCopilotTree();
+    expect(errors).toEqual([]);
+    for (const [skill, pack] of Object.entries(THIRD_PARTY)) {
+      const src = join(ASSETS_DIR, 'claude', 'packs', pack, 'skills', skill);
+      for (const rel of ['SKILL.md', 'LICENSE', UPSTREAM_RECORD_FILE]) {
+        const out = files.get(`packs/${pack}/skills/${skill}/${rel}`);
+        expect(out, `${skill}/${rel}`).toBeDefined();
+        expect(out.content.equals(await readFile(join(src, rel))), `${skill}/${rel} verbatim`).toBe(true);
+      }
+      expect(files.has(`instructions/${skill}.instructions.md`)).toBe(false);
+      expect(files.has(`instructions-extended/${skill}/${skill}.instructions.md`)).toBe(false);
+    }
+  });
+
+  it('the styles pack is skills-only, opt-in, and listed in the marketplace like every pack (kills: styles wired as a core skill)', async () => {
+    const children = (await readdir(join(ASSETS_DIR, 'claude', 'packs', 'styles'))).sort();
+    expect(children).toEqual(['.claude-plugin', 'skills']);
+    expect((await readdir(join(ASSETS_DIR, 'claude', 'packs', 'styles', 'skills'))).sort()).toEqual(['agent-fundamentals', 'i-have-adhd', 'ponytail']);
+    expect(marketplace.plugins.find((p) => p.name === 'vesper-styles')).toMatchObject({ source: './packs/styles', version: PKG_VERSION });
+    expect(manifest.packs).toContain('styles');
+  });
+
+  it('strict: a third-party skill in the CORE tree, or one without a valid record / LICENSE, is an error (kills: unchecked records)', async () => {
+    const fx = await mkdtemp(join(tmpdir(), 'vesper-packs-tp-'));
+    try {
+      const SKILL = (n) => `---\nname: ${n}\ndescription: 'A skill.'\ndisable-model-invocation: true\n---\nSee .claude/skills/${n} and vesper:code-reviewer.\n`;
+      await mkdir(join(fx, 'claude', 'skills', 'agent-fundamentals'), { recursive: true });
+      await writeFile(join(fx, 'claude', 'skills', 'agent-fundamentals', 'SKILL.md'), '---\nname: agent-fundamentals\ndescription: \'x\'\n---\nBody.\n');
+      await mkdir(join(fx, 'claude', '.claude-plugin'), { recursive: true });
+      await writeFile(join(fx, 'claude', '.claude-plugin', 'marketplace.json'), JSON.stringify({ name: 'vesper-marketplace', plugins: [{ name: 'vesper', source: './' }, { name: 'vesper-tp', source: './packs/tp' }] }));
+      const pack = join(fx, 'claude', 'packs', 'tp');
+      await mkdir(join(pack, '.claude-plugin'), { recursive: true });
+      await writeFile(join(pack, '.claude-plugin', 'plugin.json'), JSON.stringify({ name: 'vesper-tp', version: '0.0.0' }));
+      await mkdir(join(pack, 'skills', 'agent-fundamentals'), { recursive: true });
+      await writeFile(join(pack, 'skills', 'agent-fundamentals', 'SKILL.md'), '---\nname: agent-fundamentals\ndescription: \'x\'\n---\nBody.\n');
+      await mkdir(join(fx, 'claude-committed', 'skills', 'm'), { recursive: true });
+      await writeFile(join(fx, 'claude-committed', 'skills', 'm', 'SKILL.md'), '---\nname: m\ndescription: \'Maintain.\'\ndisable-model-invocation: true\n---\nRun it.\n');
+      const record = { upstream: 'https://example.com/x', sha: 'a'.repeat(40), retrieved: '2026-01-01', license: 'MIT', path: '/' };
+      // A valid third-party pack skill: the marker, the residue-looking text and the record are all fine.
+      await mkdir(join(pack, 'skills', 'tp-skill'), { recursive: true });
+      await writeFile(join(pack, 'skills', 'tp-skill', 'SKILL.md'), SKILL('tp-skill'));
+      await writeFile(join(pack, 'skills', 'tp-skill', 'LICENSE'), 'MIT\n');
+      await writeFile(join(pack, 'skills', 'tp-skill', 'UPSTREAM.json'), JSON.stringify(record));
+      const ok = await buildCopilotTree({ assetsDir: fx });
+      expect(ok.errors).toEqual([]);
+      expect(ok.files.get('packs/tp/skills/tp-skill/SKILL.md').content.toString('utf-8')).toBe(SKILL('tp-skill'));
+      expect(ok.manifest.assetPacks.skills['tp-skill']).toBe('tp');
+      // A bad sha and a missing LICENSE are errors.
+      await writeFile(join(pack, 'skills', 'tp-skill', 'UPSTREAM.json'), JSON.stringify({ ...record, sha: 'nope' }));
+      await rm(join(pack, 'skills', 'tp-skill', 'LICENSE'));
+      const bad = await buildCopilotTree({ assetsDir: fx });
+      expect(bad.errors.some((e) => e.includes('tp-skill/UPSTREAM.json') && e.includes('40-hex'))).toBe(true);
+      expect(bad.errors.some((e) => e.includes('tp-skill') && e.includes('LICENSE'))).toBe(true);
+      // A third-party skill in the core tree is refused.
+      await mkdir(join(fx, 'claude', 'skills', 'core-tp'), { recursive: true });
+      await writeFile(join(fx, 'claude', 'skills', 'core-tp', 'SKILL.md'), '---\nname: core-tp\ndescription: \'x\'\n---\nBody.\n');
+      await writeFile(join(fx, 'claude', 'skills', 'core-tp', 'LICENSE'), 'MIT\n');
+      await writeFile(join(fx, 'claude', 'skills', 'core-tp', 'UPSTREAM.json'), JSON.stringify(record));
+      const core = await buildCopilotTree({ assetsDir: fx });
+      expect(core.errors.some((e) => e.includes('claude/skills/core-tp') && e.includes('never core'))).toBe(true);
+    } finally {
+      await rm(fx, { recursive: true, force: true });
+    }
+  });
+});
+
+describe('the Copilot mirror of the packs', () => {
+  it('emits packs/<pack>/agents and packs/<pack>/skills for every packed asset, and never the shared skill copies', async () => {
+    const { files, errors } = await buildCopilotTree();
+    expect(errors).toEqual([]);
+    for (const [name, pack] of Object.entries(manifest.assetPacks.agents)) {
+      expect(files.has(pack === 'core' ? `agents/${name}.agent.md` : `packs/${pack}/agents/${name}.agent.md`), name).toBe(true);
+    }
+    // A composite skill (`debugging`, `document-skills`, …) keeps its SKILL.md files nested, so
+    // "emitted" means any file under the skill folder.
+    const keys = [...files.keys()];
+    for (const [name, pack] of Object.entries(manifest.assetPacks.skills)) {
+      const prefix = pack === 'core' ? `skills/${name}/` : `packs/${pack}/skills/${name}/`;
+      expect(keys.some((k) => k.startsWith(prefix)), name).toBe(true);
+    }
+    for (const pack of manifest.packs) {
+      for (const shared of SHARED_PACK_SKILLS) expect(files.has(`packs/${pack}/skills/${shared}/SKILL.md`), `${pack}/${shared}`).toBe(false);
+    }
+    // Nothing packed leaks into the flat core folders.
+    for (const [name, pack] of Object.entries(manifest.assetPacks.agents)) {
+      if (pack !== 'core') expect(files.has(`agents/${name}.agent.md`), name).toBe(false);
+    }
+  });
+
+  it('the committed tree has exactly those pack folders on disk', async () => {
+    const onDisk = (await readdir(join(ASSETS_DIR, 'copilot', 'packs'))).sort();
+    expect(onDisk).toEqual(manifest.packs);
+  });
+});
+
+describe('the shared pack skills are byte-identical copies of the core', () => {
+  it('every pack carries agent-fundamentals equal to the core (kills: a drifted copy)', async () => {
+    const expected = await expectedSharedPackSkillFiles();
+    expect(expected.size).toBeGreaterThan(0);
+    for (const [rel, content] of expected) {
+      const abs = join(ASSETS_DIR, 'claude', ...rel.split('/'));
+      expect(existsSync(abs), rel).toBe(true);
+      expect((await readFile(abs)).equals(content), rel).toBe(true);
+    }
+  });
+
+  it('the generator reports a drifted copy and syncSharedPackSkills repairs it (fixture copy of the real tree)', async () => {
+    const fx = await mkdtemp(join(tmpdir(), 'vesper-packs-fx-'));
+    try {
+      await cp(join(ASSETS_DIR, 'claude'), join(fx, 'claude'), { recursive: true });
+      await cp(join(ASSETS_DIR, 'claude-committed'), join(fx, 'claude-committed'), { recursive: true });
+      const [pack] = await listPackNames(fx);
+      const drifted = join(fx, 'claude', 'packs', pack, 'skills', SHARED_PACK_SKILLS[0], 'SKILL.md');
+      await writeFile(drifted, `${await readFile(drifted, 'utf-8')}\ndrift\n`);
+      const before = await buildCopilotTree({ assetsDir: fx });
+      expect(before.errors.some((e) => e.includes(`packs/${pack}/skills/${SHARED_PACK_SKILLS[0]}/SKILL.md`) && e.includes('differs'))).toBe(true);
+      const changed = await syncSharedPackSkills({ assetsDir: fx });
+      expect(changed).toEqual([`claude/packs/${pack}/skills/${SHARED_PACK_SKILLS[0]}/SKILL.md`]);
+      const after = await buildCopilotTree({ assetsDir: fx });
+      expect(after.errors).toEqual([]);
+    } finally {
+      await rm(fx, { recursive: true, force: true });
+    }
+  });
+});
+
+describe('strict pack validation on a fixture', () => {
+  let fx;
+  beforeEach(async () => { fx = await mkdtemp(join(tmpdir(), 'vesper-packs-strict-')); });
+  afterEach(async () => { await rm(fx, { recursive: true, force: true }); });
+
+  const AGENT = (n) => `---\nname: ${n}\ndescription: 'An agent.'\nmodel: claude-sonnet-5\n---\nBody.\n`;
+  const SKILL = (n) => `---\nname: ${n}\ndescription: 'A skill.'\n---\nBody.\n`;
+  const MAINT = '---\nname: m\ndescription: \'Maintain.\'\ndisable-model-invocation: true\n---\nRun it.\n';
+
+  async function tree({ packName = 'demo', pluginName = 'vesper-demo', duplicateAgent = false, extraDir = null } = {}) {
+    await mkdir(join(fx, 'claude', 'agents'), { recursive: true });
+    await writeFile(join(fx, 'claude', 'agents', 'core-agent.md'), AGENT('core-agent'));
+    await mkdir(join(fx, 'claude', 'skills', 'agent-fundamentals'), { recursive: true });
+    await writeFile(join(fx, 'claude', 'skills', 'agent-fundamentals', 'SKILL.md'), SKILL('agent-fundamentals'));
+    await mkdir(join(fx, 'claude', '.claude-plugin'), { recursive: true });
+    await writeFile(join(fx, 'claude', '.claude-plugin', 'marketplace.json'), JSON.stringify({
+      name: 'vesper-marketplace', plugins: [{ name: 'vesper', source: './' }, { name: `vesper-${packName}`, source: `./packs/${packName}` }],
+    }));
+    const pack = join(fx, 'claude', 'packs', packName);
+    await mkdir(join(pack, '.claude-plugin'), { recursive: true });
+    await writeFile(join(pack, '.claude-plugin', 'plugin.json'), JSON.stringify({ name: pluginName, version: '0.0.0' }));
+    await mkdir(join(pack, 'agents'), { recursive: true });
+    await writeFile(join(pack, 'agents', duplicateAgent ? 'core-agent.md' : 'packed-agent.md'), AGENT(duplicateAgent ? 'core-agent' : 'packed-agent'));
+    await mkdir(join(pack, 'skills', 'packed-skill'), { recursive: true });
+    await writeFile(join(pack, 'skills', 'packed-skill', 'SKILL.md'), SKILL('packed-skill'));
+    await mkdir(join(pack, 'skills', 'agent-fundamentals'), { recursive: true });
+    await writeFile(join(pack, 'skills', 'agent-fundamentals', 'SKILL.md'), SKILL('agent-fundamentals'));
+    if (extraDir) await mkdir(join(pack, extraDir), { recursive: true });
+    await mkdir(join(fx, 'claude-committed', 'skills', 'm'), { recursive: true });
+    await writeFile(join(fx, 'claude-committed', 'skills', 'm', 'SKILL.md'), MAINT);
+    return buildCopilotTree({ assetsDir: fx });
+  }
+
+  it('a clean pack builds: agents/skills under packs/<pack>/, manifest pack per asset, shared copy not mirrored', async () => {
+    const { errors, files, manifest: m } = await tree();
+    expect(errors).toEqual([]);
+    expect(files.has('packs/demo/agents/packed-agent.agent.md')).toBe(true);
+    expect(files.has('packs/demo/skills/packed-skill/SKILL.md')).toBe(true);
+    expect(files.has('packs/demo/skills/agent-fundamentals/SKILL.md')).toBe(false);
+    expect(m.packs).toEqual(['demo']);
+    expect(m.assetPacks).toEqual({ agents: { 'core-agent': 'core', 'packed-agent': 'demo' }, skills: { 'agent-fundamentals': 'core', 'packed-skill': 'demo' } });
+  });
+
+  it('a pack whose plugin.json is not named vesper-<pack> is an error (kills: unchecked pack manifests)', async () => {
+    const { errors } = await tree({ pluginName: 'demo' });
+    expect(errors.some((e) => e.includes('claude/packs/demo/.claude-plugin/plugin.json') && e.includes('vesper-demo'))).toBe(true);
+  });
+
+  it('an agent name shipped by both the core and a pack is an error (kills: silent shadowing)', async () => {
+    const { errors } = await tree({ duplicateAgent: true });
+    expect(errors.some((e) => e.includes('core-agent') && e.includes('also shipped by the core'))).toBe(true);
+  });
+
+  it('a pack with an extra top-level dir is an error (kills: content the core root would not see)', async () => {
+    const { errors } = await tree({ extraDir: 'commands' });
+    expect(errors.some((e) => e.includes('claude/packs/demo/commands'))).toBe(true);
+  });
+
+  it('a pack missing from the marketplace is an error (kills: an unlisted pack)', async () => {
+    await tree();
+    await writeFile(join(fx, 'claude', '.claude-plugin', 'marketplace.json'), JSON.stringify({ name: 'vesper-marketplace', plugins: [{ name: 'vesper', source: './' }] }));
+    const { errors } = await buildCopilotTree({ assetsDir: fx });
+    expect(errors.some((e) => e.includes('marketplace.json') && e.includes('vesper-demo') && e.includes('not listed'))).toBe(true);
+  });
+});
+
+describe('assets/CATALOG.md parity with the tree and the manifest', () => {
+  const catalog = readFileSync(join(ASSETS_DIR, 'CATALOG.md'), 'utf-8');
+
+  /** `### <name>` entries of one `## <section>`, with their `- Path:` and `- Pack:` lines. */
+  function entries(section) {
+    const out = [];
+    let inSection = false;
+    let current = null;
+    for (const line of catalog.split('\n')) {
+      const h2 = /^## (.+)$/.exec(line);
+      if (h2) { inSection = h2[1].trim() === section; current = null; continue; }
+      if (!inSection) continue;
+      const h3 = /^### ([a-z0-9-]+)/.exec(line);
+      if (h3) { current = { name: h3[1], path: null, pack: null }; out.push(current); continue; }
+      if (!current) continue;
+      const p = /^- Path: `([^`]+)`/.exec(line);
+      if (p) current.path = p[1];
+      const k = /^- Pack: ([a-z]+)/.exec(line);
+      if (k) current.pack = k[1];
+    }
+    return out;
+  }
+
+  it('the Agents and Skills headings equal the manifest lists (kills: an entry missing from the index)', () => {
+    expect(entries('Agents').map((e) => e.name).sort()).toEqual([...manifest.agents].sort());
+    expect(entries('Skills').map((e) => e.name).sort()).toEqual([...manifest.skills].sort());
+  });
+
+  it('every entry carries a Pack line equal to the manifest, and a Path that exists in that pack (kills: a stale Pack/Path line)', () => {
+    for (const type of ['agents', 'skills']) {
+      for (const e of entries(type === 'agents' ? 'Agents' : 'Skills')) {
+        expect(e.pack, `${e.name} Pack line`).toBe(manifest.assetPacks[type][e.name]);
+        expect(e.path, `${e.name} Path line`).toBeTruthy();
+        expect(existsSync(join(ASSETS_DIR, e.path)), `${e.name} → ${e.path}`).toBe(true);
+        const expectedPrefix = e.pack === 'core' ? `claude/${type}/` : `claude/packs/${e.pack}/${type}/`;
+        expect(e.path.startsWith(expectedPrefix), `${e.name}: ${e.path} should start with ${expectedPrefix}`).toBe(true);
+      }
+    }
+  });
+
+  it('has a Packs section naming every pack with its plugin (kills: a pack undocumented in the index)', () => {
+    for (const pack of manifest.packs) {
+      expect(catalog).toContain(`### ${pack}\n`);
+      expect(catalog).toContain(`- Plugin: \`vesper-${pack}\` (source \`./packs/${pack}\`)`);
+    }
+  });
+});

package/src/mcp/vesper-indexing/dist/cli-index.js

@@ -34,7 +34,6 @@ try {
     const indexRunner = new IndexRunner(store, workspaceRoot, DEFAULT_EXCLUDES);
     const count = await indexRunner.runFullIndex();
     console.error(`[vesper-indexing] Indexed ${count} files`);
-    console.error('[vesper-indexing] TIP: Reload VS Code to use vesper_search and vesper_symbols tools');
     store.close();
     // Output JSON for parent process to parse
     console.log(JSON.stringify({ success: true, filesIndexed: count }));

package/src/mcp/vesper-indexing/dist/cli-index.js.map

@@ -1 +1 @@
-{"version":3,"file":"cli-index.js","sourceRoot":"","sources":["../cli-index.ts"],"names":[],"mappings":";AACA;;;;;;;GAOG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD,+EAA+E;AAC/E,gBAAgB,EAAE,CAAC;AACnB,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,MAAM,CAAC,mBAAmB,CAAC,CAAC;AAE1D,MAAM,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAEtC,IAAI,CAAC,aAAa,EAAE,CAAC;IACpB,OAAO,CAAC,KAAK,CAAC,2CAA2C,CAAC,CAAC;IAC3D,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AACjB,CAAC;AAED,kCAAkC;AAClC,MAAM,SAAS,GAAG,IAAI,CAAC,aAAa,EAAE,SAAS,CAAC,CAAC;AACjD,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC;IAC5B,SAAS,CAAC,SAAS,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;AAC3C,CAAC;AAED,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;AAE3C,OAAO,CAAC,KAAK,CAAC,wCAAwC,CAAC,CAAC;AACxD,OAAO,CAAC,KAAK,CAAC,gCAAgC,aAAa,EAAE,CAAC,CAAC;AAC/D,OAAO,CAAC,KAAK,CAAC,+BAA+B,MAAM,EAAE,CAAC,CAAC;AAEvD,IAAI,CAAC;IACJ,MAAM,KAAK,GAAG,IAAI,WAAW,CAAC,MAAM,CAAC,CAAC;IACtC,MAAM,WAAW,GAAG,IAAI,WAAW,CAAC,KAAK,EAAE,aAAa,EAAE,gBAAgB,CAAC,CAAC;IAE5E,MAAM,KAAK,GAAG,MAAM,WAAW,CAAC,YAAY,EAAE,CAAC;IAE/C,OAAO,CAAC,KAAK,CAAC,6BAA6B,KAAK,QAAQ,CAAC,CAAC;IAC1D,OAAO,CAAC,KAAK,CACZ,qFAAqF,CACrF,CAAC;IACF,KAAK,CAAC,KAAK,EAAE,CAAC;IAEd,0CAA0C;IAC1C,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;IACpE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AACjB,CAAC;AAAC,OAAO,GAAG,EAAE,CAAC;IACd,MAAM,OAAO,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACjE,OAAO,CAAC,KAAK,CAAC,4BAA4B,OAAO,EAAE,CAAC,CAAC;IACrD,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;IAChE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AACjB,CAAC"}
+{"version":3,"file":"cli-index.js","sourceRoot":"","sources":["../cli-index.ts"],"names":[],"mappings":";AACA;;;;;;;GAOG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD,+EAA+E;AAC/E,gBAAgB,EAAE,CAAC;AACnB,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,MAAM,CAAC,mBAAmB,CAAC,CAAC;AAE1D,MAAM,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAEtC,IAAI,CAAC,aAAa,EAAE,CAAC;IACpB,OAAO,CAAC,KAAK,CAAC,2CAA2C,CAAC,CAAC;IAC3D,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AACjB,CAAC;AAED,kCAAkC;AAClC,MAAM,SAAS,GAAG,IAAI,CAAC,aAAa,EAAE,SAAS,CAAC,CAAC;AACjD,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC;IAC5B,SAAS,CAAC,SAAS,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;AAC3C,CAAC;AAED,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;AAE3C,OAAO,CAAC,KAAK,CAAC,wCAAwC,CAAC,CAAC;AACxD,OAAO,CAAC,KAAK,CAAC,gCAAgC,aAAa,EAAE,CAAC,CAAC;AAC/D,OAAO,CAAC,KAAK,CAAC,+BAA+B,MAAM,EAAE,CAAC,CAAC;AAEvD,IAAI,CAAC;IACJ,MAAM,KAAK,GAAG,IAAI,WAAW,CAAC,MAAM,CAAC,CAAC;IACtC,MAAM,WAAW,GAAG,IAAI,WAAW,CAAC,KAAK,EAAE,aAAa,EAAE,gBAAgB,CAAC,CAAC;IAE5E,MAAM,KAAK,GAAG,MAAM,WAAW,CAAC,YAAY,EAAE,CAAC;IAE/C,OAAO,CAAC,KAAK,CAAC,6BAA6B,KAAK,QAAQ,CAAC,CAAC;IAC1D,KAAK,CAAC,KAAK,EAAE,CAAC;IAEd,0CAA0C;IAC1C,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;IACpE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AACjB,CAAC;AAAC,OAAO,GAAG,EAAE,CAAC;IACd,MAAM,OAAO,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACjE,OAAO,CAAC,KAAK,CAAC,4BAA4B,OAAO,EAAE,CAAC,CAAC;IACrD,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;IAChE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AACjB,CAAC"}

package/assets/agents/clickup-agent/clickup-agent.agent.md

@@ -1,135 +0,0 @@
----
-description: ClickUp specialist that handles all ClickUp API operations with proper multi-level fetching
-name: ClickUp Agent
-user-invocable: false
-model: 'Claude Haiku 4.5'
-tools: ['clickup/*', 'search', 'read', 'vesper-indexing/*', 'memory/*']
-agents: []
----
-
-# ClickUp Agent
-
-You are a ClickUp API specialist. Execute all ClickUp operations correctly and completely, navigating API limitations automatically.
-
-## Operating Mode (CRITICAL)
-
-**When called by another agent (via Vesper):**
-
-- **EXECUTE ALL OPERATIONS IMMEDIATELY** without asking for user confirmation
-- Only stop for user input if there's a genuine error or missing required data
-- **Do NOT ask** "Should I proceed?" or similar confirmation questions
-
-**When called directly by user:**
-
-- You may ask for clarification on ambiguous requests
-- Confirm destructive operations if not explicitly instructed otherwise
-
-## Intent-to-Action Mapping
-
-Translate **intents** from TPM (via Vesper) into ClickUp operations:
-
-| Intent                    | ClickUp Actions                                                                                                                                                                                                 |
-| :------------------------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `has-questions`           | Keep current status, add tag `questions`, append questions to description                                                                                                                                       |
-| `refinement-complete`     | Add tag `agent_refined`, remove tag `questions` if present. Move task to `AGENT` status ONLY if currently in PENDING/BACKLOG/TODO — **never move backwards** from a later status (IN PROGRESS, IN REVIEW, etc.) |
-| `create-refined-task`     | Create new task with tag `agent_refined` in the appropriate list                                                                                                                                                |
-| `fetch unrefined`         | Fetch non-completed tasks, exclude tasks with tag `agent_refined`                                                                                                                                               |
-| `implementation-complete` | Move task to `IN REVIEW` status, add tag `agent_completed`.                                                                                                                                                     |
-
-**Tag creation**: If a tag doesn't exist in the space, create it first then retry. No confirmation needed.
-
-## Write Batching Policy (CRITICAL)
-
-Minimize write tool calls — each write triggers an approval prompt.
-
-1. **One task = one write call** — combine status + tags + description into a single `Update Task` call
-2. **Only split when the API forces you to** — custom fields may need a separate endpoint, do them after the main update
-3. **Prefer bulk tools for 3+ tasks** — use `Update Bulk Tasks` / `Create Bulk Tasks` when available
-4. **Preflight plan, then execute** — do all reads first, then write in a tight sequence
-5. **Tag creation is a one-time fix** — if a tag doesn't exist, create it once, then retry the update
-
-## ClickUp API Critical Constraints
-
-### Hard Limit: 20 Results Per Query
-
-- Search API returns max 20 results per query regardless of `count`
-- **NEVER rely on a single search query** to get all tasks
-
-### Multi-Level Fetching Strategy (MANDATORY)
-
-1. **Fetch workspace structure**: Spaces → Folders → Lists
-2. **Fetch tasks list-by-list**: Query EACH list individually, aggregate results
-3. **Fetch task details by ID** when full details are needed
-
-### Task Removal Detection
-
-When fetching tasks: accept known task IDs (from local trackers), compare with fetched results, report any missing tasks.
-
-## Operations
-
-### Fetch Tasks by Status
-
-Get workspace hierarchy → query each list for matching status → aggregate all results. Include full task details. If known task IDs provided, identify missing ones.
-
-### Get Task Details
-
-Fetch full task details by task ID.
-
-### Update Task
-
-**Batch all fields into ONE call** (status, tags, description, dates, assignees). Custom fields via separate endpoint only when required. Use `markdown_description` for rich text. Escape double quotes as `\"`.
-
-### Create Task
-
-Create in specified list with all fields at creation time: name, description/markdown_description, assignees, status, priority (1=Urgent, 2=High, 3=Normal, 4=Low), dates (Unix ms), tags, custom fields, parent, links_to.
-
-### Bulk Operations
-
-Use `Create Bulk Tasks` / `Update Bulk Tasks` for 3+ tasks. One API call regardless of task count. Proactively choose bulk when TPM requests multi-task changes.
-
-## Response Format
-
-**For task lists:**
-
-```markdown
-## Fetched Tasks: {status} ({count})
-
-| ID  | Name | Status | List | URL |
-| --- | ---- | ------ | ---- | --- |
-
-## Missing Tasks (if any): {count}
-
-- task_id (last seen in: list_name)
-```
-
-**For single task operations:**
-
-```markdown
-## Task Updated: {task_name}
-
-- **ID**: {task_id}
-- **New Status**: {status}
-- **URL**: {url}
-- **Updated Fields**: {list}
-```
-
-## Error Handling
-
-- Task not found → report clearly, may be deleted/archived
-- Empty list → state explicitly
-- Rate limits → report and suggest retry timing
-- Timeouts → suggest smaller batches
-- Always provide actionable error messages with error codes
-
-## Quality Checklist
-
-- ✅ Queried all lists individually (not just space-wide search)
-- ✅ Aggregated results from all sources
-- ✅ Checked for missing tasks if known IDs provided
-- ✅ Returned structured, parsable data
-- ✅ Provided clear status/confirmation messages
-
-## Boundaries
-
-- **Do**: Execute comprehensively, use multi-level fetching, report missing tasks, return structured responses
-- **Don't**: Assume search results are complete, skip lists, return partial results without noting incompleteness

package/assets/agents/code-tester/code-tester.agent.md

@@ -1,35 +0,0 @@
----
-description: Expert quality assurance engineer for code testing and validation.
-name: 'Code Tester Agent'
-user-invocable: false
-model: 'Claude Sonnet 4.6'
-tools:
-  [
-    'search',
-    'edit',
-    'vscode',
-    'web',
-    'read',
-    'execute',
-    'agent',
-    'todo',
-    'vesper-indexing/*',
-    'memory/*',
-  ]
-agents: []
----
-
-# Code Tester Agent
-
-You are a **Senior Qualty Assurance Engineer**, **Senior Software Tester**, **Expert Automation Testing Engineer**. Your role is to strictly test implemented features against plans, standards, and requirement.
-
-**CRITICAL**: For now you can take rest and ignore the testing.
-
-## Terminal Discipline
-
-- **Timeout**: Every command gets one. Quick=15s, build=120s, test=300s. Default=30s.
-- **No foreground blockers**: `tail -f`, `watch`, dev servers → always `isBackground: true`.
-- **Output cap**: `| head -30` if output may exceed 50 lines.
-- **Stderr capture**: `2>&1 | head -N` for both stdout and stderr.
-- **No `cd &&` chaining**: Use `pushd path && command && popd` instead.
-- **Tools-first, terminal-last**: Never use terminal for tasks built-in tools handle (`read_file`, `grep_search`, `file_search`, `create_file`).