@soleri/forge 4.2.2 → 5.0.0

package/src/domain-manager.ts

@@ -1,5 +1,9 @@
 /**
  * Domain manager — add new knowledge domains to existing agents.
+ *
+ * v5.0: Domain facades come from @soleri/core at runtime (createDomainFacades).
+ * Adding a domain just needs: empty data bundle + patch index.ts domains array.
+ * Falls back to generating facade files for v4.x agents.
  */
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
@@ -15,14 +19,24 @@ interface AddDomainParams {
   noBuild?: boolean;
 }
 
+/**
+ * Detect if this is a v5.0+ agent (uses createAgentRuntime from @soleri/core).
+ */
+function isV5Agent(agentPath: string): boolean {
+  const indexPath = join(agentPath, 'src', 'index.ts');
+  if (!existsSync(indexPath)) return false;
+  const content = readFileSync(indexPath, 'utf-8');
+  return content.includes('createAgentRuntime') || content.includes('createDomainFacades');
+}
+
 /**
  * Add a new knowledge domain to an existing agent.
  *
  * Steps:
  * 1. Validate agent path and domain name
  * 2. Create empty intelligence bundle
- * 3. Generate domain facade
- * 4. Patch src/index.ts with import + registration
+ * 3. Generate domain facade (v4.x only — v5.0+ uses core factory)
+ * 4. Patch src/index.ts with domain registration
  * 5. Patch src/activation/claude-md-content.ts with facade table rows
  * 6. Rebuild (unless noBuild)
  */
@@ -68,7 +82,8 @@ export async function addDomain(params: AddDomainParams): Promise<AddDomainResul
     return fail(agentPath, domain, `Domain "${domain}" already exists`);
   }
 
-  const hasBrain = existsSync(join(agentPath, 'src', 'brain'));
+  const v5 = isV5Agent(agentPath);
+  const hasBrain = v5 || existsSync(join(agentPath, 'src', 'brain'));
 
   // ── Step 1: Create empty bundle ──
 
@@ -82,18 +97,22 @@ export async function addDomain(params: AddDomainParams): Promise<AddDomainResul
     writeFileSync(join(distDataDir, `${domain}.json`), emptyBundle, 'utf-8');
   }
 
-  // ── Step 2: Generate facade ──
+  // ── Step 2: Generate facade (v4.x only) ──
 
-  const facadesDir = join(agentPath, 'src', 'facades');
-  const facadePath = join(facadesDir, `${domain}.facade.ts`);
+  let facadeGenerated = false;
+  if (!v5) {
+    const facadesDir = join(agentPath, 'src', 'facades');
+    const facadePath = join(facadesDir, `${domain}.facade.ts`);
 
-  if (existsSync(facadePath)) {
-    warnings.push(`Facade ${domain}.facade.ts already exists — skipped`);
-  } else {
-    const facadeCode = hasBrain
-      ? generateDomainFacade(agentId, domain)
-      : generateVaultOnlyDomainFacade(agentId, domain);
-    writeFileSync(facadePath, facadeCode, 'utf-8');
+    if (existsSync(facadePath)) {
+      warnings.push(`Facade ${domain}.facade.ts already exists — skipped`);
+    } else {
+      const facadeCode = hasBrain
+        ? generateDomainFacade(agentId, domain)
+        : generateVaultOnlyDomainFacade(agentId, domain);
+      writeFileSync(facadePath, facadeCode, 'utf-8');
+      facadeGenerated = true;
+    }
   }
 
   // ── Step 3: Patch src/index.ts ──
@@ -147,10 +166,10 @@ export async function addDomain(params: AddDomainParams): Promise<AddDomainResul
     agentPath,
     domain,
     agentId,
-    facadeGenerated: !existsSync(facadePath) || !warnings.some((w) => w.includes('already exists')),
+    facadeGenerated,
     buildOutput,
     warnings,
-    summary: `Added domain "${domain}" to ${agentId}${warnings.length > 0 ? ` (${warnings.length} warning(s))` : ''}`,
+    summary: `Added domain "${domain}" to ${agentId}${v5 ? ' (v5.0 — no facade file needed)' : ''}${warnings.length > 0 ? ` (${warnings.length} warning(s))` : ''}`,
   };
 }
 

