@soleri/forge 5.8.0 → 5.10.0

package/dist/templates/test-facades.js

@@ -9,7 +9,7 @@ export function generateFacadesTest(config) {
     return `import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import {
   createAgentRuntime,
-  createCoreOps,
+  createSemanticFacades,
   createDomainFacade,
 } from '@soleri/core';
 import type { AgentRuntime, IntelligenceEntry, OpDefinition, FacadeConfig } from '@soleri/core';
@@ -54,9 +54,217 @@ describe('Facades', () => {
 
 ${domainDescribes}
 
-  describe('${config.id}_core', () => {
-    function buildCoreFacade(): FacadeConfig {
-      const coreOps = createCoreOps(runtime);
+  // ─── Semantic Facades ────────────────────────────────────────
+  describe('semantic facades', () => {
+    function buildSemanticFacades(): FacadeConfig[] {
+      return createSemanticFacades(runtime, '${config.id}');
+    }
+
+    it('should create 10 semantic facades', () => {
+      const facades = buildSemanticFacades();
+      expect(facades).toHaveLength(10);
+      const names = facades.map(f => f.name);
+      expect(names).toContain('${config.id}_vault');
+      expect(names).toContain('${config.id}_plan');
+      expect(names).toContain('${config.id}_brain');
+      expect(names).toContain('${config.id}_memory');
+      expect(names).toContain('${config.id}_admin');
+      expect(names).toContain('${config.id}_curator');
+      expect(names).toContain('${config.id}_loop');
+      expect(names).toContain('${config.id}_orchestrate');
+      expect(names).toContain('${config.id}_control');
+      expect(names).toContain('${config.id}_cognee');
+    });
+
+    it('total ops across all facades should be 209', () => {
+      const facades = buildSemanticFacades();
+      const totalOps = facades.reduce((sum, f) => sum + f.ops.length, 0);
+      expect(totalOps).toBe(209);
+    });
+  });
+
+  describe('${config.id}_vault', () => {
+    function getFacade(): FacadeConfig {
+      return createSemanticFacades(runtime, '${config.id}').find(f => f.name === '${config.id}_vault')!;
+    }
+
+    it('should contain vault ops', () => {
+      const opNames = getFacade().ops.map(o => o.name);
+      expect(opNames).toContain('search');
+      expect(opNames).toContain('vault_stats');
+      expect(opNames).toContain('list_all');
+      expect(opNames).toContain('export');
+      expect(opNames).toContain('vault_get');
+      expect(opNames).toContain('vault_import');
+      expect(opNames).toContain('capture_knowledge');
+      expect(opNames).toContain('intake_ingest_book');
+    });
+
+    it('search should query across all domains', async () => {
+      runtime.vault.seed([
+        makeEntry({ id: 'c1', domain: 'alpha', title: 'Alpha pattern', tags: ['a'] }),
+        makeEntry({ id: 'c2', domain: 'beta', title: 'Beta pattern', tags: ['b'] }),
+      ]);
+      runtime = createAgentRuntime({ agentId: '${config.id}', vaultPath: ':memory:', plansPath: join(plannerDir, 'plans2.json') });
+      runtime.vault.seed([
+        makeEntry({ id: 'c1', domain: 'alpha', title: 'Alpha pattern', tags: ['a'] }),
+        makeEntry({ id: 'c2', domain: 'beta', title: 'Beta pattern', tags: ['b'] }),
+      ]);
+      const facade = createSemanticFacades(runtime, '${config.id}').find(f => f.name === '${config.id}_vault')!;
+      const searchOp = facade.ops.find(o => o.name === 'search')!;
+      const results = (await searchOp.handler({ query: 'pattern' })) as Array<{ entry: unknown; score: number }>;
+      expect(Array.isArray(results)).toBe(true);
+      expect(results.length).toBe(2);
+    });
+
+    it('vault_stats should return counts', async () => {
+      runtime.vault.seed([
+        makeEntry({ id: 'vs1', domain: 'd1', tags: ['x'] }),
+        makeEntry({ id: 'vs2', domain: 'd2', tags: ['y'] }),
+      ]);
+      const facade = createSemanticFacades(runtime, '${config.id}').find(f => f.name === '${config.id}_vault')!;
+      const statsOp = facade.ops.find(o => o.name === 'vault_stats')!;
+      const stats = (await statsOp.handler({})) as { totalEntries: number };
+      expect(stats.totalEntries).toBe(2);
+    });
+  });
+
+  describe('${config.id}_plan', () => {
+    it('should contain planning ops', () => {
+      const facade = createSemanticFacades(runtime, '${config.id}').find(f => f.name === '${config.id}_plan')!;
+      const opNames = facade.ops.map(o => o.name);
+      expect(opNames).toContain('create_plan');
+      expect(opNames).toContain('get_plan');
+      expect(opNames).toContain('approve_plan');
+      expect(opNames).toContain('plan_iterate');
+      expect(opNames).toContain('plan_grade');
+    });
+
+    it('create_plan should create a draft plan', async () => {
+      const facade = createSemanticFacades(runtime, '${config.id}').find(f => f.name === '${config.id}_plan')!;
+      const createOp = facade.ops.find(o => o.name === 'create_plan')!;
+      const result = (await createOp.handler({
+        objective: 'Add caching',
+        scope: 'api layer',
+        tasks: [{ title: 'Add Redis', description: 'Set up Redis client' }],
+      })) as { created: boolean; plan: { status: string } };
+      expect(result.created).toBe(true);
+      expect(result.plan.status).toBe('draft');
+    });
+  });
+
+  describe('${config.id}_brain', () => {
+    it('should contain brain ops', () => {
+      const facade = createSemanticFacades(runtime, '${config.id}').find(f => f.name === '${config.id}_brain')!;
+      const opNames = facade.ops.map(o => o.name);
+      expect(opNames).toContain('brain_stats');
+      expect(opNames).toContain('brain_strengths');
+      expect(opNames).toContain('brain_build_intelligence');
+      expect(opNames).toContain('brain_lifecycle');
+      expect(opNames).toContain('brain_decay_report');
+    });
+
+    it('brain_stats should return intelligence stats', async () => {
+      const facade = createSemanticFacades(runtime, '${config.id}').find(f => f.name === '${config.id}_brain')!;
+      const statsOp = facade.ops.find(o => o.name === 'brain_stats')!;
+      const result = (await statsOp.handler({})) as { vocabularySize: number };
+      expect(result.vocabularySize).toBe(0);
+    });
+  });
+
+  describe('${config.id}_memory', () => {
+    it('should contain memory ops', () => {
+      const facade = createSemanticFacades(runtime, '${config.id}').find(f => f.name === '${config.id}_memory')!;
+      const opNames = facade.ops.map(o => o.name);
+      expect(opNames).toContain('memory_search');
+      expect(opNames).toContain('memory_capture');
+      expect(opNames).toContain('memory_promote_to_global');
+    });
+  });
+
+  describe('${config.id}_admin', () => {
+    it('should contain admin ops', () => {
+      const facade = createSemanticFacades(runtime, '${config.id}').find(f => f.name === '${config.id}_admin')!;
+      const opNames = facade.ops.map(o => o.name);
+      expect(opNames).toContain('admin_health');
+      expect(opNames).toContain('admin_tool_list');
+      expect(opNames).toContain('llm_rotate');
+      expect(opNames).toContain('render_prompt');
+    });
+  });
+
+  describe('${config.id}_curator', () => {
+    it('should contain curator ops', () => {
+      const facade = createSemanticFacades(runtime, '${config.id}').find(f => f.name === '${config.id}_curator')!;
+      const opNames = facade.ops.map(o => o.name);
+      expect(opNames).toContain('curator_status');
+      expect(opNames).toContain('curator_health_audit');
+      expect(opNames).toContain('curator_hybrid_contradictions');
+    });
+
+    it('curator_status should return initialized', async () => {
+      const facade = createSemanticFacades(runtime, '${config.id}').find(f => f.name === '${config.id}_curator')!;
+      const statusOp = facade.ops.find(o => o.name === 'curator_status')!;
+      const result = (await statusOp.handler({})) as { initialized: boolean };
+      expect(result.initialized).toBe(true);
+    });
+  });
+
+  describe('${config.id}_loop', () => {
+    it('should contain loop ops', () => {
+      const facade = createSemanticFacades(runtime, '${config.id}').find(f => f.name === '${config.id}_loop')!;
+      const opNames = facade.ops.map(o => o.name);
+      expect(opNames).toContain('loop_start');
+      expect(opNames).toContain('loop_iterate');
+      expect(opNames).toContain('loop_cancel');
+    });
+  });
+
+  describe('${config.id}_orchestrate', () => {
+    it('should contain orchestrate ops', () => {
+      const facade = createSemanticFacades(runtime, '${config.id}').find(f => f.name === '${config.id}_orchestrate')!;
+      const opNames = facade.ops.map(o => o.name);
+      expect(opNames).toContain('register');
+      expect(opNames).toContain('orchestrate_plan');
+      expect(opNames).toContain('project_get');
+      expect(opNames).toContain('playbook_list');
+    });
+  });
+
+  describe('${config.id}_control', () => {
+    it('should contain control and governance ops', () => {
+      const facade = createSemanticFacades(runtime, '${config.id}').find(f => f.name === '${config.id}_control')!;
+      const opNames = facade.ops.map(o => o.name);
+      expect(opNames).toContain('get_identity');
+      expect(opNames).toContain('route_intent');
+      expect(opNames).toContain('governance_policy');
+      expect(opNames).toContain('governance_dashboard');
+    });
+
+    it('governance_policy should return default policy', async () => {
+      const facade = createSemanticFacades(runtime, '${config.id}').find(f => f.name === '${config.id}_control')!;
+      const policyOp = facade.ops.find(o => o.name === 'governance_policy')!;
+      const result = (await policyOp.handler({ action: 'get', projectPath: '/test' })) as {
+        projectPath: string;
+        quotas: { maxEntriesTotal: number };
+      };
+      expect(result.projectPath).toBe('/test');
+      expect(result.quotas.maxEntriesTotal).toBe(500);
+    });
+  });
+
+  describe('${config.id}_cognee', () => {
+    it('should contain cognee ops', () => {
+      const facade = createSemanticFacades(runtime, '${config.id}').find(f => f.name === '${config.id}_cognee')!;
+      const opNames = facade.ops.map(o => o.name);
+      expect(opNames).toContain('cognee_status');
+      expect(opNames).toContain('cognee_search');
+      expect(opNames).toContain('cognee_sync_status');
+    });
+  });
+
+  describe('${config.id}_core (agent-specific)', () => {
+    function buildAgentFacade(): FacadeConfig {
       const agentOps: OpDefinition[] = [
         {
           name: 'health',
@@ -164,239 +372,30 @@ ${domainDescribes}
       ];
       return {
         name: '${config.id}_core',
-        description: 'Core operations',
-        ops: [...coreOps, ...agentOps],
+        description: 'Agent-specific operations',
+        ops: agentOps,
       };
     }
 
-    it('should create core facade with expected ops', () => {
-      const facade = buildCoreFacade();
-      expect(facade.name).toBe('${config.id}_core');
-      const opNames = facade.ops.map((o) => o.name);
-      // Core ops (37)
-      expect(opNames).toContain('search');
-      expect(opNames).toContain('vault_stats');
-      expect(opNames).toContain('list_all');
-      expect(opNames).toContain('register');
-      expect(opNames).toContain('llm_status');
-      expect(opNames).toContain('curator_status');
-      expect(opNames).toContain('curator_health_audit');
-      // Brain Intelligence ops (11)
-      expect(opNames).toContain('brain_session_context');
-      expect(opNames).toContain('brain_strengths');
-      expect(opNames).toContain('brain_global_patterns');
-      expect(opNames).toContain('brain_recommend');
-      expect(opNames).toContain('brain_build_intelligence');
-      expect(opNames).toContain('brain_export');
-      expect(opNames).toContain('brain_import');
-      expect(opNames).toContain('brain_extract_knowledge');
-      expect(opNames).toContain('brain_archive_sessions');
-      expect(opNames).toContain('brain_promote_proposals');
-      expect(opNames).toContain('brain_lifecycle');
-      // Enhanced brain ops (3)
-      expect(opNames).toContain('brain_feedback');
-      expect(opNames).toContain('brain_feedback_stats');
-      expect(opNames).toContain('brain_reset_extracted');
-      // Brain decay report (#89)
-      expect(opNames).toContain('brain_decay_report');
-      // Agent-specific ops (5)
-      expect(opNames).toContain('health');
-      expect(opNames).toContain('identity');
-      expect(opNames).toContain('activate');
-      expect(opNames).toContain('inject_claude_md');
-      expect(opNames).toContain('setup');
-      // Control ops (8)
-      expect(opNames).toContain('get_identity');
-      expect(opNames).toContain('update_identity');
-      expect(opNames).toContain('add_guideline');
-      expect(opNames).toContain('remove_guideline');
-      expect(opNames).toContain('rollback_identity');
-      expect(opNames).toContain('route_intent');
-      expect(opNames).toContain('morph');
-      expect(opNames).toContain('get_behavior_rules');
-      // Cognee ops (5)
-      expect(opNames).toContain('cognee_status');
-      expect(opNames).toContain('cognee_search');
-      expect(opNames).toContain('cognee_add');
-      expect(opNames).toContain('cognee_cognify');
-      expect(opNames).toContain('cognee_config');
-      // LLM ops (2)
-      expect(opNames).toContain('llm_rotate');
-      expect(opNames).toContain('llm_call');
-      // Governance ops (5)
-      expect(opNames).toContain('governance_policy');
-      expect(opNames).toContain('governance_proposals');
-      expect(opNames).toContain('governance_stats');
-      expect(opNames).toContain('governance_expire');
-      expect(opNames).toContain('governance_dashboard');
-      // Planning Extra ops (13)
-      expect(opNames).toContain('plan_iterate');
-      expect(opNames).toContain('plan_split');
-      expect(opNames).toContain('plan_reconcile');
-      expect(opNames).toContain('plan_complete_lifecycle');
-      expect(opNames).toContain('plan_dispatch');
-      expect(opNames).toContain('plan_review');
-      expect(opNames).toContain('plan_archive');
-      expect(opNames).toContain('plan_list_tasks');
-      expect(opNames).toContain('plan_stats');
-      expect(opNames).toContain('plan_execution_metrics');
-      expect(opNames).toContain('plan_record_task_metrics');
-      expect(opNames).toContain('plan_submit_deliverable');
-      expect(opNames).toContain('plan_verify_deliverables');
-      // Memory Extra ops (8)
-      expect(opNames).toContain('memory_delete');
-      expect(opNames).toContain('memory_stats');
-      expect(opNames).toContain('memory_export');
-      expect(opNames).toContain('memory_import');
-      expect(opNames).toContain('memory_prune');
-      expect(opNames).toContain('memory_deduplicate');
-      expect(opNames).toContain('memory_topics');
-      expect(opNames).toContain('memory_by_project');
-      // Vault Extra ops (12)
-      expect(opNames).toContain('vault_get');
-      expect(opNames).toContain('vault_update');
-      expect(opNames).toContain('vault_remove');
-      expect(opNames).toContain('vault_bulk_add');
-      expect(opNames).toContain('vault_bulk_remove');
-      expect(opNames).toContain('vault_tags');
-      expect(opNames).toContain('vault_domains');
-      expect(opNames).toContain('vault_recent');
-      expect(opNames).toContain('vault_import');
-      expect(opNames).toContain('vault_seed');
-      expect(opNames).toContain('vault_backup');
-      expect(opNames).toContain('vault_age_report');
-      // #89: Bi-temporal
-      expect(opNames).toContain('vault_set_temporal');
-      expect(opNames).toContain('vault_find_expiring');
-      expect(opNames).toContain('vault_find_expired');
-      // Admin ops (8)
-      expect(opNames).toContain('admin_health');
-      expect(opNames).toContain('admin_tool_list');
-      expect(opNames).toContain('admin_config');
-      expect(opNames).toContain('admin_vault_size');
-      expect(opNames).toContain('admin_uptime');
-      expect(opNames).toContain('admin_version');
-      expect(opNames).toContain('admin_reset_cache');
-      expect(opNames).toContain('admin_diagnostic');
-      // Loop ops (8)
-      expect(opNames).toContain('loop_start');
-      expect(opNames).toContain('loop_iterate');
-      expect(opNames).toContain('loop_status');
-      expect(opNames).toContain('loop_cancel');
-      expect(opNames).toContain('loop_history');
-      expect(opNames).toContain('loop_is_active');
-      expect(opNames).toContain('loop_complete');
-      expect(opNames).toContain('loop_anomaly_check');
-      // Orchestrate ops (5)
-      expect(opNames).toContain('orchestrate_plan');
-      expect(opNames).toContain('orchestrate_execute');
-      expect(opNames).toContain('orchestrate_complete');
-      expect(opNames).toContain('orchestrate_status');
-      expect(opNames).toContain('orchestrate_quick_capture');
-      // Capture ops (4)
-      expect(opNames).toContain('capture_knowledge');
-      expect(opNames).toContain('capture_quick');
-      expect(opNames).toContain('search_intelligent');
-      expect(opNames).toContain('search_feedback');
-      // Grading ops (5)
-      expect(opNames).toContain('plan_grade');
-      expect(opNames).toContain('plan_check_history');
-      expect(opNames).toContain('plan_latest_check');
-      expect(opNames).toContain('plan_meets_grade');
-      expect(opNames).toContain('plan_auto_improve');
-      // Admin Extra ops (11)
-      expect(opNames).toContain('admin_telemetry');
-      expect(opNames).toContain('admin_telemetry_recent');
-      expect(opNames).toContain('admin_telemetry_reset');
-      expect(opNames).toContain('admin_permissions');
-      expect(opNames).toContain('admin_vault_analytics');
-      expect(opNames).toContain('admin_search_insights');
-      expect(opNames).toContain('admin_module_status');
-      expect(opNames).toContain('admin_env');
-      expect(opNames).toContain('admin_gc');
-      expect(opNames).toContain('admin_export_config');
-      expect(opNames).toContain('admin_hot_reload');
-      // Curator Extra ops (4 + 1 hybrid)
-      expect(opNames).toContain('curator_entry_history');
-      expect(opNames).toContain('curator_record_snapshot');
-      expect(opNames).toContain('curator_queue_stats');
-      expect(opNames).toContain('curator_enrich');
-      // #36: Hybrid contradiction detection
-      expect(opNames).toContain('curator_hybrid_contradictions');
-      // Project ops (12)
-      expect(opNames).toContain('project_get');
-      expect(opNames).toContain('project_list');
-      expect(opNames).toContain('project_unregister');
-      expect(opNames).toContain('project_get_rules');
-      expect(opNames).toContain('project_list_rules');
-      expect(opNames).toContain('project_add_rule');
-      expect(opNames).toContain('project_remove_rule');
-      expect(opNames).toContain('project_link');
-      expect(opNames).toContain('project_unlink');
-      expect(opNames).toContain('project_get_links');
-      expect(opNames).toContain('project_linked_projects');
-      expect(opNames).toContain('project_touch');
-      // Cross-project memory ops (3)
-      expect(opNames).toContain('memory_promote_to_global');
-      expect(opNames).toContain('memory_configure');
-      expect(opNames).toContain('memory_cross_project_search');
-      // Playbook ops (5)
-      expect(opNames).toContain('playbook_list');
-      expect(opNames).toContain('playbook_get');
-      expect(opNames).toContain('playbook_create');
-      expect(opNames).toContain('playbook_match');
-      expect(opNames).toContain('playbook_seed');
-      // Cognee Sync ops (3)
-      expect(opNames).toContain('cognee_sync_status');
-      expect(opNames).toContain('cognee_sync_drain');
-      expect(opNames).toContain('cognee_sync_reconcile');
-      // Intake ops (4)
-      expect(opNames).toContain('intake_ingest_book');
-      expect(opNames).toContain('intake_process');
-      expect(opNames).toContain('intake_status');
-      expect(opNames).toContain('intake_preview');
-      // Total: 208 (203 core + 5 agent-specific)
-      expect(facade.ops.length).toBe(208);
-    });
-
-    it('search should query across all domains with ranked results', async () => {
-      runtime.vault.seed([
-        makeEntry({ id: 'c1', domain: 'alpha', title: 'Alpha pattern', tags: ['a'] }),
-        makeEntry({ id: 'c2', domain: 'beta', title: 'Beta pattern', tags: ['b'] }),
-      ]);
-      runtime = createAgentRuntime({ agentId: '${config.id}', vaultPath: ':memory:', plansPath: join(plannerDir, 'plans2.json') });
-      runtime.vault.seed([
-        makeEntry({ id: 'c1', domain: 'alpha', title: 'Alpha pattern', tags: ['a'] }),
-        makeEntry({ id: 'c2', domain: 'beta', title: 'Beta pattern', tags: ['b'] }),
-      ]);
-      const facade = buildCoreFacade();
-      const searchOp = facade.ops.find((o) => o.name === 'search')!;
-      const results = (await searchOp.handler({ query: 'pattern' })) as Array<{ entry: unknown; score: number; breakdown: unknown }>;
-      expect(Array.isArray(results)).toBe(true);
-      expect(results.length).toBe(2);
-      expect(results[0].score).toBeGreaterThan(0);
-    });
-
-    it('vault_stats should return counts', async () => {
-      runtime.vault.seed([
-        makeEntry({ id: 'vs1', domain: 'd1', tags: ['x'] }),
-        makeEntry({ id: 'vs2', domain: 'd2', tags: ['y'] }),
-      ]);
-      const facade = buildCoreFacade();
-      const statsOp = facade.ops.find((o) => o.name === 'vault_stats')!;
-      const stats = (await statsOp.handler({})) as { totalEntries: number };
-      expect(stats.totalEntries).toBe(2);
+    it('agent ops should not appear in semantic facades', () => {
+      const facades = createSemanticFacades(runtime, '${config.id}');
+      const allOps = facades.flatMap(f => f.ops.map(o => o.name));
+      expect(allOps).not.toContain('health');
+      expect(allOps).not.toContain('identity');
+      expect(allOps).not.toContain('activate');
+      expect(allOps).not.toContain('inject_claude_md');
+      expect(allOps).not.toContain('setup');
     });
 
     it('health should return ok status', async () => {
-      const facade = buildCoreFacade();
+      const facade = buildAgentFacade();
       const healthOp = facade.ops.find((o) => o.name === 'health')!;
       const health = (await healthOp.handler({})) as { status: string };
       expect(health.status).toBe('ok');
     });
 
     it('identity should return persona', async () => {
-      const facade = buildCoreFacade();
+      const facade = buildAgentFacade();
       const identityOp = facade.ops.find((o) => o.name === 'identity')!;
       const persona = (await identityOp.handler({})) as { name: string; role: string };
       expect(persona.name).toBe('${escapeQuotes(config.name)}');
@@ -404,7 +403,7 @@ ${domainDescribes}
     });
 
     it('activate should return persona and setup status', async () => {
-      const facade = buildCoreFacade();
+      const facade = buildAgentFacade();
       const activateOp = facade.ops.find((o) => o.name === 'activate')!;
       const result = (await activateOp.handler({ projectPath: '/tmp/nonexistent-test' })) as {
         activated: boolean;
@@ -415,7 +414,7 @@ ${domainDescribes}
     });
 
     it('activate with deactivate flag should return deactivation', async () => {
-      const facade = buildCoreFacade();
+      const facade = buildAgentFacade();
       const activateOp = facade.ops.find((o) => o.name === 'activate')!;
       const result = (await activateOp.handler({ deactivate: true })) as { deactivated: boolean; message: string };
       expect(result.deactivated).toBe(true);
@@ -426,7 +425,7 @@ ${domainDescribes}
       const tempDir = join(tmpdir(), 'forge-inject-test-' + Date.now());
       mkdirSync(tempDir, { recursive: true });
       try {
-        const facade = buildCoreFacade();
+        const facade = buildAgentFacade();
         const injectOp = facade.ops.find((o) => o.name === 'inject_claude_md')!;
         const result = (await injectOp.handler({ projectPath: tempDir })) as {
           injected: boolean;
@@ -444,7 +443,7 @@ ${domainDescribes}
     });
 
     it('setup should return project and global CLAUDE.md status', async () => {
-      const facade = buildCoreFacade();
+      const facade = buildAgentFacade();
       const setupOp = facade.ops.find((o) => o.name === 'setup')!;
       const result = (await setupOp.handler({ projectPath: '/tmp/nonexistent-test' })) as {
         agent: { name: string };
@@ -457,75 +456,6 @@ ${domainDescribes}
       expect(result.vault.entries).toBe(0);
       expect(result.recommendations.length).toBeGreaterThan(0);
     });
-
-    it('create_plan should create a draft plan', async () => {
-      const facade = buildCoreFacade();
-      const createOp = facade.ops.find((o) => o.name === 'create_plan')!;
-      const result = (await createOp.handler({
-        objective: 'Add caching',
-        scope: 'api layer',
-        tasks: [{ title: 'Add Redis', description: 'Set up Redis client' }],
-      })) as { created: boolean; plan: { id: string; status: string; tasks: unknown[] } };
-      expect(result.created).toBe(true);
-      expect(result.plan.status).toBe('draft');
-      expect(result.plan.tasks).toHaveLength(1);
-    });
-
-    it('brain_stats should return intelligence stats', async () => {
-      const facade = buildCoreFacade();
-      const statsOp = facade.ops.find((o) => o.name === 'brain_stats')!;
-      const result = (await statsOp.handler({})) as {
-        vocabularySize: number;
-        feedbackCount: number;
-      };
-      expect(result.vocabularySize).toBe(0);
-      expect(result.feedbackCount).toBe(0);
-    });
-
-    it('curator_status should return table counts', async () => {
-      const facade = buildCoreFacade();
-      const statusOp = facade.ops.find((o) => o.name === 'curator_status')!;
-      const result = (await statusOp.handler({})) as { initialized: boolean };
-      expect(result.initialized).toBe(true);
-    });
-
-    it('curator_health_audit should return score', async () => {
-      runtime.vault.seed([
-        makeEntry({ id: 'ha1', type: 'pattern', tags: ['a', 'b'] }),
-        makeEntry({ id: 'ha2', type: 'anti-pattern', tags: ['c', 'd'] }),
-      ]);
-      runtime.curator.groomAll();
-      const facade = buildCoreFacade();
-      const healthOp = facade.ops.find((o) => o.name === 'curator_health_audit')!;
-      const result = (await healthOp.handler({})) as { score: number };
-      expect(result.score).toBeGreaterThan(0);
-    });
-
-    it('governance_policy get should return default policy', async () => {
-      const facade = buildCoreFacade();
-      const policyOp = facade.ops.find((o) => o.name === 'governance_policy')!;
-      const result = (await policyOp.handler({ action: 'get', projectPath: '/test' })) as {
-        projectPath: string;
-        quotas: { maxEntriesTotal: number };
-        autoCapture: { enabled: boolean };
-      };
-      expect(result.projectPath).toBe('/test');
-      expect(result.quotas.maxEntriesTotal).toBe(500);
-      expect(result.autoCapture.enabled).toBe(true);
-    });
-
-    it('governance_dashboard should return combined view', async () => {
-      const facade = buildCoreFacade();
-      const dashOp = facade.ops.find((o) => o.name === 'governance_dashboard')!;
-      const result = (await dashOp.handler({ projectPath: '/test' })) as {
-        vaultSize: number;
-        quotaPercent: number;
-        pendingProposals: number;
-      };
-      expect(typeof result.vaultSize).toBe('number');
-      expect(typeof result.quotaPercent).toBe('number');
-      expect(result.pendingProposals).toBe(0);
-    });
   });
 });
 `;

package/dist/templates/test-facades.js.map

@@ -1 +1 @@
-{"version":3,"file":"test-facades.js","sourceRoot":"","sources":["../../src/templates/test-facades.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAmB;IACrD,MAAM,eAAe,GAAG,MAAM,CAAC,OAAO;SACnC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,sBAAsB,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;SAChD,IAAI,CAAC,MAAM,CAAC,CAAC;IAEhB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAmCS,MAAM,CAAC,EAAE;;;;;;;;;;;EAWzB,eAAe;;cAEH,MAAM,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCA6Fe,MAAM,CAAC,IAAI;;;;;;;;;;;;;;;;iBAgBhC,MAAM,CAAC,EAAE;;;;;;;;kCAQQ,MAAM,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iDAiMM,MAAM,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAmCvB,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC;mCACzB,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC;;;;;;;;;;;0CAWlB,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;qCA0B9B,MAAM,CAAC,EAAE;;;;;;;;;;;;;;;;wCAgBN,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2EhE,CAAC;AACF,CAAC;AAED,SAAS,sBAAsB,CAAC,OAAe,EAAE,MAAc;IAC7D,MAAM,UAAU,GAAG,GAAG,OAAO,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC;IAE7D,OAAO,eAAe,UAAU;;4CAEU,OAAO,OAAO,MAAM;;;;;kCAK9B,UAAU;;;;;;;;;iDASK,MAAM;;2BAE5B,MAAM,mBAAmB,MAAM;;;;;;kDAMR,MAAM;;;iCAGvB,MAAM;;2BAEZ,MAAM,kBAAkB,MAAM;;;;;;;wDAOD,MAAM;;;wCAGtB,MAAM;;;;eAI/B,MAAM;;;;;;;;yCAQoB,MAAM;;oCAEX,MAAM;;;;6CAIG,MAAM,mBAAmB,MAAM;;;gDAG5B,MAAM;gCACtB,MAAM;;;;6CAIO,MAAM,mBAAmB,MAAM;;;gDAG5B,MAAM;;kCAEpB,MAAM;;MAElC,CAAC;AACP,CAAC;AAED,SAAS,YAAY,CAAC,CAAS;IAC7B,OAAO,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;AACvD,CAAC"}
+{"version":3,"file":"test-facades.js","sourceRoot":"","sources":["../../src/templates/test-facades.ts"],"names":[],"mappings":"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"}

package/dist/types.d.ts

@@ -1,4 +1,7 @@
 import { z } from 'zod';
+/** Communication tone for the agent persona */
+export declare const TONES: readonly ["precise", "mentor", "pragmatic"];
+export type Tone = (typeof TONES)[number];
 /** Agent configuration — everything needed to scaffold */
 export declare const AgentConfigSchema: z.ZodObject<{
     /** Agent identifier (kebab-case, used for directory and package name) */
@@ -13,32 +16,40 @@ export declare const AgentConfigSchema: z.ZodObject<{
     domains: z.ZodArray<z.ZodString, "many">;
     /** Core principles the agent follows (3-7 recommended) */
     principles: z.ZodArray<z.ZodString, "many">;
+    /** Communication tone: precise, mentor, or pragmatic */
+    tone: z.ZodDefault<z.ZodOptional<z.ZodEnum<["precise", "mentor", "pragmatic"]>>>;
     /** Greeting message when agent introduces itself (auto-generated if omitted) */
     greeting: z.ZodOptional<z.ZodString>;
     /** Output directory (parent — agent dir will be created inside, defaults to cwd) */
     outputDir: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     /** Hook packs to install after scaffolding (optional) */
     hookPacks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Skills to include (if omitted, all skills are included for backward compat) */
+    skills: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
-    id: string;
     name: string;
+    id: string;
     role: string;
     description: string;
     domains: string[];
     principles: string[];
+    tone: "precise" | "mentor" | "pragmatic";
     outputDir: string;
     greeting?: string | undefined;
     hookPacks?: string[] | undefined;
+    skills?: string[] | undefined;
 }, {
-    id: string;
     name: string;
+    id: string;
     role: string;
     description: string;
     domains: string[];
     principles: string[];
+    tone?: "precise" | "mentor" | "pragmatic" | undefined;
     greeting?: string | undefined;
     outputDir?: string | undefined;
     hookPacks?: string[] | undefined;
+    skills?: string[] | undefined;
 }>;
 export type AgentConfig = z.infer<typeof AgentConfigSchema>;
 /** Result of scaffolding */