@soleri/core 2.9.0 → 2.11.0

package/src/__tests__/claudemd.test.ts

@@ -0,0 +1,282 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { join } from 'node:path';
+import { mkdtempSync, rmSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import {
+  composeCLAUDEmd,
+  OPEN_MARKER,
+  CLOSE_MARKER,
+  USER_ZONE_OPEN,
+  USER_ZONE_CLOSE,
+} from '../claudemd/compose.js';
+import {
+  injectCLAUDEmd,
+  removeCLAUDEmd,
+  hasCLAUDEmdBlock,
+  extractUserZone,
+} from '../claudemd/inject.js';
+import type { AgentMeta } from '../claudemd/types.js';
+import type { FacadeConfig } from '../facades/types.js';
+
+const testAgent: AgentMeta = {
+  id: 'test-agent',
+  name: 'TestAgent',
+  activationPhrase: 'Hello, TestAgent!',
+  deactivationPhrase: 'Goodbye, TestAgent!',
+  activateCommand: 'test-agent_core op:activate params:{ projectPath: "." }',
+  deactivateCommand: 'test-agent_core op:activate params:{ deactivate: true }',
+};
+
+const testFacades: FacadeConfig[] = [
+  {
+    name: 'test-agent_core',
+    description: 'Core facade',
+    ops: [
+      { name: 'health', description: 'Health check', auth: 'read', handler: async () => ({}) },
+      { name: 'search', description: 'Search vault', auth: 'read', handler: async () => ({}) },
+      { name: 'capture', description: 'Capture', auth: 'write', handler: async () => ({}) },
+    ],
+  },
+  {
+    name: 'test-agent_design',
+    description: 'Design facade',
+    ops: [
+      { name: 'check_contrast', description: 'Contrast', auth: 'read', handler: async () => ({}) },
+      { name: 'validate_token', description: 'Validate', auth: 'read', handler: async () => ({}) },
+    ],
+  },
+];
+
+describe('composeCLAUDEmd', () => {
+  it('produces content wrapped in versioned markers', () => {
+    const result = composeCLAUDEmd(testAgent, testFacades);
+    expect(result).toContain(OPEN_MARKER);
+    expect(result).toContain(CLOSE_MARKER);
+    expect(result).toContain('v1');
+  });
+
+  it('includes activation phrases', () => {
+    const result = composeCLAUDEmd(testAgent, testFacades);
+    expect(result).toContain('Hello, TestAgent!');
+    expect(result).toContain('Goodbye, TestAgent!');
+  });
+
+  it('includes session start protocol', () => {
+    const result = composeCLAUDEmd(testAgent, testFacades);
+    expect(result).toContain('Session Start Protocol');
+    expect(result).toContain('test-agent_core op:register');
+  });
+
+  it('generates facade reference table', () => {
+    const result = composeCLAUDEmd(testAgent, testFacades);
+    expect(result).toContain('| Facade | Key Ops |');
+    expect(result).toContain('`test-agent_core`');
+    expect(result).toContain('`test-agent_design`');
+    expect(result).toContain('`health`');
+    expect(result).toContain('`check_contrast`');
+  });
+
+  it('includes global instructions sorted by priority', () => {
+    const agent: AgentMeta = {
+      ...testAgent,
+      globalInstructions: [
+        { heading: 'Low Priority', content: 'Come last', priority: 90 },
+        { heading: 'High Priority', content: 'Come first', priority: 10 },
+      ],
+    };
+    const result = composeCLAUDEmd(agent, testFacades);
+    const highIdx = result.indexOf('High Priority');
+    const lowIdx = result.indexOf('Low Priority');
+    expect(highIdx).toBeLessThan(lowIdx);
+  });
+
+  it('includes facade behavioral rules', () => {
+    const instructions = new Map([
+      [
+        'test-agent_core',
+        {
+          heading: 'Planning',
+          rules: ['Always plan before coding', 'Wait for approval'],
+          priority: 10,
+        },
+      ],
+    ]);
+    const result = composeCLAUDEmd(testAgent, testFacades, { facadeInstructions: instructions });
+    expect(result).toContain('## Planning');
+    expect(result).toContain('- Always plan before coding');
+    expect(result).toContain('- Wait for approval');
+  });
+
+  it('includes user-safe zone when requested', () => {
+    const result = composeCLAUDEmd(testAgent, testFacades, { includeUserZone: true });
+    expect(result).toContain(USER_ZONE_OPEN);
+    expect(result).toContain(USER_ZONE_CLOSE);
+  });
+});
+
+describe('injectCLAUDEmd', () => {
+  let tempDir: string;
+  let filePath: string;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'soleri-claudemd-'));
+    filePath = join(tempDir, 'CLAUDE.md');
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('creates a new file if none exists', () => {
+    const block = composeCLAUDEmd(testAgent, testFacades);
+    const result = injectCLAUDEmd(filePath, block);
+    expect(result.success).toBe(true);
+    expect(result.action).toBe('injected');
+    const content = readFileSync(filePath, 'utf-8');
+    expect(content).toContain(OPEN_MARKER);
+  });
+
+  it('appends to existing file without markers', () => {
+    writeFileSync(filePath, '# My Project\n\nSome user content.\n');
+    const block = composeCLAUDEmd(testAgent, testFacades);
+    const result = injectCLAUDEmd(filePath, block);
+    expect(result.action).toBe('injected');
+    const content = readFileSync(filePath, 'utf-8');
+    expect(content).toContain('# My Project');
+    expect(content).toContain(OPEN_MARKER);
+  });
+
+  it('replaces existing block', () => {
+    const block1 = composeCLAUDEmd(testAgent, testFacades);
+    writeFileSync(filePath, `# Header\n\n${block1}\n\n# Footer\n`);
+
+    const newAgent = { ...testAgent, name: 'UpdatedAgent' };
+    const block2 = composeCLAUDEmd(newAgent, testFacades);
+    const result = injectCLAUDEmd(filePath, block2);
+
+    expect(result.action).toBe('replaced');
+    expect(result.diffDetected).toBe(true);
+    const content = readFileSync(filePath, 'utf-8');
+    expect(content).toContain('UpdatedAgent');
+    expect(content).not.toContain('TestAgent Mode');
+    expect(content).toContain('# Header');
+    expect(content).toContain('# Footer');
+  });
+
+  it('skips write when content is identical', () => {
+    const block = composeCLAUDEmd(testAgent, testFacades);
+    writeFileSync(filePath, block);
+    const result = injectCLAUDEmd(filePath, block);
+    expect(result.action).toBe('skipped');
+    expect(result.diffDetected).toBe(false);
+  });
+
+  it('preserves user-safe zone content on regeneration', () => {
+    const block1 = composeCLAUDEmd(testAgent, testFacades, { includeUserZone: true });
+    // Simulate user adding custom content inside the zone
+    const customContent = 'My custom instructions here';
+    const withCustom = block1.replace(
+      `${USER_ZONE_OPEN}\n\n${USER_ZONE_CLOSE}`,
+      `${USER_ZONE_OPEN}\n${customContent}\n${USER_ZONE_CLOSE}`,
+    );
+    writeFileSync(filePath, withCustom);
+
+    // Regenerate — should preserve user content
+    const block2 = composeCLAUDEmd(testAgent, testFacades, { includeUserZone: true });
+    const result = injectCLAUDEmd(filePath, block2);
+    expect(result.success).toBe(true);
+    const content = readFileSync(filePath, 'utf-8');
+    expect(content).toContain(customContent);
+  });
+
+  it('migrates legacy unversioned markers', () => {
+    const legacyBlock = '<!-- agent:mode -->\n\nOld content\n\n<!-- /agent:mode -->';
+    writeFileSync(filePath, `# Header\n\n${legacyBlock}\n`);
+
+    const block = composeCLAUDEmd(testAgent, testFacades);
+    const result = injectCLAUDEmd(filePath, block);
+    expect(result.action).toBe('replaced');
+    const content = readFileSync(filePath, 'utf-8');
+    expect(content).toContain(OPEN_MARKER); // v1 marker
+    expect(content).not.toContain('Old content');
+  });
+});
+
+describe('removeCLAUDEmd', () => {
+  let tempDir: string;
+  let filePath: string;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'soleri-claudemd-'));
+    filePath = join(tempDir, 'CLAUDE.md');
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('removes agent block and preserves surrounding content', () => {
+    const block = composeCLAUDEmd(testAgent, testFacades);
+    writeFileSync(filePath, `# Header\n\n${block}\n\n# Footer\n`);
+    const result = removeCLAUDEmd(filePath);
+    expect(result.action).toBe('removed');
+    const content = readFileSync(filePath, 'utf-8');
+    expect(content).toContain('# Header');
+    expect(content).toContain('# Footer');
+    expect(content).not.toContain(OPEN_MARKER);
+  });
+
+  it('returns not_present when no block exists', () => {
+    writeFileSync(filePath, '# Just a file\n');
+    expect(removeCLAUDEmd(filePath).action).toBe('not_present');
+  });
+
+  it('returns not_present for missing file', () => {
+    expect(removeCLAUDEmd(filePath).action).toBe('not_present');
+  });
+});
+
+describe('hasCLAUDEmdBlock', () => {
+  let tempDir: string;
+  let filePath: string;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'soleri-claudemd-'));
+    filePath = join(tempDir, 'CLAUDE.md');
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('returns true when block exists', () => {
+    const block = composeCLAUDEmd(testAgent, testFacades);
+    writeFileSync(filePath, block);
+    expect(hasCLAUDEmdBlock(filePath)).toBe(true);
+  });
+
+  it('returns false when no block', () => {
+    writeFileSync(filePath, '# No agent block\n');
+    expect(hasCLAUDEmdBlock(filePath)).toBe(false);
+  });
+
+  it('returns false for missing file', () => {
+    expect(hasCLAUDEmdBlock(filePath)).toBe(false);
+  });
+});
+
+describe('extractUserZone', () => {
+  it('extracts content between user zone markers', () => {
+    const content = `Some stuff\n${USER_ZONE_OPEN}\nMy custom stuff\n${USER_ZONE_CLOSE}\nMore`;
+    expect(extractUserZone(content)).toBe('My custom stuff');
+  });
+
+  it('returns null for empty zone', () => {
+    const content = `${USER_ZONE_OPEN}\n\n${USER_ZONE_CLOSE}`;
+    expect(extractUserZone(content)).toBeNull();
+  });
+
+  it('returns null when no zone markers', () => {
+    expect(extractUserZone('just text')).toBeNull();
+  });
+});