package/src/knowledge-installer.ts

@@ -185,6 +185,10 @@ export async function installKnowledge(
 
   const hasBrain = existsSync(join(agentPath, 'src', 'brain'));
 
+  // v5.0+ agents use createDomainFacades() from @soleri/core — no facade files needed
+  const indexPath5 = join(agentPath, 'src', 'index.ts');
+  const isV5 = existsSync(indexPath5) && readFileSync(indexPath5, 'utf-8').includes('createDomainFacades');
+
   // ── Step 2: Read and validate bundles ────────────────────────────
 
   const bundleFiles = collectBundleFiles(bundlePath);
@@ -253,22 +257,25 @@ export async function installKnowledge(
   // ── Step 4: Generate facades for new domains ─────────────────────
 
   if (generateFacades && domainsAdded.length > 0) {
-    const facadesDir = join(agentPath, 'src', 'facades');
-
-    for (const domain of domainsAdded) {
-      const facadePath = join(facadesDir, `${domain}.facade.ts`);
-      // Skip if facade already exists (idempotent)
-      if (existsSync(facadePath)) {
-        warnings.push(`Facade ${domain}.facade.ts already exists — skipped`);
-        continue;
+    // v5.0+ agents: no facade files needed (createDomainFacades from @soleri/core)
+    // v4.x agents: generate facade files
+    if (!isV5) {
+      const facadesDir = join(agentPath, 'src', 'facades');
+
+      for (const domain of domainsAdded) {
+        const facadePath = join(facadesDir, `${domain}.facade.ts`);
+        if (existsSync(facadePath)) {
+          warnings.push(`Facade ${domain}.facade.ts already exists — skipped`);
+          continue;
+        }
+
+        const facadeCode = hasBrain
+          ? generateDomainFacade(agentId, domain)
+          : generateVaultOnlyDomainFacade(agentId, domain);
+
+        writeFileSync(facadePath, facadeCode, 'utf-8');
+        facadesGenerated.push(`${domain}.facade.ts`);
       }
-
-      const facadeCode = hasBrain
-        ? generateDomainFacade(agentId, domain)
-        : generateVaultOnlyDomainFacade(agentId, domain);
-
-      writeFileSync(facadePath, facadeCode, 'utf-8');
-      facadesGenerated.push(`${domain}.facade.ts`);
     }
 
     // ── Step 5: Patch src/index.ts ───────────────────────────────────

package/src/patching.ts

@@ -3,42 +3,74 @@
  *
  * These functions modify an agent's src/index.ts and src/activation/claude-md-content.ts
  * to register new domain facades and their CLAUDE.md table rows.
+ *
+ * v5.0: Entry point uses createDomainFacades() from @soleri/core.
+ * New domain patching inserts domain names into the domains array literal.
  */
-import { pascalCase } from './templates/domain-facade.js';
 
 /**
- * Patch the agent's src/index.ts to add imports and facade registrations
- * for new domains.
+ * Patch the agent's src/index.ts to add new domains.
+ *
+ * v5.0 format: The entry point has a `createDomainFacades(runtime, 'agentId', [...domains])` call.
+ * We insert new domain strings into that array.
  *
- * Anchor patterns:
- * - Import: insert before `import { createCoreFacade }`
- * - Facade array: insert before `createCoreFacade(`
+ * Falls back to v4.x format (import + facade creation) for older agents.
  */
 export function patchIndexTs(
+  source: string,
+  newDomains: string[],
+  _hasBrain?: boolean,
+): string | null {
+  // ── v5.0 format: createDomainFacades() with domains array literal ──
+  const v5Pattern = /createDomainFacades\(runtime,\s*'[^']+',\s*\[([\s\S]*?)\]\)/;
+  const v5Match = source.match(v5Pattern);
+
+  if (v5Match) {
+    const existingArrayContent = v5Match[1];
+    const domainsToAdd = newDomains.filter(
+      (d) => !existingArrayContent.includes(`'${d}'`) && !existingArrayContent.includes(`"${d}"`),
+    );
+    if (domainsToAdd.length === 0) return source;
+
+    const newEntries = domainsToAdd.map((d) => `'${d}'`).join(', ');
+    const currentContent = existingArrayContent.trim();
+    const updatedContent = currentContent
+      ? `${currentContent}, ${newEntries}`
+      : newEntries;
+
+    return source.replace(v5Pattern, (match) => {
+      return match.replace(v5Match[1], updatedContent);
+    });
+  }
+
+  // ── v4.x fallback: import + facade creation anchors ──
+  return patchIndexTsV4(source, newDomains, _hasBrain ?? true);
+}
+
+/**
+ * Legacy v4.x patching — import-based domain facade registration.
+ */
+function patchIndexTsV4(
   source: string,
   newDomains: string[],
   hasBrain: boolean,
 ): string | null {
-  // Filter out domains whose imports already exist (idempotent)
   const domainsToImport = newDomains.filter((d) => {
     const fn = `create${pascalCase(d)}Facade`;
     return !source.includes(`import { ${fn} }`);
   });
 
-  // Filter out domains whose facade calls already exist
   const domainsToRegister = newDomains.filter((d) => {
     const fn = `create${pascalCase(d)}Facade(`;
     return !source.includes(fn);
   });
 
-  // Nothing to patch
   if (domainsToImport.length === 0 && domainsToRegister.length === 0) {
     return source;
   }
 
   let patched = source;
 
-  // ── Insert imports ──
   if (domainsToImport.length > 0) {
     const importAnchor = /^(import \{ createCoreFacade \}.*$)/m;
     if (!importAnchor.test(patched)) return null;
@@ -53,7 +85,6 @@ export function patchIndexTs(
     patched = patched.replace(importAnchor, `${newImports}\n$1`);
   }
 
-  // ── Insert facade creations ──
   if (domainsToRegister.length > 0) {
     const facadeAnchor = /^(\s+createCoreFacade\()/m;
     if (!facadeAnchor.test(patched)) return null;
@@ -121,3 +152,10 @@ export function patchClaudeMdContent(
 
   return source.slice(0, anchorIdx) + newRows.join('\n') + '\n' + source.slice(anchorIdx);
 }
+
+function pascalCase(s: string): string {
+  return s
+    .split(/[-_\s]+/)
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+    .join('');
+}

package/src/scaffolder.ts

@@ -14,8 +14,6 @@ import { generatePackageJson } from './templates/package-json.js';
 import { generateTsconfig } from './templates/tsconfig.js';
 import { generateVitestConfig } from './templates/vitest-config.js';
 import { generatePersona } from './templates/persona.js';
-import { generateDomainFacade } from './templates/domain-facade.js';
-import { generateCoreFacade } from './templates/core-facade.js';
 import { generateEntryPoint } from './templates/entry-point.js';
 import { generateFacadesTest } from './templates/test-facades.js';
 import { generateClaudeMdTemplate } from './templates/claude-md-template.js';
@@ -23,7 +21,6 @@ import { generateInjectClaudeMd } from './templates/inject-claude-md.js';
 import { generateActivate } from './templates/activate.js';
 import { generateReadme } from './templates/readme.js';
 import { generateSetupScript } from './templates/setup-script.js';
-import { generateLLMClient } from './templates/llm-client.js';
 
 /**
  * Preview what scaffold will create without writing anything.
@@ -43,21 +40,8 @@ export function previewScaffold(config: AgentConfig): ScaffoldPreview {
     {
       path: 'src/index.ts',
       description:
-        'Entry point — initializes vault, planner, brain, registers facades, starts stdio',
-    },
-    {
-      path: 'src/llm/llm-client.ts',
-      description:
-        'LLM client — unified OpenAI/Anthropic caller with model routing (optional, needs API keys)',
-    },
-    {
-      path: 'src/facades/core.facade.ts',
-      description: 'Core facade — search, vault stats, health, identity',
+        'Entry point — thin shell using createAgentRuntime() + createCoreOps() from @soleri/core',
     },
-    ...config.domains.map((d) => ({
-      path: `src/facades/${d}.facade.ts`,
-      description: `${d} facade — search, get_patterns, capture, remove`,
-    })),
     ...config.domains.map((d) => ({
       path: `src/intelligence/data/${d}.json`,
       description: `Empty ${d} intelligence bundle — ready for knowledge capture`,
@@ -101,14 +85,10 @@ export function previewScaffold(config: AgentConfig): ScaffoldPreview {
     {
       name: `${config.id}_core`,
       ops: [
+        // From createCoreOps() — 26 generic ops
         'search',
         'vault_stats',
         'list_all',
-        'health',
-        'identity',
-        'activate',
-        'inject_claude_md',
-        'setup',
         'register',
         'memory_search',
         'memory_capture',
@@ -124,6 +104,20 @@ export function previewScaffold(config: AgentConfig): ScaffoldPreview {
         'rebuild_vocabulary',
         'brain_stats',
         'llm_status',
+        'curator_status',
+        'curator_detect_duplicates',
+        'curator_contradictions',
+        'curator_resolve_contradiction',
+        'curator_groom',
+        'curator_groom_all',
+        'curator_consolidate',
+        'curator_health_audit',
+        // Agent-specific ops — 5
+        'health',
+        'identity',
+        'activate',
+        'inject_claude_md',
+        'setup',
       ],
     },
   ];
@@ -159,12 +153,10 @@ export function scaffold(config: AgentConfig): ScaffoldResult {
     '',
     'scripts',
     'src',
-    'src/facades',
     'src/intelligence',
     'src/intelligence/data',
     'src/identity',
     'src/activation',
-    'src/llm',
     'src/__tests__',
   ];
 
@@ -201,19 +193,16 @@ export function scaffold(config: AgentConfig): ScaffoldResult {
 
   // Write source files
   const sourceFiles: Array<[string, string]> = [
-    ['src/facades/core.facade.ts', generateCoreFacade(config)],
     ['src/identity/persona.ts', generatePersona(config)],
     ['src/activation/claude-md-content.ts', generateClaudeMdTemplate(config)],
     ['src/activation/inject-claude-md.ts', generateInjectClaudeMd(config)],
     ['src/activation/activate.ts', generateActivate(config)],
     ['src/index.ts', generateEntryPoint(config)],
-    ['src/llm/llm-client.ts', generateLLMClient(config)],
     ['src/__tests__/facades.test.ts', generateFacadesTest(config)],
   ];
 
-  // Domain facades and empty data files
+  // Empty intelligence data bundles (domain facades come from @soleri/core at runtime)
   for (const domain of config.domains) {
-    sourceFiles.push([`src/facades/${domain}.facade.ts`, generateDomainFacade(config.id, domain)]);
     sourceFiles.push([`src/intelligence/data/${domain}.json`, generateEmptyBundle(domain)]);
   }
 
@@ -222,7 +211,7 @@ export function scaffold(config: AgentConfig): ScaffoldResult {
     filesCreated.push(path);
   }
 
-  const totalOps = config.domains.length * 5 + 24; // 5 per domain + 24 core (activation, registration, memory, session, export, planning, brain, llm)
+  const totalOps = config.domains.length * 5 + 31; // 5 per domain + 26 core (from createCoreOps) + 5 agent-specific
 
   // Register the agent as an MCP server in ~/.claude.json
   const mcpReg = registerMcpServer(config.id, agentDir);

package/src/templates/entry-point.ts

@@ -2,19 +2,13 @@ import type { AgentConfig } from '../types.js';
 
 /**
  * Generate the main index.ts entry point for the agent.
+ *
+ * v5.0: Thin shell — delegates to createAgentRuntime(), createCoreOps(),
+ * and createDomainFacades() from @soleri/core. Only agent-specific code
+ * (persona, activation) lives here.
  */
 export function generateEntryPoint(config: AgentConfig): string {
-  const facadeImports = config.domains
-    .map((d) => {
-      const fn = `create${pascalCase(d)}Facade`;
-      const file = `${d}.facade.js`;
-      return `import { ${fn} } from './facades/${file}';`;
-    })
-    .join('\n');
-
-  const facadeCreations = config.domains
-    .map((d) => `    create${pascalCase(d)}Facade(vault, brain),`)
-    .join('\n');
+  const domainsLiteral = JSON.stringify(config.domains);
 
   return `#!/usr/bin/env node
 
@@ -22,102 +16,170 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { homedir } from 'node:os';
 
-import { Vault, Brain, Planner, KeyPool, CogneeClient, loadKeyPoolConfig, loadIntelligenceData, registerAllFacades } from '@soleri/core';
-${facadeImports}
-import { createCoreFacade } from './facades/core.facade.js';
-import { LLMClient } from './llm/llm-client.js';
+import {
+  createAgentRuntime,
+  createCoreOps,
+  createDomainFacades,
+  registerAllFacades,
+} from '@soleri/core';
+import type { OpDefinition } from '@soleri/core';
+import { z } from 'zod';
 import { PERSONA, getPersonaPrompt } from './identity/persona.js';
+import { activateAgent, deactivateAgent } from './activation/activate.js';
+import { injectClaudeMd, injectClaudeMdGlobal, hasAgentMarker } from './activation/inject-claude-md.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
 async function main(): Promise<void> {
-  // Initialize persistent vault at ~/.${config.id}/vault.db
-  const vaultPath = join(homedir(), '.${config.id}', 'vault.db');
-  const vault = new Vault(vaultPath);
-  console.error(\`[\${PERSONA.name.toLowerCase()}] Vault: \${vaultPath}\`);
-
-  // Load and seed intelligence data
-  const dataDir = join(__dirname, 'intelligence', 'data');
-  const entries = loadIntelligenceData(dataDir);
-  if (entries.length > 0) {
-    const seeded = vault.seed(entries);
-    console.error(\`[\${PERSONA.name.toLowerCase()}] Seeded vault with \${seeded} intelligence entries\`);
-  } else {
-    console.error(\`[\${PERSONA.name.toLowerCase()}] Vault is empty — ready for knowledge capture\`);
-  }
-
-  // Initialize planner at ~/.${config.id}/plans.json
-  const plansPath = join(homedir(), '.${config.id}', 'plans.json');
-  const planner = new Planner(plansPath);
-  console.error(\`[\${PERSONA.name.toLowerCase()}] Planner: \${plansPath}\`);
-
-  // Initialize Cognee client (optional — vector search + knowledge graph)
-  // Auto-registers a service account on first use. Override with env vars.
-  const cognee = new CogneeClient({
-    baseUrl: process.env.COGNEE_URL ?? 'http://localhost:8000',
-    dataset: '${config.id}-vault',
-    ...(process.env.COGNEE_API_TOKEN ? { apiToken: process.env.COGNEE_API_TOKEN } : {}),
-    ...(process.env.COGNEE_EMAIL ? { serviceEmail: process.env.COGNEE_EMAIL } : {}),
-    ...(process.env.COGNEE_PASSWORD ? { servicePassword: process.env.COGNEE_PASSWORD } : {}),
+  // ─── Runtime — vault, brain, planner, curator, LLM, key pools ───
+  const runtime = createAgentRuntime({
+    agentId: '${config.id}',
+    dataDir: join(__dirname, 'intelligence', 'data'),
   });
-  await cognee.healthCheck();
-  console.error(\`[\${PERSONA.name.toLowerCase()}] Cognee: \${cognee.isAvailable ? 'available' : 'not running (FTS5 fallback)'}\`);
-
-  // Initialize brain — intelligence layer for ranked search, auto-tagging, dedup
-  const brain = new Brain(vault, cognee.isAvailable ? cognee : undefined);
-  console.error(\`[\${PERSONA.name.toLowerCase()}] Brain: vocabulary \${brain.getVocabularySize()} terms\`);
-
-  // Background sync vault to Cognee if available
-  if (cognee.isAvailable) {
-    brain.syncToCognee().catch((err) => {
-      console.error(\`[\${PERSONA.name.toLowerCase()}] Cognee sync failed:\`, err);
-    });
-  }
-
-  // Initialize LLM client (optional — works without API keys)
-  const keyPoolFiles = loadKeyPoolConfig('${config.id}');
-  const openaiKeyPool = new KeyPool(keyPoolFiles.openai);
-  const anthropicKeyPool = new KeyPool(keyPoolFiles.anthropic);
-  const llmClient = new LLMClient(openaiKeyPool, anthropicKeyPool);
-  const llmAvail = llmClient.isAvailable();
-  console.error(\`[\${PERSONA.name.toLowerCase()}] LLM: OpenAI \${llmAvail.openai ? 'available' : 'not configured'}, Anthropic \${llmAvail.anthropic ? 'available' : 'not configured'}\`);
-
-  // Create MCP server
+
+  const tag = PERSONA.name.toLowerCase();
+  const stats = runtime.vault.stats();
+  console.error(\`[\${tag}] Vault: \${stats.totalEntries} entries, Brain: \${runtime.brain.getVocabularySize()} terms\`);
+
+  const llmAvail = runtime.llmClient.isAvailable();
+  console.error(\`[\${tag}] LLM: OpenAI \${llmAvail.openai ? 'available' : 'not configured'}, Anthropic \${llmAvail.anthropic ? 'available' : 'not configured'}\`);
+
+  // ─── Agent-specific ops (reference persona + activation) ────────
+  const agentOps: OpDefinition[] = [
+    {
+      name: 'health',
+      description: 'Health check — vault status and agent info.',
+      auth: 'read',
+      handler: async () => {
+        const s = runtime.vault.stats();
+        return {
+          status: 'ok',
+          agent: { name: PERSONA.name, role: PERSONA.role },
+          vault: { entries: s.totalEntries, domains: Object.keys(s.byDomain) },
+        };
+      },
+    },
+    {
+      name: 'identity',
+      description: 'Get agent identity — name, role, principles.',
+      auth: 'read',
+      handler: async () => PERSONA,
+    },
+    {
+      name: 'activate',
+      description: 'Activate agent persona — returns full context for Claude to adopt. Say "Hello, ${config.name}!" to trigger.',
+      auth: 'read',
+      schema: z.object({
+        projectPath: z.string().optional().default('.'),
+        deactivate: z.boolean().optional(),
+      }),
+      handler: async (params) => {
+        if (params.deactivate) {
+          return deactivateAgent();
+        }
+        return activateAgent(runtime.vault, (params.projectPath as string) ?? '.', runtime.planner);
+      },
+    },
+    {
+      name: 'inject_claude_md',
+      description: 'Inject agent sections into CLAUDE.md — project-level or global (~/.claude/CLAUDE.md). Idempotent.',
+      auth: 'write',
+      schema: z.object({
+        projectPath: z.string().optional().default('.'),
+        global: z.boolean().optional().describe('If true, inject into ~/.claude/CLAUDE.md instead of project-level'),
+      }),
+      handler: async (params) => {
+        if (params.global) {
+          return injectClaudeMdGlobal();
+        }
+        return injectClaudeMd((params.projectPath as string) ?? '.');
+      },
+    },
+    {
+      name: 'setup',
+      description: 'Check setup status — CLAUDE.md configured? Vault has entries? What to do next?',
+      auth: 'read',
+      schema: z.object({
+        projectPath: z.string().optional().default('.'),
+      }),
+      handler: async (params) => {
+        const { existsSync } = await import('node:fs');
+        const { join: joinPath } = await import('node:path');
+        const { homedir } = await import('node:os');
+        const projectPath = (params.projectPath as string) ?? '.';
+
+        const projectClaudeMd = joinPath(projectPath, 'CLAUDE.md');
+        const globalClaudeMd = joinPath(homedir(), '.claude', 'CLAUDE.md');
+
+        const projectExists = existsSync(projectClaudeMd);
+        const projectHasAgent = hasAgentMarker(projectClaudeMd);
+        const globalExists = existsSync(globalClaudeMd);
+        const globalHasAgent = hasAgentMarker(globalClaudeMd);
+
+        const s = runtime.vault.stats();
+
+        const recommendations: string[] = [];
+        if (!globalHasAgent && !projectHasAgent) {
+          recommendations.push('No CLAUDE.md configured — run inject_claude_md with global: true for all projects, or without for this project');
+        } else if (!globalHasAgent) {
+          recommendations.push('Global ~/.claude/CLAUDE.md not configured — run inject_claude_md with global: true to enable in all projects');
+        }
+        if (s.totalEntries === 0) {
+          recommendations.push('Vault is empty — add intelligence data or capture knowledge via domain facades');
+        }
+        if (recommendations.length === 0) {
+          recommendations.push('${config.name} is fully set up and ready!');
+        }
+
+        return {
+          agent: { name: PERSONA.name, role: PERSONA.role },
+          claude_md: {
+            project: { exists: projectExists, has_agent_section: projectHasAgent },
+            global: { exists: globalExists, has_agent_section: globalHasAgent },
+          },
+          vault: { entries: s.totalEntries, domains: Object.keys(s.byDomain) },
+          recommendations,
+        };
+      },
+    },
+  ];
+
+  // ─── Assemble facades ──────────────────────────────────────────
+  const coreOps = createCoreOps(runtime);
+  const coreFacade = {
+    name: '${config.id}_core',
+    description: 'Core operations — vault stats, cross-domain search, health check, identity, and activation system.',
+    ops: [...coreOps, ...agentOps],
+  };
+
+  const domainFacades = createDomainFacades(runtime, '${config.id}', ${domainsLiteral});
+
+  // ─── MCP server ────────────────────────────────────────────────
   const server = new McpServer({
     name: '${config.id}-mcp',
     version: '1.0.0',
   });
 
-  // Register persona prompt
   server.prompt('persona', 'Get agent persona and principles', async () => ({
     messages: [{ role: 'assistant' as const, content: { type: 'text' as const, text: getPersonaPrompt() } }],
   }));
 
-  // Create and register facades
-  const facades = [
-${facadeCreations}
-    createCoreFacade(vault, planner, brain, cognee.isAvailable ? cognee : undefined, llmClient, openaiKeyPool, anthropicKeyPool),
-  ];
-
+  const facades = [coreFacade, ...domainFacades];
   registerAllFacades(server, facades);
 
-  const stats = vault.stats();
-  console.error(\`[\${PERSONA.name.toLowerCase()}] \${PERSONA.name} — \${PERSONA.role}\`);
-  console.error(\`[\${PERSONA.name.toLowerCase()}] Vault: \${stats.totalEntries} entries across \${Object.keys(stats.byDomain).length} domains\`);
-  console.error(\`[\${PERSONA.name.toLowerCase()}] Registered \${facades.length} facades with \${facades.reduce((sum, f) => sum + f.ops.length, 0)} operations\`);
+  console.error(\`[\${tag}] \${PERSONA.name} — \${PERSONA.role}\`);
+  console.error(\`[\${tag}] Registered \${facades.length} facades with \${facades.reduce((sum, f) => sum + f.ops.length, 0)} operations\`);
 
-  // Stdio transport
+  // ─── Transport + shutdown ──────────────────────────────────────
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error(\`[\${PERSONA.name.toLowerCase()}] Connected via stdio transport\`);
-  console.error(\`[\${PERSONA.name.toLowerCase()}] Say "Hello, \${PERSONA.name}!" to activate\`);
+  console.error(\`[\${tag}] Connected via stdio transport\`);
+  console.error(\`[\${tag}] Say "Hello, \${PERSONA.name}!" to activate\`);
 
-  // Graceful shutdown
   const shutdown = async (): Promise<void> => {
-    console.error(\`[\${PERSONA.name.toLowerCase()}] Shutting down...\`);
-    vault.close();
+    console.error(\`[\${tag}] Shutting down...\`);
+    runtime.close();
     process.exit(0);
   };
   process.on('SIGTERM', shutdown);
@@ -130,10 +192,3 @@ main().catch((err) => {
 });
 `;
 }
-
-function pascalCase(s: string): string {
-  return s
-    .split(/[-_\s]+/)
-    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
-    .join('');
-}

package/src/templates/package-json.ts

@@ -21,11 +21,13 @@ export function generatePackageJson(config: AgentConfig): string {
     license: 'MIT',
     engines: { node: '>=18.0.0' },
     dependencies: {
-      '@anthropic-ai/sdk': '^0.39.0',
       '@modelcontextprotocol/sdk': '^1.12.1',
       '@soleri/core': '^2.0.0',
       zod: '^3.24.2',
     },
+    optionalDependencies: {
+      '@anthropic-ai/sdk': '^0.39.0',
+    },
     devDependencies: {
       '@types/node': '^22.13.4',
       '@vitest/coverage-v8': '^3.0.5',