@soleri/forge 4.2.2 → 5.0.1

package/dist/templates/core-facade.js

@@ -4,20 +4,20 @@
  */
 export function generateCoreFacade(config) {
     return `import { z } from 'zod';
-import type { FacadeConfig, Vault, IntelligenceEntry, Planner, Brain, KeyPool, CogneeClient } from '@soleri/core';
+import type { FacadeConfig, Vault, IntelligenceEntry, Planner, Brain, KeyPool, Curator } from '@soleri/core';
 import { PERSONA } from '../identity/persona.js';
 import { activateAgent, deactivateAgent } from '../activation/activate.js';
 import { injectClaudeMd, injectClaudeMdGlobal, hasAgentMarker } from '../activation/inject-claude-md.js';
 import type { LLMClient } from '../llm/llm-client.js';
 
-export function createCoreFacade(vault: Vault, planner: Planner, brain: Brain, cognee?: CogneeClient, llmClient?: LLMClient, openaiKeyPool?: KeyPool, anthropicKeyPool?: KeyPool): FacadeConfig {
+export function createCoreFacade(vault: Vault, planner: Planner, brain: Brain, llmClient?: LLMClient, openaiKeyPool?: KeyPool, anthropicKeyPool?: KeyPool, curator?: Curator): FacadeConfig {
   return {
     name: '${config.id}_core',
     description: 'Core operations — vault stats, cross-domain search, health check, identity, and activation system.',
     ops: [
       {
         name: 'search',
-        description: 'Search across all knowledge domains. Results ranked by TF-IDF + severity + recency + tag overlap + domain match. When Cognee is available, adds vector similarity for hybrid ranking.',
+        description: 'Search across all knowledge domains. Results ranked by TF-IDF + severity + recency + tag overlap + domain match.',
         auth: 'read',
         schema: z.object({
           query: z.string(),
@@ -28,7 +28,7 @@ export function createCoreFacade(vault: Vault, planner: Planner, brain: Brain, c
           limit: z.number().optional(),
         }),
         handler: async (params) => {
-          return await brain.intelligentSearch(params.query as string, {
+          return brain.intelligentSearch(params.query as string, {
             domain: params.domain as string | undefined,
             type: params.type as string | undefined,
             severity: params.severity as string | undefined,
@@ -448,64 +448,112 @@ export function createCoreFacade(vault: Vault, planner: Planner, brain: Brain, c
           };
         },
       },
+      // ─── Curator ops ───────────────────────────────────────────
       {
-        name: 'cognee_status',
-        description: 'Check Cognee vector search availability and connection status.',
+        name: 'curator_status',
+        description: 'Curator status — table row counts, last groomed timestamp.',
         auth: 'read',
         handler: async () => {
-          if (!cognee) return { available: false, message: 'Cognee not configured' };
-          const status = cognee.getStatus();
-          const cfg = cognee.getConfig();
-          return {
-            available: cognee.isAvailable,
-            config: {
-              baseUrl: cfg.baseUrl,
-              dataset: cfg.dataset,
-              timeoutMs: cfg.timeoutMs,
-              searchTimeoutMs: cfg.searchTimeoutMs,
-              healthTimeoutMs: cfg.healthTimeoutMs,
-              healthCacheTtlMs: cfg.healthCacheTtlMs,
-              cognifyDebounceMs: cfg.cognifyDebounceMs,
-              hasApiToken: Boolean(cfg.apiToken),
-              hasServiceCredentials: Boolean(cfg.serviceEmail && cfg.servicePassword),
-            },
-            lastHealth: status,
-          };
+          if (!curator) return { error: 'Curator not initialized' };
+          return curator.getStatus();
         },
       },
       {
-        name: 'cognee_sync',
-        description: 'Force sync all vault entries to Cognee and trigger knowledge graph build. Requires Cognee to be running.',
-        auth: 'write',
-        handler: async () => {
-          if (!cognee?.isAvailable) {
-            return { synced: false, message: 'Cognee not available. Start with: docker compose -f docker/docker-compose.cognee.yml up -d' };
-          }
-          const result = await brain.syncToCognee();
-          return { ok: true, entriesSynced: result.synced, cognified: result.cognified };
+        name: 'curator_detect_duplicates',
+        description: 'Detect duplicate entries using TF-IDF cosine similarity.',
+        auth: 'read',
+        schema: z.object({
+          entryId: z.string().optional().describe('Check a specific entry. Omit to scan all.'),
+          threshold: z.number().optional().describe('Similarity threshold (0-1). Default 0.45.'),
+        }),
+        handler: async (params) => {
+          if (!curator) return { error: 'Curator not initialized' };
+          return curator.detectDuplicates(
+            params.entryId as string | undefined,
+            params.threshold as number | undefined,
+          );
         },
       },
       {
-        name: 'graph_search',
-        description: 'Search using Cognee knowledge graph completion. Returns semantically related entries that keyword search might miss.',
+        name: 'curator_contradictions',
+        description: 'List or detect contradictions between patterns and anti-patterns.',
         auth: 'read',
         schema: z.object({
-          query: z.string(),
-          searchType: z.enum(['SUMMARIES', 'CHUNKS', 'RAG_COMPLETION', 'GRAPH_COMPLETION', 'GRAPH_SUMMARY_COMPLETION', 'NATURAL_LANGUAGE', 'FEELING_LUCKY', 'CHUNKS_LEXICAL']).optional().default('CHUNKS'),
-          limit: z.number().optional().default(10),
+          status: z.enum(['open', 'resolved', 'dismissed']).optional().describe('Filter by status.'),
+          detect: z.boolean().optional().describe('If true, run detection before listing.'),
         }),
         handler: async (params) => {
-          if (!cognee?.isAvailable) {
-            return { results: [], message: 'Cognee not available — use search op for FTS5 results' };
+          if (!curator) return { error: 'Curator not initialized' };
+          if (params.detect) {
+            curator.detectContradictions();
           }
-          const results = await cognee.search(
-            params.query as string,
-            {
-              searchType: params.searchType as 'SUMMARIES' | 'CHUNKS' | 'GRAPH_COMPLETION',
-              limit: params.limit as number,
-            },
+          return curator.getContradictions(params.status as 'open' | 'resolved' | 'dismissed' | undefined);
+        },
+      },
+      {
+        name: 'curator_resolve_contradiction',
+        description: 'Resolve or dismiss a contradiction.',
+        auth: 'write',
+        schema: z.object({
+          id: z.number().describe('Contradiction ID.'),
+          resolution: z.enum(['resolved', 'dismissed']),
+        }),
+        handler: async (params) => {
+          if (!curator) return { error: 'Curator not initialized' };
+          return curator.resolveContradiction(
+            params.id as number,
+            params.resolution as 'resolved' | 'dismissed',
           );
-          return { results, count: results.length };
+        },
+      },
+      {
+        name: 'curator_groom',
+        description: 'Groom a single entry — normalize tags, check staleness.',
+        auth: 'write',
+        schema: z.object({
+          entryId: z.string().describe('Entry ID to groom.'),
+        }),
+        handler: async (params) => {
+          if (!curator) return { error: 'Curator not initialized' };
+          return curator.groomEntry(params.entryId as string);
+        },
+      },
+      {
+        name: 'curator_groom_all',
+        description: 'Groom all vault entries — normalize tags, detect staleness.',
+        auth: 'write',
+        handler: async () => {
+          if (!curator) return { error: 'Curator not initialized' };
+          return curator.groomAll();
+        },
+      },
+      {
+        name: 'curator_consolidate',
+        description: 'Consolidate vault — find duplicates, stale entries, contradictions. Dry-run by default.',
+        auth: 'write',
+        schema: z.object({
+          dryRun: z.boolean().optional().describe('Default true. Set false to apply mutations.'),
+          staleDaysThreshold: z.number().optional().describe('Days before entry is stale. Default 90.'),
+          duplicateThreshold: z.number().optional().describe('Cosine similarity threshold. Default 0.45.'),
+          contradictionThreshold: z.number().optional().describe('Contradiction threshold. Default 0.4.'),
+        }),
+        handler: async (params) => {
+          if (!curator) return { error: 'Curator not initialized' };
+          return curator.consolidate({
+            dryRun: params.dryRun as boolean | undefined,
+            staleDaysThreshold: params.staleDaysThreshold as number | undefined,
+            duplicateThreshold: params.duplicateThreshold as number | undefined,
+            contradictionThreshold: params.contradictionThreshold as number | undefined,
+          });
+        },
+      },
+      {
+        name: 'curator_health_audit',
+        description: 'Audit vault health — score (0-100), coverage, freshness, quality, tag health, recommendations.',
+        auth: 'read',
+        handler: async () => {
+          if (!curator) return { error: 'Curator not initialized' };
+          return curator.healthAudit();
         },
       },
     ],

package/dist/templates/core-facade.js.map

@@ -1 +1 @@
-{"version":3,"file":"core-facade.js","sourceRoot":"","sources":["../../src/templates/core-facade.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAmB;IACpD,OAAO;;;;;;;;;aASI,MAAM,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uGA2EiF,MAAM,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA6D9E,MAAM,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEAiCiB,MAAM,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0U1E,CAAC;AACF,CAAC"}
+{"version":3,"file":"core-facade.js","sourceRoot":"","sources":["../../src/templates/core-facade.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAmB;IACpD,OAAO;;;;;;;;;aASI,MAAM,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uGA2EiF,MAAM,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA6D9E,MAAM,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEAiCiB,MAAM,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0X1E,CAAC;AACF,CAAC"}

package/dist/templates/entry-point.d.ts

@@ -1,5 +1,9 @@
 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 declare function generateEntryPoint(config: AgentConfig): string;

package/dist/templates/entry-point.js

@@ -1,119 +1,182 @@
 /**
  * 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) {
-    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
 
 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);
@@ -126,10 +189,4 @@ main().catch((err) => {
 });
 `;
 }
