@soleri/core 9.2.0 → 9.3.1

package/src/curator/quality-gate.test.ts

@@ -31,12 +31,20 @@ describe('evaluateQuality', () => {
   });
 
   it('returns ACCEPT for high-quality entry', async () => {
-    const llm = mockLLM(JSON.stringify({
-      verdict: 'ACCEPT',
-      overallScore: 85,
-      scores: { novelty: 80, actionability: 90, specificity: 85, relevance: 80, informationDensity: 90 },
-      reasoning: 'High quality entry with specific guidance.',
-    }));
+    const llm = mockLLM(
+      JSON.stringify({
+        verdict: 'ACCEPT',
+        overallScore: 85,
+        scores: {
+          novelty: 80,
+          actionability: 90,
+          specificity: 85,
+          relevance: 80,
+          informationDensity: 90,
+        },
+        reasoning: 'High quality entry with specific guidance.',
+      }),
+    );
 
     const result = await evaluateQuality(makeEntry(), llm);
     expect(result.evaluated).toBe(true);
@@ -45,13 +53,21 @@ describe('evaluateQuality', () => {
   });
 
   it('returns REJECT for low-quality entry', async () => {
-    const llm = mockLLM(JSON.stringify({
-      verdict: 'REJECT',
-      overallScore: 30,
-      scores: { novelty: 10, actionability: 30, specificity: 40, relevance: 50, informationDensity: 20 },
-      reasoning: 'Too generic.',
-      rejectReasons: ['Low novelty', 'Not actionable'],
-    }));
+    const llm = mockLLM(
+      JSON.stringify({
+        verdict: 'REJECT',
+        overallScore: 30,
+        scores: {
+          novelty: 10,
+          actionability: 30,
+          specificity: 40,
+          relevance: 50,
+          informationDensity: 20,
+        },
+        reasoning: 'Too generic.',
+        rejectReasons: ['Low novelty', 'Not actionable'],
+      }),
+    );
 
     const result = await evaluateQuality(makeEntry(), llm);
     expect(result.evaluated).toBe(true);
@@ -87,24 +103,40 @@ describe('evaluateQuality', () => {
   });
 
   it('normalizes non-REJECT verdict to ACCEPT', async () => {
-    const llm = mockLLM(JSON.stringify({
-      verdict: 'MAYBE',
-      overallScore: 60,
-      scores: { novelty: 60, actionability: 60, specificity: 60, relevance: 60, informationDensity: 60 },
-      reasoning: 'Borderline entry.',
-    }));
+    const llm = mockLLM(
+      JSON.stringify({
+        verdict: 'MAYBE',
+        overallScore: 60,
+        scores: {
+          novelty: 60,
+          actionability: 60,
+          specificity: 60,
+          relevance: 60,
+          informationDensity: 60,
+        },
+        reasoning: 'Borderline entry.',
+      }),
+    );
 
     const result = await evaluateQuality(makeEntry(), llm);
     expect(result.verdict).toBe('ACCEPT');
   });
 
   it('includes optional entry fields in prompt', async () => {
-    const llm = mockLLM(JSON.stringify({
-      verdict: 'ACCEPT',
-      overallScore: 70,
-      scores: { novelty: 70, actionability: 70, specificity: 70, relevance: 70, informationDensity: 70 },
-      reasoning: 'OK.',
-    }));
+    const llm = mockLLM(
+      JSON.stringify({
+        verdict: 'ACCEPT',
+        overallScore: 70,
+        scores: {
+          novelty: 70,
+          actionability: 70,
+          specificity: 70,
+          relevance: 70,
+          informationDensity: 70,
+        },
+        reasoning: 'OK.',
+      }),
+    );
 
     const entry = makeEntry();
     entry.why = 'Because security matters';
@@ -120,12 +152,20 @@ describe('evaluateQuality', () => {
   });
 
   it('uses low temperature for consistent scoring', async () => {
-    const llm = mockLLM(JSON.stringify({
-      verdict: 'ACCEPT',
-      overallScore: 70,
-      scores: { novelty: 70, actionability: 70, specificity: 70, relevance: 70, informationDensity: 70 },
-      reasoning: 'OK.',
-    }));
+    const llm = mockLLM(
+      JSON.stringify({
+        verdict: 'ACCEPT',
+        overallScore: 70,
+        scores: {
+          novelty: 70,
+          actionability: 70,
+          specificity: 70,
+          relevance: 70,
+          informationDensity: 70,
+        },
+        reasoning: 'OK.',
+      }),
+    );
 
     await evaluateQuality(makeEntry(), llm);
 

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

@@ -16,8 +16,12 @@ function mockTagStore(): TagStore {
 
   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); }),
+    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,
@@ -59,7 +63,11 @@ describe('tag-manager', () => {
 
     it('returns lowercased tag when no alias found', () => {
       const result = normalizeTag('MyCustomTag', store);
-      expect(result).toEqual({ original: 'MyCustomTag', normalized: 'mycustomtag', wasAliased: false });
+      expect(result).toEqual({
+        original: 'MyCustomTag',
+        normalized: 'mycustomtag',
+        wasAliased: false,
+      });
     });
 
     it('trims whitespace', () => {
@@ -92,7 +100,7 @@ describe('tag-manager', () => {
   describe('normalizeAndDedup', () => {
     it('deduplicates after normalization', () => {
       (store.getAlias as ReturnType<typeof vi.fn>)
-        .mockReturnValueOnce('styling')  // css -> styling
+        .mockReturnValueOnce('styling') // css -> styling
         .mockReturnValueOnce('styling'); // tailwind -> styling
       const { results, dedupedTags, changed } = normalizeAndDedup(['css', 'tailwind'], store);
       expect(results).toHaveLength(2);

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

@@ -128,11 +128,7 @@ describe('installKnowledge', () => {
     const canonicalDir = join(tempDir, 'canonical');
     writeMdFiles(canonicalDir, { 'tagged.md': 'Tagged entry.' });
     const runtime = mockRuntime();
-    await installKnowledge(
-      mockPack({ knowledge: { canonical: 'canonical' } }),
-      runtime,
-      tempDir,
-    );
+    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');
@@ -144,11 +140,7 @@ describe('installKnowledge', () => {
     const curatedDir = join(tempDir, 'curated');
     writeMdFiles(curatedDir, { 'my-pattern.md': 'Content.' });
     const runtime = mockRuntime();
-    await installKnowledge(
-      mockPack({ knowledge: { curated: 'curated' } }),
-      runtime,
-      tempDir,
-    );
+    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');
   });

package/src/domain-packs/token-resolver.test.ts

@@ -75,9 +75,7 @@ describe('resolveToken', () => {
   });
 
   it('throws for unknown token', () => {
-    expect(() => resolveToken('unknown-token', emptyProject())).toThrow(
-      /Cannot resolve token/,
-    );
+    expect(() => resolveToken('unknown-token', emptyProject())).toThrow(/Cannot resolve token/);
   });
 
   it('throws for unknown color scale', () => {

package/src/domain-packs/types.test.ts

@@ -53,7 +53,9 @@ describe('validateDomainPack', () => {
   });
 
   it('accepts pack with rules string', () => {
-    const result = validateDomainPack(minimalPack({ rules: '## Token Rules\nUse semantic tokens.' }));
+    const result = validateDomainPack(
+      minimalPack({ rules: '## Token Rules\nUse semantic tokens.' }),
+    );
     expect(result.success).toBe(true);
   });
 
@@ -122,7 +124,19 @@ describe('SEMANTIC_FACADE_NAMES', () => {
   });
 
   it('contains all core engine facades', () => {
-    const expected = ['vault', 'plan', 'brain', 'memory', 'admin', 'curator', 'loop', 'orchestrate', 'control', 'cognee', 'governance'];
+    const expected = [
+      'vault',
+      'plan',
+      'brain',
+      'memory',
+      'admin',
+      'curator',
+      'loop',
+      'orchestrate',
+      'control',
+      'cognee',
+      'governance',
+    ];
     for (const name of expected) {
       expect(SEMANTIC_FACADE_NAMES).toContain(name);
     }

package/src/enforcement/registry.test.ts

@@ -74,10 +74,7 @@ describe('EnforcementRegistry', () => {
 
   describe('getEnabledRules', () => {
     it('excludes disabled rules', () => {
-      registry.addRules([
-        makeRule({ id: 'active' }),
-        makeRule({ id: 'disabled', enabled: false }),
-      ]);
+      registry.addRules([makeRule({ id: 'active' }), makeRule({ id: 'disabled', enabled: false })]);
       const enabled = registry.getEnabledRules();
       expect(enabled).toHaveLength(1);
       expect(enabled[0].id).toBe('active');
@@ -91,10 +88,7 @@ describe('EnforcementRegistry', () => {
 
   describe('getConfig', () => {
     it('returns config with only enabled rules', () => {
-      registry.addRules([
-        makeRule({ id: 'on' }),
-        makeRule({ id: 'off', enabled: false }),
-      ]);
+      registry.addRules([makeRule({ id: 'on' }), makeRule({ id: 'off', enabled: false })]);
       const config = registry.getConfig();
       expect(config.rules).toHaveLength(1);
       expect(config.rules[0].id).toBe('on');

package/src/engine/bin/soleri-engine.ts

@@ -169,7 +169,9 @@ async function main(): Promise<void> {
     const syncResult = syncSkillsToClaudeCode([skillsDir], config.name as string);
     const total = syncResult.installed.length + syncResult.updated.length;
     if (total > 0) {
-      console.error(`${tag} Skills synced: ${syncResult.installed.length} new, ${syncResult.updated.length} updated`);
+      console.error(
+        `${tag} Skills synced: ${syncResult.installed.length} new, ${syncResult.updated.length} updated`,
+      );
     }
   }
 

package/src/engine/module-manifest.test.ts

@@ -29,10 +29,11 @@ describe('ENGINE_MODULE_MANIFEST', () => {
     expect(suffixes).toContain('agency');
     expect(suffixes).toContain('chat');
     expect(suffixes).toContain('operator');
+    expect(suffixes).toContain('intake');
   });
 
-  it('has exactly 16 modules', () => {
-    expect(ENGINE_MODULE_MANIFEST).toHaveLength(16);
+  it('has exactly 20 modules', () => {
+    expect(ENGINE_MODULE_MANIFEST).toHaveLength(20);
   });
 
   it('has no duplicate suffixes', () => {
@@ -88,6 +89,49 @@ describe('ENGINE_MODULE_MANIFEST', () => {
     expect(testEntry.suffix).toBe('test');
     expect(testEntry.conditional).toBeUndefined();
   });
+
+  it('intentSignals is optional and a Record<string, string> when present', () => {
+    for (const entry of ENGINE_MODULE_MANIFEST) {
+      if (entry.intentSignals !== undefined) {
+        expect(typeof entry.intentSignals).toBe('object');
+        for (const [phrase, op] of Object.entries(entry.intentSignals)) {
+          expect(typeof phrase).toBe('string');
+          expect(phrase.length).toBeGreaterThan(0);
+          expect(typeof op).toBe('string');
+          expect(op.length).toBeGreaterThan(0);
+        }
+      }
+    }
+  });
+
+  it('every module has intentSignals defined', () => {
+    for (const entry of ENGINE_MODULE_MANIFEST) {
+      expect(entry.intentSignals).toBeDefined();
+      expect(Object.keys(entry.intentSignals!).length).toBeGreaterThanOrEqual(2);
+      expect(Object.keys(entry.intentSignals!).length).toBeLessThanOrEqual(6);
+    }
+  });
+
+  it('intentSignals values reference known keyOps or valid op names', () => {
+    for (const entry of ENGINE_MODULE_MANIFEST) {
+      if (entry.intentSignals) {
+        for (const op of Object.values(entry.intentSignals)) {
+          // Op should be a non-empty snake_case string
+          expect(op).toMatch(/^[a-z][a-z0-9_]*$/);
+        }
+      }
+    }
+  });
+
+  it('intentSignals phrases are unique across all modules', () => {
+    const allPhrases: string[] = [];
+    for (const entry of ENGINE_MODULE_MANIFEST) {
+      if (entry.intentSignals) {
+        allPhrases.push(...Object.keys(entry.intentSignals));
+      }
+    }
+    expect(new Set(allPhrases).size).toBe(allPhrases.length);
+  });
 });
 
 describe('CORE_KEY_OPS', () => {
@@ -118,7 +162,7 @@ describe('manifest order stability', () => {
     expect(ENGINE_MODULE_MANIFEST[0].suffix).toBe('vault');
   });
 
-  it('review is the last module', () => {
-    expect(ENGINE_MODULE_MANIFEST[ENGINE_MODULE_MANIFEST.length - 1].suffix).toBe('review');
+  it('tier is the last module', () => {
+    expect(ENGINE_MODULE_MANIFEST[ENGINE_MODULE_MANIFEST.length - 1].suffix).toBe('tier');
   });
 });

package/src/engine/module-manifest.ts

@@ -16,6 +16,8 @@ export interface ModuleManifestEntry {
   keyOps: string[];
   /** If true, module requires a runtime condition to register */
   conditional?: boolean;
+  /** Intent phrases that map to this module's ops — used for dynamic tool routing */
+  intentSignals?: Record<string, string>;
 }
 
 /**
@@ -25,84 +27,219 @@ export interface ModuleManifestEntry {
 export const ENGINE_MODULE_MANIFEST: ModuleManifestEntry[] = [
   {
     suffix: 'vault',
-    description: 'Knowledge management — search, CRUD, import/export, intake, sharing, linking.',
+    description: 'Knowledge management — search, CRUD, capture, sharing scope.',
     keyOps: ['search_intelligent', 'capture_knowledge', 'capture_quick'],
+    intentSignals: {
+      'search knowledge': 'search_intelligent',
+      'find pattern': 'search_intelligent',
+      'best practice': 'search_intelligent',
+      'save this': 'capture_knowledge',
+      'remember this': 'capture_knowledge',
+      'capture this': 'capture_quick',
+    },
   },
   {
     suffix: 'plan',
     description: 'Plan lifecycle — create, approve, execute, reconcile, complete, grading.',
     keyOps: ['create_plan', 'approve_plan', 'plan_split', 'plan_reconcile'],
+    intentSignals: {
+      'plan this': 'create_plan',
+      'break this down': 'create_plan',
+      'approve the plan': 'approve_plan',
+      'split into tasks': 'plan_split',
+      'how did it go': 'plan_reconcile',
+    },
   },
   {
     suffix: 'brain',
     description: 'Learning system — intelligence pipeline, strengths, feedback, sessions.',
     keyOps: ['recommend', 'strengths', 'feedback'],
+    intentSignals: {
+      'what works': 'recommend',
+      'recommendations': 'recommend',
+      'pattern strengths': 'strengths',
+      'give feedback': 'feedback',
+    },
   },
   {
     suffix: 'memory',
     description: 'Session & cross-project memory — capture, search, dedup, promote.',
     keyOps: ['memory_search', 'memory_capture', 'session_capture'],
+    intentSignals: {
+      'recall past work': 'memory_search',
+      'what did we do': 'memory_search',
+      'last time': 'memory_search',
+      'wrap up session': 'session_capture',
+      'summarize session': 'session_capture',
+    },
   },
   {
     suffix: 'admin',
     description: 'Infrastructure — health, config, telemetry, tokens, LLM, prompts.',
     keyOps: ['admin_health', 'admin_tool_list', 'admin_diagnostic'],
+    intentSignals: {
+      'health check': 'admin_health',
+      'system status': 'admin_health',
+      'what tools exist': 'admin_tool_list',
+      'run diagnostics': 'admin_diagnostic',
+    },
   },
   {
     suffix: 'curator',
     description: 'Quality — duplicate detection, contradictions, grooming, health audit.',
     keyOps: ['curator_groom', 'curator_status', 'curator_health'],
+    intentSignals: {
+      'clean up vault': 'curator_groom',
+      'find duplicates': 'curator_groom',
+      'vault quality': 'curator_status',
+      'audit knowledge': 'curator_health',
+    },
   },
   {
     suffix: 'loop',
     description: 'Iterative validation loops — start, iterate, cancel, complete, history.',
     keyOps: ['loop_start', 'loop_status', 'loop_cancel'],
+    intentSignals: {
+      'start a loop': 'loop_start',
+      'iterate on this': 'loop_start',
+      'loop status': 'loop_status',
+      'stop the loop': 'loop_cancel',
+    },
   },
   {
     suffix: 'orchestrate',
     description:
       'Execution orchestration — project registration, playbooks, plan/execute/complete.',
     keyOps: ['orchestrate_plan', 'orchestrate_execute', 'orchestrate_complete'],
+    intentSignals: {
+      'do this task': 'orchestrate_plan',
+      'build this': 'orchestrate_plan',
+      'execute the plan': 'orchestrate_execute',
+      'finish up': 'orchestrate_complete',
+    },
   },
   {
     suffix: 'control',
     description: 'Agent behavior — identity, intent routing, morphing, guidelines, governance.',
     keyOps: ['route_intent', 'morph', 'get_behavior_rules'],
+    intentSignals: {
+      'what should I do': 'route_intent',
+      'change persona': 'morph',
+      'behavior rules': 'get_behavior_rules',
+    },
   },
   {
     suffix: 'context',
     description: 'Context analysis — entity extraction, knowledge retrieval, confidence scoring.',
     keyOps: ['context_extract_entities', 'context_retrieve_knowledge', 'context_analyze'],
+    intentSignals: {
+      'extract entities': 'context_extract_entities',
+      'get context': 'context_retrieve_knowledge',
+      'analyze this': 'context_analyze',
+    },
   },
   {
     suffix: 'agency',
     description: 'Proactive intelligence — file watching, pattern surfacing, warnings.',
     keyOps: ['agency_scan_file', 'agency_surface_patterns', 'agency_warnings'],
+    intentSignals: {
+      'scan this file': 'agency_scan_file',
+      'surface patterns': 'agency_surface_patterns',
+      'any warnings': 'agency_warnings',
+    },
   },
   {
     suffix: 'chat',
     description: 'Chat transport — session management, response chunking, authentication.',
     keyOps: ['chat_send', 'chat_history', 'chat_session'],
+    intentSignals: {
+      'send message': 'chat_send',
+      'chat history': 'chat_history',
+      'start chat': 'chat_session',
+    },
   },
   {
     suffix: 'operator',
     description: 'Operator profile — personality learning, signals, adaptation.',
     keyOps: ['profile_get', 'signal_accumulate', 'synthesis_check'],
+    intentSignals: {
+      'who am I': 'profile_get',
+      'my profile': 'profile_get',
+      'learn my style': 'signal_accumulate',
+    },
   },
   {
     suffix: 'archive',
     description: 'Archival, lifecycle, and knowledge maintenance.',
     keyOps: ['vault_archive', 'vault_restore', 'vault_optimize', 'knowledge_audit'],
+    intentSignals: {
+      'archive entries': 'vault_archive',
+      'restore archived': 'vault_restore',
+      'optimize vault': 'vault_optimize',
+      'knowledge audit': 'knowledge_audit',
+    },
   },
   {
     suffix: 'sync',
     description: 'Git, Obsidian, and pack sync operations.',
     keyOps: ['vault_git_push', 'vault_git_pull', 'obsidian_sync'],
+    intentSignals: {
+      'push vault': 'vault_git_push',
+      'pull vault': 'vault_git_pull',
+      'sync obsidian': 'obsidian_sync',
+    },
   },
   {
     suffix: 'review',
     description: 'Knowledge review workflow.',
     keyOps: ['vault_submit_review', 'vault_approve', 'vault_reject'],
+    intentSignals: {
+      'submit for review': 'vault_submit_review',
+      'approve entry': 'vault_approve',
+      'reject entry': 'vault_reject',
+    },
+  },
+  {
+    suffix: 'intake',
+    description: 'Content ingestion — books, URLs, text, batch import.',
+    keyOps: ['intake_ingest_book', 'ingest_url', 'ingest_text', 'ingest_batch'],
+    intentSignals: {
+      'ingest a book': 'intake_ingest_book',
+      'import from URL': 'ingest_url',
+      'ingest text': 'ingest_text',
+      'batch import': 'ingest_batch',
+    },
+  },
+  {
+    suffix: 'links',
+    description: 'Entry linking — create, traverse, suggest, orphan detection.',
+    keyOps: ['link_entries', 'traverse', 'suggest_links', 'get_orphans'],
+    intentSignals: {
+      'link entries': 'link_entries',
+      'explore connections': 'traverse',
+      'suggest links': 'suggest_links',
+      'find orphans': 'get_orphans',
+    },
+  },
+  {
+    suffix: 'branching',
+    description: 'Vault branching — create, list, merge, delete branches.',
+    keyOps: ['vault_branch', 'vault_branch_list', 'vault_merge_branch'],
+    intentSignals: {
+      'create branch': 'vault_branch',
+      'list branches': 'vault_branch_list',
+      'merge branch': 'vault_merge_branch',
+    },
+  },
+  {
+    suffix: 'tier',
+    description: 'Multi-vault tiers — connect, disconnect, search across sources.',
+    keyOps: ['vault_connect_source', 'vault_search_all', 'vault_list_sources'],
+    intentSignals: {
+      'connect source': 'vault_connect_source',
+      'search all vaults': 'vault_search_all',
+      'list sources': 'vault_list_sources',
+    },
   },
 ];
 

package/src/engine/register-engine.test.ts

@@ -97,7 +97,12 @@ describe('registerEngine — core ops', () => {
   it('registers core facade when coreOps provided', () => {
     const server = makeServer();
     const coreOps: OpDefinition[] = [
-      { name: 'health', description: 'Health check', auth: 'read', handler: async () => ({ ok: true }) },
+      {
+        name: 'health',
+        description: 'Health check',
+        auth: 'read',
+        handler: async () => ({ ok: true }),
+      },
     ];
     const result = registerEngine(server, runtime, { agentId: 'core', coreOps });
     expect(result.tools).toContain('core_core');

package/src/engine/register-engine.ts

@@ -39,6 +39,10 @@ import { createOperatorFacadeOps } from '../runtime/facades/operator-facade.js';
 import { createArchiveFacadeOps } from '../runtime/facades/archive-facade.js';
 import { createSyncFacadeOps } from '../runtime/facades/sync-facade.js';
 import { createReviewFacadeOps } from '../runtime/facades/review-facade.js';
+import { createIntakeFacadeOps } from '../runtime/facades/intake-facade.js';
+import { createLinksFacadeOps } from '../runtime/facades/links-facade.js';
+import { createBranchingFacadeOps } from '../runtime/facades/branching-facade.js';
+import { createTierFacadeOps } from '../runtime/facades/tier-facade.js';
 import { createDomainFacade } from '../runtime/domain-ops.js';
 
 // ─── Types ────────────────────────────────────────────────────────────
@@ -88,7 +92,7 @@ interface ModuleDef {
 export const ENGINE_MODULES: ModuleDef[] = [
   {
     suffix: 'vault',
-    description: 'Knowledge management — search, CRUD, import/export, intake, sharing, linking.',
+    description: 'Knowledge management — search, CRUD, capture, sharing scope.',
     createOps: createVaultFacadeOps,
   },
   {
@@ -123,8 +127,7 @@ export const ENGINE_MODULES: ModuleDef[] = [
   },
   {
     suffix: 'orchestrate',
-    description:
-      'Execution orchestration — session start, playbooks, plan/execute/complete.',
+    description: 'Execution orchestration — session start, playbooks, plan/execute/complete.',
     createOps: createOrchestrateFacadeOps,
   },
   {
@@ -167,6 +170,26 @@ export const ENGINE_MODULES: ModuleDef[] = [
     description: 'Knowledge review workflow.',
     createOps: createReviewFacadeOps,
   },
+  {
+    suffix: 'intake',
+    description: 'Content ingestion — books, URLs, text, batch import.',
+    createOps: createIntakeFacadeOps,
+  },
+  {
+    suffix: 'links',
+    description: 'Entry linking — create, traverse, suggest, orphan detection.',
+    createOps: createLinksFacadeOps,
+  },
+  {
+    suffix: 'branching',
+    description: 'Vault branching — create, list, merge, delete branches.',
+    createOps: createBranchingFacadeOps,
+  },
+  {
+    suffix: 'tier',
+    description: 'Multi-vault tiers — connect, disconnect, search across sources.',
+    createOps: createTierFacadeOps,
+  },
 ];
 
 // ─── Core Registration ────────────────────────────────────────────────