@soleri/forge 5.14.9 → 7.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

@@ -2,26 +2,15 @@ import type { AgentConfig } from '../types.js';
 
 /**
  * Generates src/activation/activate.ts for a new agent.
- * Provides the activate/deactivate system that returns full context
- * to Claude — persona, guidelines, tool recommendations, setup status.
+ *
+ * Activation is ADAPTIVE — it discovers current capabilities at runtime
+ * (vault domains, installed packs, identity changes) rather than returning
+ * a frozen snapshot from scaffold time. PERSONA is the birth config;
+ * the activation response reflects what the agent has become.
  *
  * Uses array-joined pattern because generated code contains template literals.
  */
 export function generateActivate(config: AgentConfig): string {
-  const toolPrefix = config.id; // keep hyphens — matches MCP tool registration
-  const _marker = `${config.id}:mode`;
-
-  // Build tool recommendations from config domains
-  const toolRecLines: string[] = [];
-  for (const d of config.domains) {
-    const toolName = `${toolPrefix}_${d.replace(/-/g, '_')}`;
-    toolRecLines.push(`      { intent: 'search ${d}', facade: '${toolName}', op: 'search' },`);
-    toolRecLines.push(
-      `      { intent: '${d} patterns', facade: '${toolName}', op: 'get_patterns' },`,
-    );
-    toolRecLines.push(`      { intent: 'capture ${d}', facade: '${toolName}', op: 'capture' },`);
-  }
-
   // Build behavioral guidelines from config principles
   const guidelineLines = config.principles
     .map((p) => {
@@ -30,23 +19,34 @@ export function generateActivate(config: AgentConfig): string {
     })
     .join('\n');
 
+  // Static domain list (from scaffold time) — used as baseline
+  const configDomains = JSON.stringify(config.domains);
+
   return [
     "import { join } from 'node:path';",
+    "import { existsSync, readFileSync } from 'node:fs';",
     "import { homedir } from 'node:os';",
     "import { PERSONA } from '../identity/persona.js';",
     "import { hasAgentMarker, removeClaudeMdGlobal } from './inject-claude-md.js';",
-    "import type { Vault, Planner, Plan } from '@soleri/core';",
+    "import type { AgentRuntime } from '@soleri/core';",
     '',
     'export interface ActivationResult {',
     '  activated: boolean;',
-    '  persona: {',
+    '  origin: {',
     '    name: string;',
     '    role: string;',
     '    description: string;',
+    '  };',
+    '  current: {',
+    '    role: string;',
     '    greeting: 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[];',
-    '  tool_recommendations: Array<{ intent: string; facade: string; op: string }>;',
     '  session_instruction: string;',
     '  setup_status: {',
     '    claude_md_injected: boolean;',
@@ -67,20 +67,115 @@ export function generateActivate(config: AgentConfig): string {
     '}',
     '',
     '/**',
-    ` * Activate ${config.name} — returns full context for Claude to adopt the persona.`,
+    ` * Activate ${config.name} — discovers current capabilities and returns adaptive context.`,
+    ' *',
+    ' * PERSONA is the birth config. The activation response reflects what the agent',
+    ' * has become through installed packs, captured knowledge, and identity updates.',
     ' */',
-    'export function activateAgent(vault: Vault, projectPath: string, planner?: Planner): ActivationResult {',
-    '  // Check CLAUDE.md injection status (project-level and global)',
+    'export function activateAgent(runtime: AgentRuntime, projectPath: string): ActivationResult {',
+    '  const { vault, planner, identityManager } = runtime;',
+    '',
+    '  // ─── Setup status ──────────────────────────────────────────',
     "  const projectClaudeMd = join(projectPath, 'CLAUDE.md');",
     "  const globalClaudeMd = join(homedir(), '.claude', 'CLAUDE.md');",
     '  const claudeMdInjected = hasAgentMarker(projectClaudeMd);',
     '  const globalClaudeMdInjected = hasAgentMarker(globalClaudeMd);',
     '',
-    '  // Check vault status',
+    '  // ─── Vault stats — what the agent actually knows ──────────',
     '  const stats = vault.stats();',
     '  const vaultHasEntries = stats.totalEntries > 0;',
     '',
-    "  // Build next steps based on what's missing",
+    '  // ─── Discover domains ─────────────────────────────────────',
+    `  const configuredDomains: string[] = ${configDomains};`,
+    '  const vaultDomains = Object.keys(stats.byDomain);',
+    '',
+    '  // Merge configured + vault-discovered domains (dedup)',
+    '  const allDomains = [...new Set([...configuredDomains, ...vaultDomains])];',
+    '',
+    '  // Build capability map — entries per domain',
+    '  const capabilities = allDomains.map((d) => ({',
+    '    domain: d,',
+    '    entries: stats.byDomain[d] ?? 0,',
+    '  }));',
+    '',
+    '  // ─── Discover installed packs ─────────────────────────────',
+    '  const installedPacks: Array<{ id: string; type: string }> = [];',
+    '  try {',
+    "    const lockPath = join(projectPath, 'soleri.lock');",
+    '    if (existsSync(lockPath)) {',
+    "      const lockData = JSON.parse(readFileSync(lockPath, 'utf-8'));",
+    '      if (lockData.packs) {',
+    '        for (const [id, entry] of Object.entries(lockData.packs)) {',
+    '          installedPacks.push({ id, type: (entry as Record<string, string>).type ?? "unknown" });',
+    '        }',
+    '      }',
+    '    }',
+    '  } catch {',
+    '    // Lock file missing or corrupt — proceed without pack info',
+    '  }',
+    '',
+    '  // ─── Dynamic role — based on what the agent actually covers ─',
+    "  const currentIdentity = identityManager.getIdentity('" + config.id + "');",
+    '  const newDomains = allDomains.filter((d) => !configuredDomains.includes(d));',
+    '  let currentRole = currentIdentity?.role ?? PERSONA.role;',
+    '',
+    '  // If the agent has grown beyond its birth domains, reflect that',
+    '  if (newDomains.length > 0) {',
+    '    const formatted = newDomains.map((d) => d.replace(/-/g, " ")).join(", ");',
+    '    currentRole = `${PERSONA.role} (also covering ${formatted})`;',
+    '  }',
+    '',
+    '  // ─── Dynamic greeting ─────────────────────────────────────',
+    "  let greeting = `Hello! I'm ${PERSONA.name}.`;",
+    '  if (allDomains.length > configuredDomains.length) {',
+    "    greeting += ` I started as a ${PERSONA.role} and have expanded to also cover ${newDomains.map((d) => d.replace(/-/g, ' ')).join(', ')}.`;",
+    '  } else {',
+    '    greeting += ` ${PERSONA.role} ready to help.`;',
+    '  }',
+    '  if (stats.totalEntries > 0) {',
+    '    const domainSummary = capabilities',
+    '      .filter((c) => c.entries > 0)',
+    '      .map((c) => `${c.entries} ${c.domain.replace(/-/g, " ")}`)',
+    '      .join(", ");',
+    '    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) {',
     `    nextSteps.push('No CLAUDE.md configured — run inject_claude_md with global: true for all projects, or without for this project only');`,
@@ -88,10 +183,7 @@ export function generateActivate(config: AgentConfig): string {
     `    nextSteps.push('Global CLAUDE.md not configured — run inject_claude_md with global: true to enable activation in all projects');`,
     '  }',
     '  if (!vaultHasEntries) {',
-    "    nextSteps.push('Vault is empty — start capturing knowledge with the domain capture ops');",
-    '  }',
-    '  if (nextSteps.length === 0) {',
-    `    nextSteps.push('All set! ${config.name} is fully integrated.');`,
+    "    nextSteps.push('Vault is empty — start capturing knowledge with the domain capture ops, or install a knowledge pack with soleri pack install');",
     '  }',
     '',
     '  // Check for executing plans',
@@ -105,25 +197,32 @@ export function generateActivate(config: AgentConfig): string {
     '    nextSteps.unshift(`${executingPlans.length} plan(s) in progress — use get_plan to review`);',
     '  }',
     '',
+    '  if (nextSteps.length === 0) {',
+    `    nextSteps.push('All set! ${config.name} is ready.');`,
+    '  }',
+    '',
     '  return {',
     '    activated: true,',
-    '    persona: {',
+    '    origin: {',
     '      name: PERSONA.name,',
     '      role: PERSONA.role,',
     '      description: PERSONA.description,',
-    '      greeting: PERSONA.greeting,',
+    '    },',
+    '    current: {',
+    '      role: currentRole,',
+    '      greeting,',
+    '      domains: allDomains,',
+    '      capabilities,',
+    '      installed_packs: installedPacks,',
+    '      what_you_can_do: whatYouCanDo,',
+    '      growth_suggestions: growthSuggestions,',
     '    },',
     '    guidelines: [',
     guidelineLines,
     '    ],',
-    '    tool_recommendations: [',
-    `      { intent: 'health check', facade: '${toolPrefix}_core', op: 'health' },`,
-    `      { intent: 'search all', facade: '${toolPrefix}_core', op: 'search' },`,
-    `      { intent: 'vault stats', facade: '${toolPrefix}_core', op: 'vault_stats' },`,
-    ...toolRecLines,
-    '    ],',
-    `    session_instruction: 'You are now ' + PERSONA.name + ', a ' + PERSONA.role + '. Stay in character for the ENTIRE session. ' +`,
-    `      'Reference patterns from the knowledge vault. Provide concrete examples. Flag anti-patterns with severity.',`,
+    "    session_instruction: `You are ${PERSONA.name}. Your origin role is ${PERSONA.role}, but you have grown — your current capabilities span: ${allDomains.join(', ')}. ` +",
+    "      'Adapt your expertise to match your actual knowledge. ' +",
+    "      'Reference patterns from the knowledge vault. Provide concrete examples. Flag anti-patterns with severity.',",
     '    setup_status: {',
     '      claude_md_injected: claudeMdInjected,',
     '      global_claude_md_injected: globalClaudeMdInjected,',
@@ -139,7 +238,6 @@ export function generateActivate(config: AgentConfig): string {
     ` * Deactivate ${config.name} — drops persona and cleans up CLAUDE.md sections.`,
     ' */',
     'export function deactivateAgent(): DeactivationResult {',
-    '  // Remove agent sections from global CLAUDE.md on deactivation',
     '  const globalResult = removeClaudeMdGlobal();',
     '  return {',
     '    deactivated: true,',