-function pascalCase(s) {
-    return s
-        .split(/[-_\s]+/)
-        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
-        .join('');
-}
 //# sourceMappingURL=entry-point.js.map

package/dist/templates/entry-point.js.map

@@ -1 +1 @@
-{"version":3,"file":"entry-point.js","sourceRoot":"","sources":["../../src/templates/entry-point.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAmB;IACpD,MAAM,aAAa,GAAG,MAAM,CAAC,OAAO;SACjC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;QACT,MAAM,EAAE,GAAG,SAAS,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC;QAC1C,MAAM,IAAI,GAAG,GAAG,CAAC,YAAY,CAAC;QAC9B,OAAO,YAAY,EAAE,sBAAsB,IAAI,IAAI,CAAC;IACtD,CAAC,CAAC;SACD,IAAI,CAAC,IAAI,CAAC,CAAC;IAEd,MAAM,eAAe,GAAG,MAAM,CAAC,OAAO;SACnC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,aAAa,UAAU,CAAC,CAAC,CAAC,uBAAuB,CAAC;SAC7D,IAAI,CAAC,IAAI,CAAC,CAAC;IAEd,OAAO;;;;;;;;;EASP,aAAa;;;;;;;;yCAQ0B,MAAM,CAAC,EAAE;wCACV,MAAM,CAAC,EAAE;;;;;;;;;;;;;;gCAcjB,MAAM,CAAC,EAAE;wCACD,MAAM,CAAC,EAAE;;;;;;;;gBAQjC,MAAM,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;4CAoBmB,MAAM,CAAC,EAAE;;;;;;;;;aASxC,MAAM,CAAC,EAAE;;;;;;;;;;;EAWpB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA4BG,MAAM,CAAC,EAAE;;;CAG5B,CAAC;AACF,CAAC;AAED,SAAS,UAAU,CAAC,CAAS;IAC3B,OAAO,CAAC;SACL,KAAK,CAAC,SAAS,CAAC;SAChB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;SAClD,IAAI,CAAC,EAAE,CAAC,CAAC;AACd,CAAC"}
+{"version":3,"file":"entry-point.js","sourceRoot":"","sources":["../../src/templates/entry-point.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAmB;IACpD,MAAM,cAAc,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAEtD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;gBAwBO,MAAM,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qGAkC4E,MAAM,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCA6D9E,MAAM,CAAC,IAAI;;;;;;;;;;;;;;;;;;;aAmBhC,MAAM,CAAC,EAAE;;;;;wDAKkC,MAAM,CAAC,EAAE,MAAM,cAAc;;;;aAIxE,MAAM,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA8BF,MAAM,CAAC,EAAE;;;CAG5B,CAAC;AACF,CAAC"}

package/dist/templates/facade-factory.d.ts

@@ -0,0 +1 @@
+export declare function generateFacadeFactory(): string;

package/dist/templates/facade-factory.js

@@ -0,0 +1,63 @@
+export function generateFacadeFactory() {
+    return `import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { FacadeConfig, FacadeResponse } from './types.js';
+
+export function registerFacade(server: McpServer, facade: FacadeConfig): void {
+  const opNames = facade.ops.map((o) => o.name);
+
+  server.tool(
+    facade.name,
+    \`\${facade.description}\\n\\nOperations: \${opNames.join(', ')}\`,
+    {
+      op: z.string().describe(\`Operation: \${opNames.join(' | ')}\`),
+      params: z.record(z.unknown()).optional().default({}).describe('Operation parameters'),
+    },
+    async ({ op, params }): Promise<{ content: Array<{ type: 'text'; text: string }> }> => {
+      const response = await dispatchOp(facade, op, params);
+      return { content: [{ type: 'text' as const, text: JSON.stringify(response, null, 2) }] };
+    },
+  );
+}
+
+async function dispatchOp(
+  facade: FacadeConfig,
+  opName: string,
+  params: Record<string, unknown>,
+): Promise<FacadeResponse> {
+  const op = facade.ops.find((o) => o.name === opName);
+  if (!op) {
+    return {
+      success: false,
+      error: \`Unknown operation "\${opName}" on \${facade.name}. Available: \${facade.ops.map((o) => o.name).join(', ')}\`,
+      op: opName,
+      facade: facade.name,
+    };
+  }
+
+  try {
+    let validatedParams = params;
+    if (op.schema) {
+      const result = op.schema.safeParse(params);
+      if (!result.success) {
+        return { success: false, error: \`Invalid params for \${opName}: \${result.error.message}\`, op: opName, facade: facade.name };
+      }
+      validatedParams = result.data as Record<string, unknown>;
+    }
+
+    const data = await op.handler(validatedParams);
+    return { success: true, data, op: opName, facade: facade.name };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { success: false, error: message, op: opName, facade: facade.name };
+  }
+}
+
+export function registerAllFacades(server: McpServer, facades: FacadeConfig[]): void {
+  for (const facade of facades) {
+    registerFacade(server, facade);
+  }
+}
+`;
+}
+//# sourceMappingURL=facade-factory.js.map

package/dist/templates/facade-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"facade-factory.js","sourceRoot":"","sources":["../../src/templates/facade-factory.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,qBAAqB;IACnC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2DR,CAAC;AACF,CAAC"}

package/dist/templates/facade-types.d.ts

@@ -0,0 +1 @@
+export declare function generateFacadeTypes(): string;

package/dist/templates/facade-types.js

@@ -0,0 +1,46 @@
+export function generateFacadeTypes() {
+    return `import { z } from 'zod';
+
+/** Handler function for a single facade operation */
+export type OpHandler = (params: Record<string, unknown>) => Promise<unknown>;
+
+/** Auth level required for an operation */
+export type AuthLevel = 'read' | 'write' | 'admin';
+
+/** Operation definition within a facade */
+export interface OpDefinition {
+  name: string;
+  description: string;
+  auth: AuthLevel;
+  handler: OpHandler;
+  schema?: z.ZodType;
+}
+
+/** Facade configuration — one MCP tool */
+export interface FacadeConfig {
+  /** MCP tool name */
+  name: string;
+  /** Human-readable description */
+  description: string;
+  /** Domain operations */
+  ops: OpDefinition[];
+}
+
+/** Standard facade response envelope */
+export interface FacadeResponse {
+  success: boolean;
+  data?: unknown;
+  error?: string;
+  op?: string;
+  facade?: string;
+}
+
+export const facadeInputSchema = z.object({
+  op: z.string().describe('Operation name'),
+  params: z.record(z.unknown()).optional().default({}),
+});
+
+export type FacadeInput = z.infer<typeof facadeInputSchema>;
+`;
+}
+//# sourceMappingURL=facade-types.js.map

package/dist/templates/facade-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"facade-types.js","sourceRoot":"","sources":["../../src/templates/facade-types.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,mBAAmB;IACjC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0CR,CAAC;AACF,CAAC"}

package/dist/templates/intelligence-loader.d.ts

@@ -0,0 +1 @@
+export declare function generateIntelligenceLoader(): string;