package/src/__tests__/context-engine.test.ts

@@ -0,0 +1,256 @@
+/**
+ * Context Engine Tests — entity extraction, knowledge retrieval, confidence scoring.
+ */
+
+import { describe, test, expect, beforeEach } from 'vitest';
+import { Vault } from '../vault/vault.js';
+import { Brain } from '../brain/brain.js';
+import { BrainIntelligence } from '../brain/intelligence.js';
+import { ContextEngine } from '../context/context-engine.js';
+
+describe('ContextEngine', () => {
+  let vault: Vault;
+  let brain: Brain;
+  let intelligence: BrainIntelligence;
+  let engine: ContextEngine;
+
+  beforeEach(() => {
+    vault = new Vault(':memory:');
+    brain = new Brain(vault);
+    intelligence = new BrainIntelligence(vault, brain);
+    engine = new ContextEngine(vault, brain, intelligence, null);
+  });
+
+  // ─── Entity Extraction ───────────────────────────────────────────
+
+  describe('extractEntities', () => {
+    test('extracts file paths', () => {
+      const result = engine.extractEntities('Fix the bug in src/vault/vault.ts');
+      const files = result.byType.file ?? [];
+      expect(files.length).toBeGreaterThan(0);
+      expect(files.some((f) => f.value.includes('vault.ts'))).toBe(true);
+    });
+
+    test('extracts function calls', () => {
+      const result = engine.extractEntities('The search() method returns wrong results');
+      const functions = result.byType.function ?? [];
+      expect(functions.length).toBeGreaterThan(0);
+      expect(functions.some((f) => f.value === 'search()')).toBe(true);
+    });
+
+    test('extracts domain keywords', () => {
+      const result = engine.extractEntities('Improve accessibility and performance');
+      const domains = result.byType.domain ?? [];
+      expect(domains.length).toBe(2);
+      expect(domains.some((d) => d.value === 'accessibility')).toBe(true);
+      expect(domains.some((d) => d.value === 'performance')).toBe(true);
+    });
+
+    test('extracts action verbs', () => {
+      const result = engine.extractEntities('Create a new component and test it');
+      const actions = result.byType.action ?? [];
+      expect(actions.some((a) => a.value === 'create')).toBe(true);
+      expect(actions.some((a) => a.value === 'test')).toBe(true);
+    });
+
+    test('extracts technologies', () => {
+      const result = engine.extractEntities('Build a React component with TypeScript');
+      const techs = result.byType.technology ?? [];
+      expect(techs.some((t) => t.value === 'react')).toBe(true);
+      expect(techs.some((t) => t.value === 'typescript')).toBe(true);
+    });
+
+    test('deduplicates entities', () => {
+      const result = engine.extractEntities('Fix the fix for the fix');
+      const actions = result.byType.action ?? [];
+      const fixActions = actions.filter((a) => a.value === 'fix');
+      expect(fixActions.length).toBe(1);
+    });
+
+    test('filters stop patterns', () => {
+      const result = engine.extractEntities('This is a real-time built-in feature');
+      const patterns = result.byType.pattern ?? [];
+      expect(patterns.some((p) => p.value === 'real-time')).toBe(false);
+      expect(patterns.some((p) => p.value === 'built-in')).toBe(false);
+    });
+
+    test('returns empty for empty prompt', () => {
+      const result = engine.extractEntities('');
+      expect(result.entities.length).toBe(0);
+    });
+
+    test('groups entities by type', () => {
+      const result = engine.extractEntities('Create a React component in src/app.tsx for security');
+      expect(result.byType.action).toBeDefined();
+      expect(result.byType.technology).toBeDefined();
+      expect(result.byType.file).toBeDefined();
+      expect(result.byType.domain).toBeDefined();
+    });
+  });
+
+  // ─── Knowledge Retrieval ─────────────────────────────────────────
+
+  describe('retrieveKnowledge', () => {
+    test('retrieves from vault FTS', async () => {
+      vault.seed([
+        {
+          id: 'p1',
+          type: 'pattern',
+          domain: 'design',
+          title: 'Button component pattern',
+          severity: 'suggestion',
+          description: 'Use semantic HTML for buttons',
+          tags: ['design', 'component'],
+        },
+      ]);
+
+      // Use single term for FTS5 compatibility
+      const result = await engine.retrieveKnowledge('button');
+      expect(result.vaultHits).toBeGreaterThan(0);
+      expect(result.items.length).toBeGreaterThan(0);
+      expect(result.items[0].source).toBe('vault');
+    });
+
+    test('returns empty when vault has no matches', async () => {
+      const result = await engine.retrieveKnowledge('xyzzy nonexistent query');
+      expect(result.items.length).toBe(0);
+      expect(result.vaultHits).toBe(0);
+    });
+
+    test('handles null cognee gracefully', async () => {
+      const result = await engine.retrieveKnowledge('anything');
+      expect(result.cogneeHits).toBe(0);
+    });
+
+    test('filters by domain', async () => {
+      vault.seed([
+        {
+          id: 'p1',
+          type: 'pattern',
+          domain: 'design',
+          title: 'Design pattern one',
+          severity: 'suggestion',
+          description: 'A design domain pattern',
+          tags: ['design'],
+        },
+        {
+          id: 'p2',
+          type: 'pattern',
+          domain: 'security',
+          title: 'Security pattern one',
+          severity: 'warning',
+          description: 'A security domain pattern',
+          tags: ['security'],
+        },
+      ]);
+
+      // Search for "pattern" (exists in both entries) filtered to design domain
+      const result = await engine.retrieveKnowledge('pattern', 'design');
+      expect(result.vaultHits).toBe(1);
+      expect(result.items.length).toBeGreaterThan(0);
+      expect(result.items[0].domain).toBe('design');
+    });
+  });
+
+  // ─── Context Analysis ────────────────────────────────────────────
+
+  describe('analyze', () => {
+    test('returns full context analysis', async () => {
+      vault.seed([
+        {
+          id: 'r1',
+          type: 'rule',
+          domain: 'accessibility',
+          title: 'All buttons must have labels',
+          severity: 'critical',
+          description: 'Screen readers require button labels for navigation',
+          tags: ['accessibility', 'button'],
+        },
+      ]);
+
+      const result = await engine.analyze('Fix the accessibility issue with buttons');
+
+      expect(result.prompt).toBe('Fix the accessibility issue with buttons');
+      expect(result.entities.entities.length).toBeGreaterThan(0);
+      expect(result.confidence).toBeGreaterThan(0);
+      expect(result.confidenceLevel).toBeDefined();
+      expect(result.detectedDomains).toContain('accessibility');
+      expect(result.processingTimeMs).toBeGreaterThanOrEqual(0);
+    });
+
+    test('detects domains from entities and knowledge', async () => {
+      vault.seed([
+        {
+          id: 'r1',
+          type: 'rule',
+          domain: 'performance',
+          title: 'Avoid N+1 queries',
+          severity: 'warning',
+          description: 'Batch database queries to avoid N+1 problems',
+          tags: ['performance', 'database'],
+        },
+      ]);
+
+      const result = await engine.analyze('Optimize the performance of database queries');
+      expect(result.detectedDomains).toContain('performance');
+    });
+
+    test('low confidence for vague prompts', async () => {
+      const result = await engine.analyze('do something');
+      expect(result.confidenceLevel).toBe('low');
+    });
+
+    test('higher confidence with entities and knowledge', async () => {
+      vault.seed([
+        {
+          id: 'r1',
+          type: 'pattern',
+          domain: 'testing',
+          title: 'Unit test best practices',
+          severity: 'suggestion',
+          description: 'Write focused unit tests that test one thing',
+          tags: ['testing'],
+        },
+      ]);
+
+      const result = await engine.analyze(
+        'Create unit tests for the search() function in src/vault/vault.ts with TypeScript',
+      );
+      expect(result.confidence).toBeGreaterThan(0.4);
+      expect(result.entities.entities.length).toBeGreaterThan(3);
+    });
+
+    test('includes processing time', async () => {
+      const result = await engine.analyze('test query');
+      expect(typeof result.processingTimeMs).toBe('number');
+      expect(result.processingTimeMs).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  // ─── Configuration ───────────────────────────────────────────────
+
+  describe('configuration', () => {
+    test('respects custom config', async () => {
+      const customEngine = new ContextEngine(vault, brain, intelligence, null, {
+        vaultSearchLimit: 2,
+        minScoreThreshold: 0.9,
+      });
+
+      vault.seed(
+        Array.from({ length: 10 }, (_, i) => ({
+          id: `entry-${i}`,
+          type: 'pattern' as const,
+          domain: 'general',
+          title: `Pattern ${i} for testing`,
+          severity: 'suggestion' as const,
+          description: `Description for pattern ${i}`,
+          tags: ['general'],
+        })),
+      );
+
+      const result = await customEngine.retrieveKnowledge('pattern testing');
+      // High threshold filters out low-score items
+      expect(result.items.every((i) => i.score >= 0.9)).toBe(true);
+    });
+  });
+});

package/src/__tests__/core-ops.test.ts

@@ -20,7 +20,7 @@ describe('createSemanticFacades', () => {
       vaultPath: ':memory:',
       plansPath: join(plannerDir, 'plans.json'),
     });
-    ops = createSemanticFacades(runtime, 'test').flatMap(f => f.ops);
+    ops = createSemanticFacades(runtime, 'test').flatMap((f) => f.ops);
   });
 
   afterEach(() => {
@@ -34,8 +34,8 @@ describe('createSemanticFacades', () => {
     return op;
   }
 
-  it('should return 209 ops', () => {
-    expect(ops.length).toBe(209);
+  it('should return 232 ops', () => {
+    expect(ops.length).toBe(314);
   });
 
   it('should have all expected op names', () => {
@@ -78,6 +78,11 @@ describe('createSemanticFacades', () => {
     expect(names).toContain('brain_promote_proposals');
     expect(names).toContain('brain_lifecycle');
     expect(names).toContain('brain_reset_extracted');
+    // Session management (#178)
+    expect(names).toContain('session_list');
+    expect(names).toContain('session_get');
+    expect(names).toContain('session_quality');
+    expect(names).toContain('session_replay');
     // Brain decay report (#89)
     expect(names).toContain('brain_decay_report');
     // Curator
@@ -104,6 +109,69 @@ describe('createSemanticFacades', () => {
     expect(names).toContain('cognee_add');
     expect(names).toContain('cognee_cognify');
     expect(names).toContain('cognee_config');
+    // Context Engine (#172)
+    expect(names).toContain('context_extract_entities');
+    expect(names).toContain('context_retrieve_knowledge');
+    expect(names).toContain('context_analyze');
+    // Agency Mode (#171)
+    expect(names).toContain('agency_enable');
+    expect(names).toContain('agency_disable');
+    expect(names).toContain('agency_status');
+    expect(names).toContain('agency_config');
+    expect(names).toContain('agency_scan_file');
+    expect(names).toContain('agency_warnings');
+    expect(names).toContain('agency_surface_patterns');
+    expect(names).toContain('agency_clarify');
+    // Chat transport (12)
+    expect(names).toContain('chat_session_init');
+    expect(names).toContain('chat_session_get');
+    expect(names).toContain('chat_session_append');
+    expect(names).toContain('chat_session_clear');
+    expect(names).toContain('chat_session_delete');
+    expect(names).toContain('chat_session_list');
+    expect(names).toContain('chat_chunk_response');
+    expect(names).toContain('chat_auth_init');
+    expect(names).toContain('chat_auth_check');
+    expect(names).toContain('chat_auth_authenticate');
+    expect(names).toContain('chat_auth_revoke');
+    expect(names).toContain('chat_auth_status');
+    // Chat bridge + compressor (5)
+    expect(names).toContain('chat_bridge_init');
+    expect(names).toContain('chat_bridge_register');
+    expect(names).toContain('chat_bridge_list');
+    expect(names).toContain('chat_bridge_execute');
+    expect(names).toContain('chat_compress_output');
+    // Chat cancellation (3)
+    expect(names).toContain('chat_cancel_create');
+    expect(names).toContain('chat_cancel_stop');
+    expect(names).toContain('chat_cancel_status');
+    // Chat self-update (3)
+    expect(names).toContain('chat_update_init');
+    expect(names).toContain('chat_update_request');
+    expect(names).toContain('chat_update_confirm');
+    // Chat file handling (3)
+    expect(names).toContain('chat_file_detect_intent');
+    expect(names).toContain('chat_file_build_content');
+    expect(names).toContain('chat_file_cleanup');
+    // Chat notifications (5)
+    expect(names).toContain('chat_notify_init');
+    expect(names).toContain('chat_notify_start');
+    expect(names).toContain('chat_notify_stop');
+    expect(names).toContain('chat_notify_poll');
+    expect(names).toContain('chat_notify_status');
+    // Chat voice (2)
+    expect(names).toContain('chat_voice_transcribe');
+    expect(names).toContain('chat_voice_synthesize');
+    // Chat queue (4)
+    expect(names).toContain('chat_queue_init');
+    expect(names).toContain('chat_queue_inbox');
+    expect(names).toContain('chat_queue_reply');
+    expect(names).toContain('chat_queue_drain');
+    // Chat browser (4)
+    expect(names).toContain('chat_browser_init');
+    expect(names).toContain('chat_browser_acquire');
+    expect(names).toContain('chat_browser_release');
+    expect(names).toContain('chat_browser_status');
     // LLM
     expect(names).toContain('llm_rotate');
     expect(names).toContain('llm_call');
@@ -162,6 +230,27 @@ describe('createSemanticFacades', () => {
     // Vault content hashing (#166)
     expect(names).toContain('vault_content_hash');
     expect(names).toContain('vault_dedup_status');
+    // Obsidian sync (#127)
+    expect(names).toContain('obsidian_export');
+    expect(names).toContain('obsidian_import');
+    expect(names).toContain('obsidian_sync');
+    // Vault Sharing — Scoping (#105)
+    expect(names).toContain('vault_detect_scope');
+    expect(names).toContain('vault_set_scope');
+    expect(names).toContain('vault_list_by_scope');
+    // Vault Sharing — Export (#104)
+    expect(names).toContain('vault_export_pack');
+    expect(names).toContain('vault_import_pack');
+    // Vault Sharing — Git Sync (#67)
+    expect(names).toContain('vault_git_push');
+    expect(names).toContain('vault_git_pull');
+    expect(names).toContain('vault_git_sync');
+    // Vault Sharing — Review (#65)
+    expect(names).toContain('vault_submit_review');
+    expect(names).toContain('vault_approve');
+    expect(names).toContain('vault_reject');
+    expect(names).toContain('vault_pending_reviews');
+    expect(names).toContain('vault_review_stats');
     // Admin (8)
     expect(names).toContain('admin_health');
     expect(names).toContain('admin_tool_list');
@@ -184,6 +273,9 @@ describe('createSemanticFacades', () => {
     expect(names).toContain('admin_export_config');
     // Admin persistence (#85)
     expect(names).toContain('admin_persistence_info');
+    // Telemetry extended (#181)
+    expect(names).toContain('telemetry_errors');
+    expect(names).toContain('telemetry_slow_ops');
     // Loop (7)
     expect(names).toContain('loop_start');
     expect(names).toContain('loop_iterate');
@@ -267,7 +359,7 @@ describe('createSemanticFacades', () => {
     runtime.brain.rebuildVocabulary();
 
     // Re-create ops since brain state changed
-    ops = createSemanticFacades(runtime, 'test').flatMap(f => f.ops);
+    ops = createSemanticFacades(runtime, 'test').flatMap((f) => f.ops);
     const results = (await findOp('search').handler({ query: 'core ops test' })) as unknown[];
     expect(results.length).toBeGreaterThan(0);
   });
@@ -374,7 +466,7 @@ describe('createSemanticFacades', () => {
         tags: ['test'],
       },
     ]);
-    ops = createSemanticFacades(runtime, 'test').flatMap(f => f.ops);
+    ops = createSemanticFacades(runtime, 'test').flatMap((f) => f.ops);
     const result = (await findOp('brain_feedback').handler({
       query: 'test',
       entryId: 'bf-1',