@soleri/forge 5.14.10 → 8.0.0

package/src/scaffolder.ts

@@ -9,7 +9,13 @@ import {
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { execFileSync } from 'node:child_process';
-import type { AgentConfig, ScaffoldResult, ScaffoldPreview, AgentInfo } from './types.js';
+import type {
+  AgentConfig,
+  SetupTarget,
+  ScaffoldResult,
+  ScaffoldPreview,
+  AgentInfo,
+} from './types.js';
 
 import { generatePackageJson } from './templates/package-json.js';
 import { generateTsconfig } from './templates/tsconfig.js';
@@ -29,30 +35,49 @@ import { generateTelegramBot } from './templates/telegram-bot.js';
 import { generateTelegramConfig } from './templates/telegram-config.js';
 import { generateTelegramAgent } from './templates/telegram-agent.js';
 import { generateTelegramSupervisor } from './templates/telegram-supervisor.js';
+import { detectInstalledDomainPacks } from './utils/detect-domain-packs.js';
 
-function getSetupTarget(config: AgentConfig): 'claude' | 'codex' | 'both' {
+function getSetupTarget(config: AgentConfig): SetupTarget {
   return config.setupTarget ?? 'claude';
 }
 
 function includesClaudeSetup(config: AgentConfig): boolean {
   const target = getSetupTarget(config);
-  return target === 'claude' || target === 'both';
+  return target === 'claude' || target === 'both' || target === 'all';
 }
 
 function includesCodexSetup(config: AgentConfig): boolean {
   const target = getSetupTarget(config);
-  return target === 'codex' || target === 'both';
+  return target === 'codex' || target === 'both' || target === 'all';
+}
+
+function includesOpencodeSetup(config: AgentConfig): boolean {
+  const target = getSetupTarget(config);
+  return target === 'opencode' || target === 'all';
 }
 
 /**
  * Preview what scaffold will create without writing anything.
  */
 export function previewScaffold(config: AgentConfig): ScaffoldPreview {
+  // Auto-detect domain packs if not explicitly configured
+  if (!config.domainPacks || config.domainPacks.length === 0) {
+    const detected = detectInstalledDomainPacks(config.outputDir);
+    if (detected.length > 0) {
+      config = { ...config, domainPacks: detected };
+    }
+  }
+
   const agentDir = join(config.outputDir, config.id);
   const claudeSetup = includesClaudeSetup(config);
   const codexSetup = includesCodexSetup(config);
-  const setupLabel =
-    claudeSetup && codexSetup ? 'Claude Code + Codex' : claudeSetup ? 'Claude Code' : 'Codex';
+  const opencodeSetup = includesOpencodeSetup(config);
+  const setupParts = [
+    ...(claudeSetup ? ['Claude Code'] : []),
+    ...(codexSetup ? ['Codex'] : []),
+    ...(opencodeSetup ? ['OpenCode'] : []),
+  ];
+  const setupLabel = setupParts.join(' + ');
 
   const files = [
     { path: 'package.json', description: 'NPM package with MCP SDK, SQLite, Zod dependencies' },
@@ -113,10 +138,20 @@ export function previewScaffold(config: AgentConfig): ScaffoldPreview {
     },
   ];
 
-  if (codexSetup) {
+  if (opencodeSetup) {
+    files.push({
+      path: '.opencode.json',
+      description: 'OpenCode MCP server config for connecting to this agent',
+    });
+  }
+
+  if (codexSetup || opencodeSetup) {
+    const hosts = [...(codexSetup ? ['Codex'] : []), ...(opencodeSetup ? ['OpenCode'] : [])].join(
+      ' + ',
+    );
     files.push({
       path: 'AGENTS.md',
-      description: 'Codex project instructions and activation workflow',
+      description: `${hosts} project instructions and activation workflow`,
     });
   }
 
@@ -253,8 +288,21 @@ export function scaffold(config: AgentConfig): ScaffoldResult {
       greeting: `Hello! I'm ${config.name}, your AI assistant for ${config.role}.`,
     };
   }
+
+  // Auto-detect domain packs if not explicitly configured
+  if (!config.domainPacks || config.domainPacks.length === 0) {
+    const detected = detectInstalledDomainPacks(config.outputDir);
+    if (detected.length > 0) {
+      config = { ...config, domainPacks: detected };
+      console.error(
+        `[forge] Auto-detected ${detected.length} domain pack(s): ${detected.map((d) => d.package).join(', ')}`,
+      );
+    }
+  }
+
   const claudeSetup = includesClaudeSetup(config);
   const codexSetup = includesCodexSetup(config);
+  const opencodeSetup = includesOpencodeSetup(config);
   const agentDir = join(config.outputDir, config.id);
   const filesCreated: string[] = [];
 
@@ -312,7 +360,36 @@ export function scaffold(config: AgentConfig): ScaffoldResult {
     ['scripts/setup.sh', generateSetupScript(config)],
   ];
 
-  if (codexSetup) {
+  if (opencodeSetup) {
+    projectFiles.push([
+      '.opencode.json',
+      JSON.stringify(
+        {
+          $schema: 'https://opencode.ai/config.json',
+          title: config.name,
+          tui: { theme: 'soleri' },
+          mcpServers: {
+            [config.id]: {
+              type: 'stdio',
+              command: 'node',
+              args: ['dist/index.js'],
+            },
+          },
+          agents: {
+            coder: { model: config.model ?? 'claude-code-sonnet-4' },
+            summarizer: { model: 'claude-code-3.5-haiku' },
+            task: { model: 'claude-code-3.5-haiku' },
+            title: { model: 'claude-code-3.5-haiku' },
+          },
+          contextPaths: ['AGENTS.md'],
+        },
+        null,
+        2,
+      ),
+    ]);
+  }
+
+  if (codexSetup || opencodeSetup) {
     projectFiles.push(['AGENTS.md', generateAgentsMd(config)]);
   }
 
@@ -386,8 +463,22 @@ export function scaffold(config: AgentConfig): ScaffoldResult {
     buildError = err instanceof Error ? err.message : String(err);
   }
 
+  // Install OpenCode CLI if needed and not already available
+  const opencodeInstallResult = opencodeSetup ? ensureOpencodeInstalled() : undefined;
+
+  // Create launcher script so typing the agent name starts OpenCode
+  if (opencodeSetup && buildSuccess) {
+    const launcherResult = createOpencodeLauncher(config.id, agentDir);
+    if (launcherResult.created) {
+      // Launcher details added to summary below
+    }
+  }
+
   // Register the agent as an MCP server in selected host configs (only if build succeeded)
-  const mcpRegistrations: Array<{ host: 'Claude Code' | 'Codex'; result: RegistrationResult }> = [];
+  const mcpRegistrations: Array<{
+    host: 'Claude Code' | 'Codex' | 'OpenCode';
+    result: RegistrationResult;
+  }> = [];
   if (claudeSetup) {
     if (buildSuccess) {
       mcpRegistrations.push({
@@ -422,13 +513,30 @@ export function scaffold(config: AgentConfig): ScaffoldResult {
       });
     }
   }
+  if (opencodeSetup) {
+    if (buildSuccess) {
+      mcpRegistrations.push({
+        host: 'OpenCode',
+        result: registerOpencodeMcpServer(config.id, agentDir),
+      });
+    } else {
+      mcpRegistrations.push({
+        host: 'OpenCode',
+        result: {
+          registered: false,
+          path: join(homedir(), '.opencode.json'),
+          error: 'Skipped — build failed',
+        },
+      });
+    }
+  }
 
   const summaryLines = [
     `Created ${config.name} agent at ${agentDir}`,
     `${config.domains.length + 11} facades with ${totalOps} operations`,
     `${config.domains.length} empty knowledge domains ready for capture`,
     `Intelligence layer (Brain) — TF-IDF scoring, auto-tagging, duplicate detection`,
-    `Activation system included — say "Hello, ${config.name}!" to activate`,
+    `Persistent identity — ${config.name} is active from the start`,
     `1 test suite — facades (vault, brain, planner, llm tests provided by @soleri/core)`,
     `${skillFiles.length} built-in skills (TDD, debugging, planning, vault, brain debrief)`,
   ];
@@ -440,6 +548,23 @@ export function scaffold(config: AgentConfig): ScaffoldResult {
     summaryLines.push(`  Run manually: cd ${agentDir} && npm install && npm run build`);
   }
 
+  if (opencodeInstallResult) {
+    if (opencodeInstallResult.installed) {
+      summaryLines.push(`OpenCode CLI installed (${opencodeInstallResult.method})`);
+    } else if (!opencodeInstallResult.alreadyPresent && opencodeInstallResult.error) {
+      summaryLines.push('Warning: Failed to install OpenCode CLI');
+      summaryLines.push('  Install manually: npm install -g opencode-ai');
+    }
+  }
+
+  // Report launcher status
+  if (opencodeSetup && buildSuccess) {
+    const launcherPath = join('/usr', 'local', 'bin', config.id);
+    if (existsSync(launcherPath)) {
+      summaryLines.push(`Launcher created: type "${config.id}" in terminal to start OpenCode`);
+    }
+  }
+
   if (claudeSetup && config.hookPacks?.length) {
     summaryLines.push(`${config.hookPacks.length} hook pack(s) bundled in .claude/`);
   }
@@ -463,7 +588,10 @@ export function scaffold(config: AgentConfig): ScaffoldResult {
   if (codexSetup) {
     nextSteps.push('  Restart Codex');
   }
-  nextSteps.push(`  Say "Hello, ${config.name}!" to activate the persona`);
+  if (opencodeSetup) {
+    nextSteps.push('  Restart OpenCode');
+  }
+  nextSteps.push(`  ${config.name} identity is active from the start — no activation needed`);
   summaryLines.push(...nextSteps);
 
   return {
@@ -498,7 +626,10 @@ export function listAgents(parentDir: string): AgentInfo[] {
 
     try {
       const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-      if (!pkg.name?.endsWith('-mcp')) continue;
+      // Accept both old format (name-mcp) and new format (name)
+      const hasMcpSuffix = pkg.name?.endsWith('-mcp');
+      const hasIntelligenceDir = existsSync(join(dir, 'src', 'intelligence', 'data'));
+      if (!hasMcpSuffix && !hasIntelligenceDir) continue;
 
       const dataDir = join(dir, 'src', 'intelligence', 'data');
       let domains: string[] = [];
@@ -512,7 +643,7 @@ export function listAgents(parentDir: string): AgentInfo[] {
 
       agents.push({
         id: name,
-        name: pkg.name.replace('-mcp', ''),
+        name: hasMcpSuffix ? pkg.name.replace('-mcp', '') : pkg.name,
         role: pkg.description || '',
         path: dir,
         domains,
@@ -614,12 +745,165 @@ args = ["${join(agentDir, 'dist', 'index.js')}"]
   }
 }
 
+/**
+ * Create a launcher script at /usr/local/bin/<agentId> that starts OpenCode
+ * in the agent's project directory. Typing the agent name in terminal → OpenCode starts.
+ */
+function createOpencodeLauncher(
+  agentId: string,
+  agentDir: string,
+): { created: boolean; path: string; error?: string } {
+  const launcherPath = join('/usr', 'local', 'bin', agentId);
+  const script = [
+    '#!/usr/bin/env bash',
+    `# Soleri agent launcher — starts OpenCode with ${agentId} MCP agent`,
+    `# Set terminal title to agent name`,
+    `printf '\\033]0;${agentId}\\007'`,
+    `cd "${agentDir}" || exit 1`,
+    'exec opencode "$@"',
+    '',
+  ].join('\n');
+
+  try {
+    writeFileSync(launcherPath, script, { mode: 0o755 });
+    return { created: true, path: launcherPath };
+  } catch {
+    // /usr/local/bin may need sudo — try via agent's scripts/ directory instead
+    const localLauncher = join(agentDir, 'scripts', agentId);
+    try {
+      writeFileSync(localLauncher, script, { mode: 0o755 });
+      // Try to symlink to /usr/local/bin
+      try {
+        const { symlinkSync, unlinkSync } = require('node:fs') as typeof import('node:fs');
+        if (existsSync(launcherPath)) unlinkSync(launcherPath);
+        symlinkSync(localLauncher, launcherPath);
+        return { created: true, path: launcherPath };
+      } catch {
+        return { created: true, path: localLauncher };
+      }
+    } catch (err) {
+      return {
+        created: false,
+        path: launcherPath,
+        error: err instanceof Error ? err.message : String(err),
+      };
+    }
+  }
+}
+
+/**
+ * Ensure OpenCode CLI is installed (Soleri fork with title branding support).
+ * Tries `go install` from the fork first, falls back to upstream npm package.
+ */
+function ensureOpencodeInstalled(): {
+  alreadyPresent: boolean;
+  installed: boolean;
+  method?: string;
+  error?: string;
+} {
+  // Check if already available
+  try {
+    execFileSync('opencode', ['--version'], { stdio: 'pipe', timeout: 10_000 });
+    return { alreadyPresent: true, installed: false };
+  } catch {
+    // Not installed — proceed to install
+  }
+
+  // Try Go install from Soleri fork (supports title branding)
+  try {
+    execFileSync('go', ['version'], { stdio: 'pipe', timeout: 5_000 });
+    execFileSync('go', ['install', 'github.com/adrozdenko/opencode@latest'], {
+      stdio: 'pipe',
+      timeout: 120_000,
+    });
+    return {
+      alreadyPresent: false,
+      installed: true,
+      method: 'go install github.com/adrozdenko/opencode@latest',
+    };
+  } catch {
+    // Go not available or install failed — fall back to npm
+  }
+
+  // Fallback: upstream npm package (no title branding)
+  try {
+    execFileSync('npm', ['install', '-g', 'opencode-ai'], {
+      stdio: 'pipe',
+      timeout: 60_000,
+    });
+    return {
+      alreadyPresent: false,
+      installed: true,
+      method: 'npm install -g opencode-ai (upstream — title branding requires Go)',
+    };
+  } catch (err) {
+    return {
+      alreadyPresent: false,
+      installed: false,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
+/**
+ * Register the agent as an MCP server in ~/.opencode.json.
+ * Idempotent — updates existing entry if present.
+ */
+function registerOpencodeMcpServer(agentId: string, agentDir: string): RegistrationResult {
+  const opencodeConfigPath = join(homedir(), '.opencode.json');
+
+  try {
+    let config: Record<string, unknown> = {};
+
+    if (existsSync(opencodeConfigPath)) {
+      // Strip single-line comments before parsing (JSONC support)
+      const raw = readFileSync(opencodeConfigPath, 'utf-8');
+      const stripped = raw.replace(/^\s*\/\/.*$/gm, '');
+      try {
+        config = JSON.parse(stripped);
+      } catch {
+        config = {};
+      }
+    }
+
+    if (!config.mcpServers || typeof config.mcpServers !== 'object') {
+      config.mcpServers = {};
+    }
+
+    const servers = config.mcpServers as Record<string, unknown>;
+    servers[agentId] = {
+      type: 'stdio',
+      command: 'node',
+      args: [join(agentDir, 'dist', 'index.js')],
+    };
+
+    writeFileSync(opencodeConfigPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+    return { registered: true, path: opencodeConfigPath };
+  } catch (err) {
+    return {
+      registered: false,
+      path: opencodeConfigPath,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
 function generateEmptyBundle(domain: string): string {
   return JSON.stringify(
     {
       domain,
       version: '1.0.0',
-      entries: [],
+      entries: [
+        {
+          id: `${domain}-seed`,
+          type: 'pattern',
+          domain,
+          title: `${domain.replace(/-/g, ' ')} domain seed`,
+          severity: 'suggestion',
+          description: `Seed entry for the ${domain.replace(/-/g, ' ')} domain. Replace or remove once real knowledge is captured.`,
+          tags: [domain, 'seed'],
+        },
+      ],
     },
     null,
     2,

package/src/templates/activate.ts

@@ -43,6 +43,8 @@ export function generateActivate(config: AgentConfig): string {
     '    domains: string[];',
     '    capabilities: Array<{ domain: string; entries: number }>;',
     '    installed_packs: Array<{ id: string; type: string }>;',
+    '    what_you_can_do: string[];',
+    '    growth_suggestions: string[];',
     '  };',
     '  guidelines: string[];',
     '  session_instruction: string;',
@@ -138,6 +140,41 @@ export function generateActivate(config: AgentConfig): string {
     '    greeting += ` Vault: ${stats.totalEntries} entries (${domainSummary}).`;',
     '  }',
     '',
+    '  // ─── Capability self-awareness ────────────────────────────',
+    '  const whatYouCanDo: string[] = [',
+    '    "Search and traverse a connected knowledge graph (vault) before every decision",',
+    '    "Create structured plans with approval gates and drift reconciliation",',
+    '    "Learn from sessions — brain tracks pattern strengths and recommends approaches",',
+    '    "Remember across conversations and projects (cross-project memory)",',
+    '    "Capture knowledge as typed entries with Zettelkasten links",',
+    '    "Run iterative validation loops until quality targets are met",',
+    '    "Orchestrate multi-step workflows: plan → execute → capture",',
+    '  ];',
+    '',
+    '  // Add domain-specific capabilities',
+    '  for (const cap of capabilities) {',
+    '    if (cap.entries > 0) {',
+    '      whatYouCanDo.push(`${cap.domain.replace(/-/g, " ")}: ${cap.entries} patterns and knowledge entries`);',
+    '    }',
+    '  }',
+    '',
+    '  // Add pack-specific capabilities',
+    '  for (const pack of installedPacks) {',
+    '    whatYouCanDo.push(`Pack "${pack.id}" (${pack.type}) installed — provides domain-specific intelligence`);',
+    '  }',
+    '',
+    '  const growthSuggestions: string[] = [];',
+    '  if (stats.totalEntries < 10) {',
+    '    growthSuggestions.push("Vault has few entries — start capturing patterns to build your knowledge base");',
+    '  }',
+    '  if (installedPacks.length === 0) {',
+    '    growthSuggestions.push("No packs installed — try: soleri pack install <name> to add domain intelligence");',
+    '    growthSuggestions.push("Available starter packs: soleri pack available");',
+    '  }',
+    '  if (allDomains.length <= 1) {',
+    '    growthSuggestions.push("Only one domain configured — add more with: soleri add-domain <name>");',
+    '  }',
+    '',
     '  // ─── Next steps ───────────────────────────────────────────',
     '  const nextSteps: string[] = [];',
     '  if (!globalClaudeMdInjected && !claudeMdInjected) {',
@@ -177,6 +214,8 @@ export function generateActivate(config: AgentConfig): string {
     '      domains: allDomains,',
     '      capabilities,',
     '      installed_packs: installedPacks,',
+    '      what_you_can_do: whatYouCanDo,',
+    '      growth_suggestions: growthSuggestions,',
     '    },',
     '    guidelines: [',
     guidelineLines,

package/src/templates/agents-md.ts

@@ -1,35 +1,97 @@
 import type { AgentConfig } from '../types.js';
+import { getEngineRulesContent } from './shared-rules.js';
 
 /**
- * Generate AGENTS.md content for Codex sessions.
+ * Generate AGENTS.md content for OpenCode (primary host).
+ *
+ * This is the full instruction file — equivalent to what CLAUDE.md gets
+ * via claude-md-template.ts + shared-rules.ts. OpenCode reads AGENTS.md
+ * as its primary instruction file, so it must contain:
+ *   1. Persistent identity (always-on, no activation needed)
+ *   2. Full facade table (all 13+ semantic facades + domains)
+ *   3. Engine rules (vault-first, planning, output formatting, etc.)
+ *   4. Session start protocol
+ *   5. Skills reference
  */
 export function generateAgentsMd(config: AgentConfig): string {
+  const bt = '`';
+  const tp = config.id; // tool prefix
   const principles = config.principles.map((p) => `- ${p}`).join('\n');
   const domains = config.domains.map((d) => `- ${d}`).join('\n');
 
-  return `# AGENTS.md instructions for this project
+  // ─── Domain facade rows ───────────────────────────────────
+  const domainRows = config.domains
+    .map((d) => {
+      const toolName = `${tp}_${d.replace(/-/g, '_')}`;
+      return `| ${bt}${toolName}${bt} | ${bt}get_patterns${bt}, ${bt}search${bt}, ${bt}capture${bt} |`;
+    })
+    .join('\n');
 
-## Agent Identity
-- Name: ${config.name}
-- Role: ${config.role}
-- Agent MCP prefix: \`${config.id}\`
+  // ─── Engine rules (strip markers — AGENTS.md embeds them inline) ───
+  const engineRules = getEngineRulesContent()
+    .replace(/<!-- soleri:engine-rules -->\n?/, '')
+    .replace(/<!-- \/soleri:engine-rules -->\n?/, '')
+    .trim();
 
-## Activation
-- Say "Hello, ${config.name}!" to activate persona behavior via \`${config.id}_core\`.
-- Say "Goodbye, ${config.name}!" to deactivate.
+  return `# ${config.name}
 
-## Domains
+## Identity
+
+You ARE **${config.name}**. ${config.role}.
+
+${config.description}
+
+This identity is permanent — not activated by greeting, not deactivated by farewell.
+Adopt this persona for every message. Your MCP tool prefix is ${bt}${tp}${bt}.
+
+**Tone:** ${config.tone ?? 'pragmatic'}
+
+**Domains:**
 ${domains}
 
-## Principles
+**Principles:**
 ${principles}
 
+## Adaptive Identity
+
+${config.name} is not a fixed-role agent. The role above is a starting point — the agent evolves as knowledge is added.
+
+When the user asks about your capabilities or you need to check what you've learned, use ${bt}${tp}_core op:activate${bt} to discover evolved capabilities.
+
+## Session Start
+
+Do NOT call any tools automatically on session start. Just greet the user in character.
+Only call ${bt}${tp}_orchestrate op:register${bt} or ${bt}${tp}_core op:activate${bt} when you actually need project context or capability discovery — not on every message.
+
+## Essential Tools
+
+| Facade | Key Ops |
+|--------|---------|
+| ${bt}${tp}_core${bt} | ${bt}health${bt}, ${bt}search${bt}, ${bt}identity${bt}, ${bt}register${bt}, ${bt}activate${bt} |
+${domainRows}
+| ${bt}${tp}_vault${bt} | ${bt}search_intelligent${bt}, ${bt}capture_knowledge${bt}, ${bt}capture_quick${bt}, ${bt}search_feedback${bt} |
+| ${bt}${tp}_vault${bt} (keeper) | ${bt}knowledge_audit${bt}, ${bt}knowledge_health${bt}, ${bt}knowledge_merge${bt}, ${bt}knowledge_reorganize${bt} |
+| ${bt}${tp}_vault${bt} (mgmt) | ${bt}vault_get${bt}, ${bt}vault_update${bt}, ${bt}vault_remove${bt}, ${bt}vault_tags${bt}, ${bt}vault_domains${bt}, ${bt}vault_recent${bt} |
+| ${bt}${tp}_curator${bt} | ${bt}curator_status${bt}, ${bt}curator_detect_duplicates${bt}, ${bt}curator_contradictions${bt}, ${bt}curator_groom_all${bt}, ${bt}curator_consolidate${bt}, ${bt}curator_health_audit${bt} |
+| ${bt}${tp}_curator${bt} (advanced) | ${bt}curator_enrich${bt}, ${bt}curator_hybrid_contradictions${bt}, ${bt}curator_entry_history${bt}, ${bt}curator_queue_stats${bt} |
+| ${bt}${tp}_plan${bt} | ${bt}create_plan${bt}, ${bt}approve_plan${bt}, ${bt}plan_split${bt}, ${bt}plan_reconcile${bt}, ${bt}plan_complete_lifecycle${bt} |
+| ${bt}${tp}_orchestrate${bt} | ${bt}orchestrate_plan${bt}, ${bt}orchestrate_execute${bt}, ${bt}orchestrate_complete${bt} |
+| ${bt}${tp}_brain${bt} | ${bt}brain_stats${bt}, ${bt}brain_feedback${bt}, ${bt}rebuild_vocabulary${bt}, ${bt}brain_strengths${bt}, ${bt}brain_recommend${bt} |
+| ${bt}${tp}_memory${bt} | ${bt}memory_search${bt}, ${bt}memory_capture${bt}, ${bt}session_capture${bt} |
+| ${bt}${tp}_control${bt} | ${bt}route_intent${bt}, ${bt}morph${bt}, ${bt}get_behavior_rules${bt}, ${bt}governance_dashboard${bt}, ${bt}governance_policy${bt} |
+| ${bt}${tp}_loop${bt} | ${bt}loop_start${bt}, ${bt}loop_iterate${bt}, ${bt}loop_status${bt}, ${bt}loop_cancel${bt} |
+| ${bt}${tp}_cognee${bt} | ${bt}cognee_search${bt}, ${bt}cognee_graph_stats${bt}, ${bt}cognee_export_status${bt} |
+| ${bt}${tp}_context${bt} | ${bt}context_extract_entities${bt}, ${bt}context_retrieve_knowledge${bt}, ${bt}context_analyze${bt} |
+| ${bt}${tp}_agency${bt} | ${bt}agency_enable${bt}, ${bt}agency_status${bt}, ${bt}agency_surface_patterns${bt}, ${bt}agency_warnings${bt}, ${bt}agency_clarify${bt} |
+| ${bt}${tp}_admin${bt} | ${bt}admin_health${bt}, ${bt}admin_tool_list${bt}, ${bt}admin_diagnostic${bt} |
+
+> Full list: ${bt}${tp}_admin op:admin_tool_list${bt}
+
 ## Skills
-- Local skills live in \`skills/<skill>/SKILL.md\`.
-- If a user explicitly names a skill, open that \`SKILL.md\` and follow it for that turn.
 
-## Setup Notes
-- This repository was scaffolded with Codex support.
-- Session model/reasoning is selected at session start and does not auto-switch per prompt.
+- Local skills live in ${bt}skills/<skill>/SKILL.md${bt}.
+- If a user explicitly names a skill, open that ${bt}SKILL.md${bt} and follow it for that turn.
+
+${engineRules}
 `;
 }

package/src/templates/claude-md-template.ts

@@ -32,6 +32,7 @@ export function generateClaudeMdTemplate(config: AgentConfig): string {
     `**Origin role:** ${config.role}`,
     `**Initial domains:** ${config.domains.join(', ')}`,
     `**Tone:** ${config.tone ?? 'pragmatic'}`,
+    ...(config.sharedVaultPath ? [`**Shared vault:** \`${config.sharedVaultPath}\``] : []),
     '',
     config.description,
     '',
@@ -65,7 +66,7 @@ export function generateClaudeMdTemplate(config: AgentConfig): string {
     // ─── Session Start ─────────────────────────────────────
     '## Session Start',
     '',
-    `On every new session: ${bt}${toolPrefix}_core op:register params:{ projectPath: "." }${bt}`,
+    `On every new session: ${bt}${toolPrefix}_orchestrate op:register params:{ projectPath: "." }${bt}`,
     '',
   ];
 
@@ -87,6 +88,16 @@ export function generateClaudeMdTemplate(config: AgentConfig): string {
     );
   }
 
+  // Domain pack facades (if any)
+  if (config.domainPacks?.length) {
+    mdLines.push('', '**Domain Pack Facades:**', '');
+    for (const ref of config.domainPacks) {
+      mdLines.push(
+        `| ${bt}${ref.name}${bt} (pack: ${bt}${ref.package}${bt}) | *custom ops — see ${bt}admin_tool_list${bt}* |`,
+      );
+    }
+  }
+
   // Engine facades — use actual tool names (standalone facades, NOT _core sub-groups)
   mdLines.push(
     // Vault — knowledge lifecycle, capture, search, management