@soleri/core 9.0.3 → 9.2.0

package/src/curator/schema.ts

@@ -0,0 +1,65 @@
+/**
+ * Curator Schema — DDL for curator tables.
+ */
+
+import type { PersistenceProvider } from '../persistence/types.js';
+
+export const CURATOR_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS curator_entry_state (
+    entry_id TEXT PRIMARY KEY,
+    status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'stale', 'archived')),
+    confidence REAL NOT NULL DEFAULT 1.0,
+    source TEXT NOT NULL DEFAULT 'unknown' CHECK(source IN ('manual', 'capture', 'seed', 'unknown')),
+    last_groomed_at INTEGER,
+    created_at INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  CREATE TABLE IF NOT EXISTS curator_tag_canonical (
+    tag TEXT PRIMARY KEY,
+    description TEXT,
+    created_at INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  CREATE TABLE IF NOT EXISTS curator_tag_alias (
+    alias TEXT PRIMARY KEY,
+    canonical TEXT NOT NULL,
+    created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+    FOREIGN KEY (canonical) REFERENCES curator_tag_canonical(tag)
+  );
+
+  CREATE TABLE IF NOT EXISTS curator_changelog (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    action TEXT NOT NULL,
+    entry_id TEXT NOT NULL,
+    before_value TEXT,
+    after_value TEXT,
+    reason TEXT NOT NULL,
+    created_at INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  CREATE TABLE IF NOT EXISTS curator_entry_history (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    entry_id TEXT NOT NULL,
+    snapshot TEXT NOT NULL,
+    changed_by TEXT DEFAULT 'system',
+    change_reason TEXT,
+    created_at INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  CREATE TABLE IF NOT EXISTS curator_contradictions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    pattern_id TEXT NOT NULL,
+    antipattern_id TEXT NOT NULL,
+    similarity REAL NOT NULL,
+    status TEXT NOT NULL DEFAULT 'open' CHECK(status IN ('open', 'resolved', 'dismissed')),
+    created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+    resolved_at INTEGER,
+    UNIQUE(pattern_id, antipattern_id)
+  );
+  CREATE INDEX IF NOT EXISTS idx_curator_state_status ON curator_entry_state(status);
+  CREATE INDEX IF NOT EXISTS idx_curator_changelog_entry ON curator_changelog(entry_id);
+`;
+
+export function initializeTables(provider: PersistenceProvider): void {
+  provider.execSql(CURATOR_SCHEMA);
+}

package/src/curator/tag-manager.test.ts

@@ -0,0 +1,165 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+  normalizeTag,
+  normalizeTags,
+  normalizeAndDedup,
+  addTagAlias,
+  getCanonicalTags,
+  seedDefaultAliases,
+  DEFAULT_TAG_ALIASES,
+  type TagStore,
+} from './tag-manager.js';
+
+function mockTagStore(): TagStore {
+  const aliases = new Map<string, string>();
+  const canonicals = new Map<string, string | null>();
+
+  return {
+    getAlias: vi.fn((lower: string) => aliases.get(lower) ?? null),
+    insertCanonical: vi.fn((tag: string) => { canonicals.set(tag, null); }),
+    upsertAlias: vi.fn((alias: string, canonical: string) => { aliases.set(alias, canonical); }),
+    getCanonicalRows: vi.fn(() =>
+      Array.from(canonicals.entries()).map(([tag, description]) => ({
+        tag,
+        description,
+        alias_count: Array.from(aliases.values()).filter((c) => c === tag).length,
+      })),
+    ),
+    countTagUsage: vi.fn(() => 0),
+  };
+}
+
+describe('tag-manager', () => {
+  let store: TagStore;
+
+  beforeEach(() => {
+    store = mockTagStore();
+  });
+
+  describe('DEFAULT_TAG_ALIASES', () => {
+    it('exports expected alias count', () => {
+      expect(DEFAULT_TAG_ALIASES.length).toBe(13);
+    });
+
+    it('includes common aliases', () => {
+      const aliasMap = new Map(DEFAULT_TAG_ALIASES);
+      expect(aliasMap.get('a11y')).toBe('accessibility');
+      expect(aliasMap.get('ts')).toBe('typescript');
+      expect(aliasMap.get('js')).toBe('javascript');
+      expect(aliasMap.get('perf')).toBe('performance');
+    });
+  });
+
+  describe('normalizeTag', () => {
+    it('returns aliased result when store has alias', () => {
+      (store.getAlias as ReturnType<typeof vi.fn>).mockReturnValue('accessibility');
+      const result = normalizeTag('a11y', store);
+      expect(result).toEqual({ original: 'a11y', normalized: 'accessibility', wasAliased: true });
+    });
+
+    it('returns lowercased tag when no alias found', () => {
+      const result = normalizeTag('MyCustomTag', store);
+      expect(result).toEqual({ original: 'MyCustomTag', normalized: 'mycustomtag', wasAliased: false });
+    });
+
+    it('trims whitespace', () => {
+      const result = normalizeTag('  spaced  ', store);
+      expect(result.normalized).toBe('spaced');
+    });
+
+    it('lowercases before lookup', () => {
+      normalizeTag('A11Y', store);
+      expect(store.getAlias).toHaveBeenCalledWith('a11y');
+    });
+  });
+
+  describe('normalizeTags', () => {
+    it('normalizes each tag in the array', () => {
+      (store.getAlias as ReturnType<typeof vi.fn>)
+        .mockReturnValueOnce('accessibility')
+        .mockReturnValueOnce(null);
+      const results = normalizeTags(['a11y', 'custom'], store);
+      expect(results).toHaveLength(2);
+      expect(results[0].wasAliased).toBe(true);
+      expect(results[1].wasAliased).toBe(false);
+    });
+
+    it('returns empty array for empty input', () => {
+      expect(normalizeTags([], store)).toEqual([]);
+    });
+  });
+
+  describe('normalizeAndDedup', () => {
+    it('deduplicates after normalization', () => {
+      (store.getAlias as ReturnType<typeof vi.fn>)
+        .mockReturnValueOnce('styling')  // css -> styling
+        .mockReturnValueOnce('styling'); // tailwind -> styling
+      const { results, dedupedTags, changed } = normalizeAndDedup(['css', 'tailwind'], store);
+      expect(results).toHaveLength(2);
+      expect(dedupedTags).toEqual(['styling']);
+      expect(changed).toBe(true);
+    });
+
+    it('reports changed=false when no aliases applied', () => {
+      const { changed } = normalizeAndDedup(['custom', 'other'], store);
+      expect(changed).toBe(false);
+    });
+
+    it('reports changed=true when any tag is aliased', () => {
+      (store.getAlias as ReturnType<typeof vi.fn>)
+        .mockReturnValueOnce('accessibility')
+        .mockReturnValueOnce(null);
+      const { changed } = normalizeAndDedup(['a11y', 'custom'], store);
+      expect(changed).toBe(true);
+    });
+  });
+
+  describe('addTagAlias', () => {
+    it('inserts canonical and upserts alias', () => {
+      addTagAlias('react', 'frontend', store);
+      expect(store.insertCanonical).toHaveBeenCalledWith('frontend');
+      expect(store.upsertAlias).toHaveBeenCalledWith('react', 'frontend');
+    });
+
+    it('lowercases and trims both alias and canonical', () => {
+      addTagAlias('  React  ', '  Frontend  ', store);
+      expect(store.insertCanonical).toHaveBeenCalledWith('frontend');
+      expect(store.upsertAlias).toHaveBeenCalledWith('react', 'frontend');
+    });
+  });
+
+  describe('getCanonicalTags', () => {
+    it('maps rows to CanonicalTag objects', () => {
+      (store.getCanonicalRows as ReturnType<typeof vi.fn>).mockReturnValue([
+        { tag: 'styling', description: 'CSS stuff', alias_count: 3 },
+      ]);
+      (store.countTagUsage as ReturnType<typeof vi.fn>).mockReturnValue(5);
+
+      const tags = getCanonicalTags(store);
+      expect(tags).toEqual([
+        { tag: 'styling', description: 'CSS stuff', usageCount: 5, aliasCount: 3 },
+      ]);
+    });
+
+    it('returns empty array when no canonicals', () => {
+      (store.getCanonicalRows as ReturnType<typeof vi.fn>).mockReturnValue([]);
+      expect(getCanonicalTags(store)).toEqual([]);
+    });
+  });
+
+  describe('seedDefaultAliases', () => {
+    it('inserts all unique canonical tags', () => {
+      seedDefaultAliases(store);
+      const uniqueCanonicals = new Set(DEFAULT_TAG_ALIASES.map(([, c]) => c));
+      expect(store.insertCanonical).toHaveBeenCalledTimes(uniqueCanonicals.size);
+    });
+
+    it('upserts all alias pairs', () => {
+      seedDefaultAliases(store);
+      expect(store.upsertAlias).toHaveBeenCalledTimes(DEFAULT_TAG_ALIASES.length);
+      // Spot check
+      expect(store.upsertAlias).toHaveBeenCalledWith('a11y', 'accessibility');
+      expect(store.upsertAlias).toHaveBeenCalledWith('ts', 'typescript');
+    });
+  });
+});

package/src/curator/tag-manager.ts

@@ -0,0 +1,109 @@
+/**
+ * Tag Manager — tag normalization, aliasing, and suggestion logic.
+ *
+ * Pure logic where possible; database access is delegated via a TagStore interface.
+ */
+
+import type { TagNormalizationResult, CanonicalTag } from './types.js';
+
+// ─── Constants ──────────────────────────────────────────────────────
+
+export const DEFAULT_TAG_ALIASES: Array<[string, string]> = [
+  ['a11y', 'accessibility'],
+  ['ts', 'typescript'],
+  ['js', 'javascript'],
+  ['css', 'styling'],
+  ['tailwind', 'styling'],
+  ['tw', 'styling'],
+  ['vitest', 'testing'],
+  ['jest', 'testing'],
+  ['perf', 'performance'],
+  ['sec', 'security'],
+  ['auth', 'authentication'],
+  ['i18n', 'internationalization'],
+  ['l10n', 'localization'],
+];
+
+// ─── Tag Store Interface ────────────────────────────────────────────
+
+/**
+ * Thin abstraction over the persistence layer for tag operations.
+ * Implemented by the Curator facade using its PersistenceProvider.
+ */
+export interface TagStore {
+  getAlias(lower: string): string | null;
+  insertCanonical(tag: string): void;
+  upsertAlias(alias: string, canonical: string): void;
+  getCanonicalRows(): Array<{ tag: string; description: string | null; alias_count: number }>;
+  countTagUsage(tag: string): number;
+}
+
+// ─── Normalize ──────────────────────────────────────────────────────
+
+export function normalizeTag(tag: string, store: TagStore): TagNormalizationResult {
+  const lower = tag.toLowerCase().trim();
+  const canonical = store.getAlias(lower);
+  if (canonical) {
+    return { original: tag, normalized: canonical, wasAliased: true };
+  }
+  return { original: tag, normalized: lower, wasAliased: false };
+}
+
+export function normalizeTags(tags: string[], store: TagStore): TagNormalizationResult[] {
+  return tags.map((tag) => normalizeTag(tag, store));
+}
+
+/**
+ * Deduplicate and return final tag list after normalization.
+ */
+export function normalizeAndDedup(
+  tags: string[],
+  store: TagStore,
+): { results: TagNormalizationResult[]; dedupedTags: string[]; changed: boolean } {
+  const results: TagNormalizationResult[] = [];
+  const normalizedTags: string[] = [];
+  let changed = false;
+
+  for (const tag of tags) {
+    const result = normalizeTag(tag, store);
+    results.push(result);
+    normalizedTags.push(result.normalized);
+    if (result.normalized !== tag) changed = true;
+  }
+
+  const dedupedTags = [...new Set(normalizedTags)];
+  return { results, dedupedTags, changed };
+}
+
+// ─── Alias Management ───────────────────────────────────────────────
+
+export function addTagAlias(alias: string, canonical: string, store: TagStore): void {
+  const lower = alias.toLowerCase().trim();
+  const canonicalLower = canonical.toLowerCase().trim();
+  store.insertCanonical(canonicalLower);
+  store.upsertAlias(lower, canonicalLower);
+}
+
+// ─── Canonical Tags ─────────────────────────────────────────────────
+
+export function getCanonicalTags(store: TagStore): CanonicalTag[] {
+  const rows = store.getCanonicalRows();
+  return rows.map((row) => ({
+    tag: row.tag,
+    description: row.description,
+    usageCount: store.countTagUsage(row.tag),
+    aliasCount: row.alias_count,
+  }));
+}
+
+// ─── Seed ───────────────────────────────────────────────────────────
+
+export function seedDefaultAliases(store: TagStore): void {
+  const canonicals = new Set(DEFAULT_TAG_ALIASES.map(([, c]) => c));
+  for (const tag of canonicals) {
+    store.insertCanonical(tag);
+  }
+  for (const [alias, canonical] of DEFAULT_TAG_ALIASES) {
+    store.upsertAlias(alias, canonical);
+  }
+}

package/src/domain-packs/inject-rules.test.ts

@@ -0,0 +1,117 @@
+/**
+ * Colocated tests for domain-packs/inject-rules.ts
+ *
+ * Tests: inject into new file, inject into existing, idempotent replace,
+ * remove, no-op on empty content.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, writeFileSync, readFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { injectDomainRules, removeDomainRules } from './inject-rules.js';
+
+let tempDir: string;
+
+beforeEach(() => {
+  tempDir = mkdtempSync(join(tmpdir(), 'inject-rules-test-'));
+});
+
+afterEach(() => {
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+describe('injectDomainRules', () => {
+  it('creates file if it does not exist', () => {
+    const filePath = join(tempDir, 'CLAUDE.md');
+    injectDomainRules(filePath, 'design', '## Design Rules\nUse semantic tokens.');
+    const content = readFileSync(filePath, 'utf-8');
+    expect(content).toContain('<!-- domain:design -->');
+    expect(content).toContain('## Design Rules');
+    expect(content).toContain('<!-- /domain:design -->');
+  });
+
+  it('appends to existing file', () => {
+    const filePath = join(tempDir, 'CLAUDE.md');
+    writeFileSync(filePath, '# Agent Rules\n\nExisting content.\n');
+    injectDomainRules(filePath, 'security', 'Security rules here.');
+    const content = readFileSync(filePath, 'utf-8');
+    expect(content).toContain('# Agent Rules');
+    expect(content).toContain('<!-- domain:security -->');
+    expect(content).toContain('Security rules here.');
+  });
+
+  it('is idempotent — replaces existing block', () => {
+    const filePath = join(tempDir, 'CLAUDE.md');
+    writeFileSync(filePath, '# Header\n');
+    injectDomainRules(filePath, 'design', 'Version 1');
+    injectDomainRules(filePath, 'design', 'Version 2');
+    const content = readFileSync(filePath, 'utf-8');
+    expect(content).not.toContain('Version 1');
+    expect(content).toContain('Version 2');
+    // Only one pair of markers
+    const openCount = content.split('<!-- domain:design -->').length - 1;
+    expect(openCount).toBe(1);
+  });
+
+  it('does nothing when content is empty', () => {
+    const filePath = join(tempDir, 'CLAUDE.md');
+    writeFileSync(filePath, 'Original');
+    injectDomainRules(filePath, 'design', '');
+    expect(readFileSync(filePath, 'utf-8')).toBe('Original');
+  });
+
+  it('does nothing when content is whitespace-only', () => {
+    const filePath = join(tempDir, 'CLAUDE.md');
+    writeFileSync(filePath, 'Original');
+    injectDomainRules(filePath, 'design', '   \n  \n  ');
+    expect(readFileSync(filePath, 'utf-8')).toBe('Original');
+  });
+
+  it('handles multiple pack injections independently', () => {
+    const filePath = join(tempDir, 'CLAUDE.md');
+    writeFileSync(filePath, '# Agent\n');
+    injectDomainRules(filePath, 'design', 'Design rules');
+    injectDomainRules(filePath, 'security', 'Security rules');
+    const content = readFileSync(filePath, 'utf-8');
+    expect(content).toContain('<!-- domain:design -->');
+    expect(content).toContain('<!-- domain:security -->');
+    expect(content).toContain('Design rules');
+    expect(content).toContain('Security rules');
+  });
+});
+
+describe('removeDomainRules', () => {
+  it('removes injected block', () => {
+    const filePath = join(tempDir, 'CLAUDE.md');
+    writeFileSync(filePath, '# Header\n');
+    injectDomainRules(filePath, 'design', 'Rules to remove');
+    removeDomainRules(filePath, 'design');
+    const content = readFileSync(filePath, 'utf-8');
+    expect(content).not.toContain('<!-- domain:design -->');
+    expect(content).not.toContain('Rules to remove');
+  });
+
+  it('does nothing if file does not exist', () => {
+    // Should not throw
+    removeDomainRules(join(tempDir, 'nonexistent.md'), 'design');
+  });
+
+  it('does nothing if markers are not found', () => {
+    const filePath = join(tempDir, 'CLAUDE.md');
+    writeFileSync(filePath, '# Header\nNo markers here.\n');
+    removeDomainRules(filePath, 'design');
+    expect(readFileSync(filePath, 'utf-8')).toBe('# Header\nNo markers here.\n');
+  });
+
+  it('only removes the targeted pack block', () => {
+    const filePath = join(tempDir, 'CLAUDE.md');
+    writeFileSync(filePath, '# Header\n');
+    injectDomainRules(filePath, 'design', 'Design rules');
+    injectDomainRules(filePath, 'security', 'Security rules');
+    removeDomainRules(filePath, 'design');
+    const content = readFileSync(filePath, 'utf-8');
+    expect(content).not.toContain('Design rules');
+    expect(content).toContain('Security rules');
+  });
+});

package/src/domain-packs/knowledge-installer.test.ts

@@ -0,0 +1,171 @@
+/**
+ * Colocated tests for domain-packs/knowledge-installer.ts
+ *
+ * Tests: three-tier installation, immutable canonical skip, empty knowledge,
+ * missing directories.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { installKnowledge } from './knowledge-installer.js';
+import type { DomainPack } from './types.js';
+import type { AgentRuntime } from '../runtime/types.js';
+
+let tempDir: string;
+
+function mockPack(overrides: Partial<DomainPack> = {}): DomainPack {
+  return {
+    name: 'test-pack',
+    version: '1.0.0',
+    domains: ['testing'],
+    ops: [],
+    ...overrides,
+  };
+}
+
+function mockRuntime(): AgentRuntime {
+  const entries = new Map<string, unknown>();
+  return {
+    vault: {
+      get: vi.fn((id: string) => entries.get(id) ?? null),
+      add: vi.fn((entry: Record<string, unknown>) => entries.set(entry.id as string, entry)),
+      search: vi.fn(() => []),
+    },
+  } as unknown;
+}
+
+function writeMdFiles(dir: string, files: Record<string, string>) {
+  mkdirSync(dir, { recursive: true });
+  for (const [name, content] of Object.entries(files)) {
+    writeFileSync(join(dir, name), content, 'utf-8');
+  }
+}
+
+beforeEach(() => {
+  tempDir = mkdtempSync(join(tmpdir(), 'knowledge-test-'));
+});
+
+afterEach(() => {
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+describe('installKnowledge', () => {
+  it('returns zeros when pack has no knowledge', async () => {
+    const result = await installKnowledge(mockPack(), mockRuntime(), tempDir);
+    expect(result).toEqual({ canonical: 0, curated: 0, captured: 0, skipped: 0 });
+  });
+
+  it('installs canonical entries', async () => {
+    const canonicalDir = join(tempDir, 'canonical');
+    writeMdFiles(canonicalDir, {
+      'no-raw-colors.md': '# No Raw Colors\nAlways use tokens.',
+      'token-priority.md': '# Token Priority\nSemantic first.',
+    });
+    const runtime = mockRuntime();
+    const result = await installKnowledge(
+      mockPack({ knowledge: { canonical: 'canonical' } }),
+      runtime,
+      tempDir,
+    );
+    expect(result.canonical).toBe(2);
+    expect(runtime.vault.add).toHaveBeenCalledTimes(2);
+  });
+
+  it('installs curated entries', async () => {
+    const curatedDir = join(tempDir, 'curated');
+    writeMdFiles(curatedDir, { 'pattern-a.md': 'Pattern A content.' });
+    const runtime = mockRuntime();
+    const result = await installKnowledge(
+      mockPack({ knowledge: { curated: 'curated' } }),
+      runtime,
+      tempDir,
+    );
+    expect(result.curated).toBe(1);
+  });
+
+  it('installs captured entries', async () => {
+    const capturedDir = join(tempDir, 'captured');
+    writeMdFiles(capturedDir, { 'lesson-1.md': 'A lesson.' });
+    const runtime = mockRuntime();
+    const result = await installKnowledge(
+      mockPack({ knowledge: { captured: 'captured' } }),
+      runtime,
+      tempDir,
+    );
+    expect(result.captured).toBe(1);
+  });
+
+  it('skips canonical entries that already exist (immutable)', async () => {
+    const canonicalDir = join(tempDir, 'canonical');
+    writeMdFiles(canonicalDir, { 'existing.md': 'Content.' });
+    const runtime = mockRuntime();
+    // Pre-populate vault with existing entry
+    (runtime.vault.get as unknown).mockImplementation((id: string) =>
+      id === 'pack-test-pack-existing' ? { id } : null,
+    );
+    const result = await installKnowledge(
+      mockPack({ knowledge: { canonical: 'canonical' } }),
+      runtime,
+      tempDir,
+    );
+    expect(result.canonical).toBe(0);
+  });
+
+  it('skips non-existing directories gracefully', async () => {
+    const runtime = mockRuntime();
+    const result = await installKnowledge(
+      mockPack({ knowledge: { canonical: 'no-such-dir', curated: 'also-missing' } }),
+      runtime,
+      tempDir,
+    );
+    expect(result.canonical).toBe(0);
+    expect(result.curated).toBe(0);
+  });
+
+  it('tags entries with pack source and tier', async () => {
+    const canonicalDir = join(tempDir, 'canonical');
+    writeMdFiles(canonicalDir, { 'tagged.md': 'Tagged entry.' });
+    const runtime = mockRuntime();
+    await installKnowledge(
+      mockPack({ knowledge: { canonical: 'canonical' } }),
+      runtime,
+      tempDir,
+    );
+    const addCall = (runtime.vault.add as unknown).mock.calls[0][0];
+    expect(addCall.tags).toContain('pack:test-pack');
+    expect(addCall.tags).toContain('tier:canonical');
+    expect(addCall.origin).toBe('pack');
+    expect(addCall.domain).toBe('test-pack');
+  });
+
+  it('generates correct entry id from pack name and filename', async () => {
+    const curatedDir = join(tempDir, 'curated');
+    writeMdFiles(curatedDir, { 'my-pattern.md': 'Content.' });
+    const runtime = mockRuntime();
+    await installKnowledge(
+      mockPack({ knowledge: { curated: 'curated' } }),
+      runtime,
+      tempDir,
+    );
+    const addCall = (runtime.vault.add as unknown).mock.calls[0][0];
+    expect(addCall.id).toBe('pack-test-pack-my-pattern');
+  });
+
+  it('installs all three tiers in a single call', async () => {
+    writeMdFiles(join(tempDir, 'c'), { 'a.md': 'A' });
+    writeMdFiles(join(tempDir, 'u'), { 'b.md': 'B' });
+    writeMdFiles(join(tempDir, 'p'), { 'c.md': 'C' });
+    const runtime = mockRuntime();
+    const result = await installKnowledge(
+      mockPack({ knowledge: { canonical: 'c', curated: 'u', captured: 'p' } }),
+      runtime,
+      tempDir,
+    );
+    expect(result.canonical).toBe(1);
+    expect(result.curated).toBe(1);
+    expect(result.captured).toBe(1);
+    expect(runtime.vault.add).toHaveBeenCalledTimes(3);
+  });
+});