@soleri/forge 5.14.9 → 7.0.0

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

@@ -29,9 +29,10 @@ export function generateClaudeMdTemplate(config: AgentConfig): string {
     // ─── Identity ──────────────────────────────────────────
     `## ${config.name}`,
     '',
-    `**Role:** ${config.role}`,
-    `**Domains:** ${config.domains.join(', ')}`,
+    `**Origin role:** ${config.role}`,
+    `**Initial domains:** ${config.domains.join(', ')}`,
     `**Tone:** ${config.tone ?? 'pragmatic'}`,
+    ...(config.sharedVaultPath ? [`**Shared vault:** \`${config.sharedVaultPath}\``] : []),
     '',
     config.description,
     '',
@@ -39,19 +40,33 @@ export function generateClaudeMdTemplate(config: AgentConfig): string {
     ...config.principles.map((p) => `- ${p}`),
     '',
 
+    // ─── Adaptive Identity ──────────────────────────────────
+    '## Adaptive Identity',
+    '',
+    `${config.name} is not a fixed-role agent. The origin role above is a starting point — the agent evolves as knowledge is added.`,
+    '',
+    '**On activation**, the agent discovers its current capabilities by checking:',
+    '- Vault domains (what knowledge actually exists)',
+    '- Installed packs (what was added after creation)',
+    '- Identity updates (any role changes via `op:update_identity`)',
+    '',
+    '**Use the `current` field** from the activation response — not `origin` — to determine how to present yourself.',
+    'If you have grown beyond your origin role, say so. Your greeting and expertise should reflect what you actually know.',
+    '',
+
     // ─── Activation ────────────────────────────────────────
     '## Activation',
     '',
     `**Activate:** "Hello, ${config.name}!" → ${bt}${toolPrefix}_core op:activate params:{ projectPath: "." }${bt}`,
     `**Deactivate:** "Goodbye, ${config.name}!" → ${bt}${toolPrefix}_core op:activate params:{ deactivate: true }${bt}`,
     '',
-    'On activation, adopt the returned persona. Stay in character until deactivated.',
+    'On activation, read the `current` field to discover your evolved role, then adopt that persona for the session.',
     '',
 
     // ─── 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}`,
     '',
   ];
 
@@ -73,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

package/src/templates/entry-point.ts

@@ -1,5 +1,21 @@
 import type { AgentConfig } from '../types.js';
 
+/** Generate vault connection code for linked vaults. */
+function generateVaultConnections(config: AgentConfig): string {
+  if (!config.vaults?.length) return '';
+  const lines = ['', '  // ─── Linked vaults ──────────────────────────────────────────────'];
+  for (const v of config.vaults) {
+    lines.push(
+      `  try { runtime.vaultManager.connect('${v.name}', '${v.path}', ${v.priority ?? 0.5}); } catch { /* already connected or unavailable */ }`,
+    );
+  }
+  lines.push(
+    `  console.error(\`[\${tag}] Connected ${config.vaults.length} linked vault(s): ${config.vaults.map((v) => v.name).join(', ')}\`);`,
+    '',
+  );
+  return lines.join('\n');
+}
+
 /**
  * Generate the main index.ts entry point for the agent.
  *
@@ -9,6 +25,7 @@ import type { AgentConfig } from '../types.js';
  */
 export function generateEntryPoint(config: AgentConfig): string {
   const domainsLiteral = JSON.stringify(config.domains);
+  const hasDomainPacks = config.domainPacks && config.domainPacks.length > 0;
 
   return `#!/usr/bin/env node
 
@@ -24,12 +41,14 @@ import {
   registerAllFacades,
   seedDefaultPlaybooks,
   wrapWithMiddleware,
+  CapabilityRegistry,
+  loadAllFlows,
 } from '@soleri/core';
-import type { OpDefinition, AgentExtensions } from '@soleri/core';
+import type { OpDefinition, AgentExtensions } from '@soleri/core';${hasDomainPacks ? `\nimport { loadDomainPacksFromConfig, createPackRuntime } 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';
+import { injectClaudeMd, injectClaudeMdGlobal, hasAgentMarker, injectAgentsMd, injectAgentsMdGlobal, hasAgentMarkerInAgentsMd } from './activation/inject-claude-md.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -37,11 +56,11 @@ async function main(): Promise<void> {
   // ─── Runtime — vault, brain, planner, curator, LLM, key pools ───
   const runtime = createAgentRuntime({
     agentId: '${config.id}',
-    dataDir: join(__dirname, 'intelligence', 'data'),
+    dataDir: join(__dirname, 'intelligence', 'data'),${config.sharedVaultPath ? `\n    sharedVaultPath: '${config.sharedVaultPath}',` : ''}${config.cognee ? `\n    cognee: true,` : ''}
   });
 
   const tag = PERSONA.name.toLowerCase();
-
+${generateVaultConnections(config)}
   // Seed built-in playbooks (idempotent)
   const seedResult = seedDefaultPlaybooks(runtime.vault);
   if (seedResult.seeded > 0) {
@@ -102,7 +121,7 @@ async function main(): Promise<void> {
             changeReason: 'Initial identity seeded from PERSONA',
           });
         }
-        return activateAgent(runtime.vault, (params.projectPath as string) ?? '.', runtime.planner);
+        return activateAgent(runtime, (params.projectPath as string) ?? '.');
       },
     },
     {
@@ -120,9 +139,24 @@ async function main(): Promise<void> {
         return injectClaudeMd((params.projectPath as string) ?? '.');
       },
     },
+    {
+      name: 'inject_agents_md',
+      description: 'Inject agent sections into AGENTS.md — project-level or global (~/.config/opencode/AGENTS.md). For OpenCode and Codex. Idempotent.',
+      auth: 'write',
+      schema: z.object({
+        projectPath: z.string().optional().default('.'),
+        global: z.boolean().optional().describe('If true, inject into ~/.config/opencode/AGENTS.md instead of project-level'),
+      }),
+      handler: async (params) => {
+        if (params.global) {
+          return injectAgentsMdGlobal();
+        }
+        return injectAgentsMd((params.projectPath as string) ?? '.');
+      },
+    },
     {
       name: 'setup',
-      description: 'Check setup status — CLAUDE.md configured? Vault has entries? What to do next?',
+      description: 'Check setup status — CLAUDE.md configured? AGENTS.md configured? Vault has entries? What to do next?',
       auth: 'read',
       schema: z.object({
         projectPath: z.string().optional().default('.'),
@@ -135,12 +169,19 @@ async function main(): Promise<void> {
 
         const projectClaudeMd = joinPath(projectPath, 'CLAUDE.md');
         const globalClaudeMd = joinPath(homedir(), '.claude', 'CLAUDE.md');
+        const projectAgentsMd = joinPath(projectPath, 'AGENTS.md');
+        const globalAgentsMd = joinPath(homedir(), '.config', 'opencode', 'AGENTS.md');
 
         const projectExists = existsSync(projectClaudeMd);
         const projectHasAgent = hasAgentMarker(projectClaudeMd);
         const globalExists = existsSync(globalClaudeMd);
         const globalHasAgent = hasAgentMarker(globalClaudeMd);
 
+        const agentsMdProjectExists = existsSync(projectAgentsMd);
+        const agentsMdProjectHasAgent = hasAgentMarkerInAgentsMd(projectAgentsMd);
+        const agentsMdGlobalExists = existsSync(globalAgentsMd);
+        const agentsMdGlobalHasAgent = hasAgentMarkerInAgentsMd(globalAgentsMd);
+
         const s = runtime.vault.stats();
 
         const recommendations: string[] = [];
@@ -149,6 +190,9 @@ async function main(): Promise<void> {
         } else if (!globalHasAgent) {
           recommendations.push('Global ~/.claude/CLAUDE.md not configured — run inject_claude_md with global: true to enable in all projects');
         }
+        if (!agentsMdGlobalHasAgent && !agentsMdProjectHasAgent) {
+          recommendations.push('No AGENTS.md configured — run inject_agents_md for OpenCode/Codex support');
+        }
         if (s.totalEntries === 0) {
           recommendations.push('Vault is empty — add intelligence data or capture knowledge via domain facades');
         }
@@ -193,6 +237,10 @@ async function main(): Promise<void> {
             project: { exists: projectExists, has_agent_section: projectHasAgent },
             global: { exists: globalExists, has_agent_section: globalHasAgent },
           },
+          agents_md: {
+            project: { exists: agentsMdProjectExists, has_agent_section: agentsMdProjectHasAgent },
+            global: { exists: agentsMdGlobalExists, has_agent_section: agentsMdGlobalHasAgent },
+          },
           vault: { entries: s.totalEntries, domains: Object.keys(s.byDomain) },
           hooks: hookStatus,
           recommendations,
@@ -209,7 +257,43 @@ async function main(): Promise<void> {
     ops: agentOps,
   };
 
-  const domainFacades = createDomainFacades(runtime, '${config.id}', ${domainsLiteral});
+${
+  hasDomainPacks
+    ? `  // ─── Domain packs ─────────────────────────────────────────────
+  const domainPacks = await loadDomainPacksFromConfig(${JSON.stringify(config.domainPacks)});
+  console.error(\`[\${tag}] Loaded \${domainPacks.length} domain packs\`);
+  for (const pack of domainPacks) {
+    if (pack.onActivate) await pack.onActivate(runtime);
+  }
+
+  // ─── Capability Registry ─────────────────────────────────────
+  const capabilityRegistry = new CapabilityRegistry();
+  const packRuntime = createPackRuntime(runtime);
+
+  // Register domain pack capabilities
+  for (const pack of domainPacks) {
+    if (pack.capabilities) {
+      const handlers = pack.capabilities(packRuntime);
+      // Use pack manifest capabilities if available, otherwise derive from handler keys
+      const definitions = (pack as Record<string, unknown>).manifest
+        ? ((pack as Record<string, unknown>).manifest as { capabilities?: Array<{ id: string; description: string; provides: string[]; requires: string[] }> }).capabilities ?? []
+        : [...handlers.keys()].map(id => ({ id, description: id, provides: [], requires: [] }));
+      capabilityRegistry.registerPack(pack.name, definitions, handlers, 50);
+    }
+  }
+
+  // Validate flows against installed capabilities
+  const flows = loadAllFlows();
+  for (const flow of flows) {
+    const validation = capabilityRegistry.validateFlow(flow);
+    if (validation.missing.length > 0) {
+      console.error(\`[\${tag}] Flow \${flow.id}: \${validation.missing.length} capabilities degraded (\${validation.missing.join(', ')})\`);
+    }
+  }
+  console.error(\`[\${tag}] Capability registry: \${capabilityRegistry.size} capabilities from \${capabilityRegistry.packCount} pack(s)\`);
+`
+    : ''
+}  const domainFacades = createDomainFacades(runtime, '${config.id}', ${domainsLiteral}${hasDomainPacks ? `, domainPacks` : ''});
 
   // ─── User extensions (auto-discovered from src/extensions/) ────
   let extensions: AgentExtensions = {};

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

@@ -44,6 +44,10 @@ export function generateInjectClaudeMd(config: AgentConfig): string {
     '  if (existing.includes(startMarker)) {',
     '    const startIdx = existing.indexOf(startMarker);',
     '    const endIdx = existing.indexOf(endMarker);',
+    '    if (endIdx !== -1) {',
+    '      const currentBlock = existing.slice(startIdx, endIdx + endMarker.length);',
+    "      if (currentBlock === content.trim()) return 'skipped';",
+    '    }',
     '    if (endIdx === -1) {',
     "      const updated = existing.slice(0, startIdx) + content + '\\n' + existing.slice(startIdx + startMarker.length);",
     "      writeFileSync(filePath, updated, 'utf-8');",
@@ -166,5 +170,54 @@ export function generateInjectClaudeMd(config: AgentConfig): string {
     "  const content = readFileSync(filePath, 'utf-8');",
     "  return content.includes('<!-- ' + getEngineRulesMarker() + ' -->');",
     '}',
+    '',
+    '// ─── AGENTS.md support (OpenCode, Codex) ──────────────────────',
+    '',
+    '/**',
+    ' * Inject agent sections into a project AGENTS.md.',
+    ' * Same engine rules + agent block as CLAUDE.md, targeting AGENTS.md instead.',
+    ' * OpenCode reads AGENTS.md as its primary instruction file.',
+    ' */',
+    'export function injectAgentsMd(projectPath: string): InjectResult {',
+    "  return injectIntoFile(join(projectPath, 'AGENTS.md'));",
+    '}',
+    '',
+    '/**',
+    ' * Inject into the global ~/.config/opencode/AGENTS.md.',
+    " * Creates ~/.config/opencode/ directory if it doesn't exist.",
+    ' * This makes the activation phrase work in any OpenCode project.',
+    ' */',
+    'export function injectAgentsMdGlobal(): InjectResult {',
+    "  const opencodeDir = join(homedir(), '.config', 'opencode');",
+    '  if (!existsSync(opencodeDir)) {',
+    '    mkdirSync(opencodeDir, { recursive: true });',
+    '  }',
+    "  return injectIntoFile(join(opencodeDir, 'AGENTS.md'));",
+    '}',
+    '',
+    '/**',
+    ' * Remove agent section from a project AGENTS.md.',
+    ' */',
+    'export function removeAgentsMd(projectPath: string): { removed: boolean; path: string } {',
+    "  const filePath = join(projectPath, 'AGENTS.md');",
+    '  return { removed: removeBlock(filePath, getClaudeMdMarker()), path: filePath };',
+    '}',
+    '',
+    '/**',
+    ' * Remove agent section from the global ~/.config/opencode/AGENTS.md.',
+    ' */',
+    'export function removeAgentsMdGlobal(): { removed: boolean; path: string } {',
+    "  const filePath = join(homedir(), '.config', 'opencode', 'AGENTS.md');",
+    '  return { removed: removeBlock(filePath, getClaudeMdMarker()), path: filePath };',
+    '}',
+    '',
+    '/**',
+    ' * Check if the agent marker exists in an AGENTS.md file.',
+    ' */',
+    'export function hasAgentMarkerInAgentsMd(filePath: string): boolean {',
+    '  if (!existsSync(filePath)) return false;',
+    "  const content = readFileSync(filePath, 'utf-8');",
+    `  return content.includes('<!-- ${marker} -->');`,
+    '}',
   ].join('\n');
 }

package/src/templates/package-json.ts

@@ -2,7 +2,7 @@ import type { AgentConfig } from '../types.js';
 
 export function generatePackageJson(config: AgentConfig): string {
   const pkg = {
-    name: `${config.id}-mcp`,
+    name: config.id,
     version: '1.0.0',
     description: config.description,
     type: 'module',
@@ -31,6 +31,9 @@ export function generatePackageJson(config: AgentConfig): string {
       '@soleri/core': '^2.0.0',
       zod: '^3.24.2',
       ...(config.telegram ? { grammy: '^1.35.0' } : {}),
+      ...(config.domainPacks?.length
+        ? Object.fromEntries(config.domainPacks.map((pack) => [pack.package, pack.version ?? '*']))
+        : {}),
     },
     optionalDependencies: {
       '@anthropic-ai/sdk': '^0.39.0',

package/src/templates/readme.ts

@@ -4,6 +4,7 @@ import type { AgentConfig } from '../types.js';
  * Generate a README.md for the scaffolded agent.
  */
 export function generateReadme(config: AgentConfig): string {
+  const skillCount = config.skills?.length ?? 17;
   const setupTarget = config.setupTarget ?? 'claude';
   const claudeSetup = setupTarget === 'claude' || setupTarget === 'both';
   const codexSetup = setupTarget === 'codex' || setupTarget === 'both';
@@ -78,10 +79,10 @@ export function generateReadme(config: AgentConfig): string {
 
   const skillsLead =
     claudeSetup && codexSetup
-      ? `${config.name} ships with 17 structured workflow skills. In Claude Code they are invocable via \`/<skill-name>\`; in Codex they are available via generated AGENTS.md + local skill files.`
+      ? `${config.name} ships with ${skillCount} structured workflow skills. In Claude Code they are invocable via \`/<skill-name>\`; in Codex they are available via generated AGENTS.md + local skill files.`
       : claudeSetup
-        ? `${config.name} ships with 17 structured workflow skills, invocable via \`/<skill-name>\` in Claude Code:`
-        : `${config.name} ships with 17 structured workflow skills, available via generated AGENTS.md + local skill files in Codex:`;
+        ? `${config.name} ships with ${skillCount} structured workflow skills, invocable via \`/<skill-name>\` in Claude Code:`
+        : `${config.name} ships with ${skillCount} structured workflow skills, available via generated AGENTS.md + local skill files in Codex:`;
 
   const skillsInstallNote =
     claudeSetup && codexSetup

package/src/templates/setup-script.ts

@@ -6,10 +6,15 @@ import type { AgentConfig } from '../types.js';
  */
 export function generateSetupScript(config: AgentConfig): string {
   const setupTarget = config.setupTarget ?? 'claude';
-  const claudeSetup = setupTarget === 'claude' || setupTarget === 'both';
-  const codexSetup = setupTarget === 'codex' || setupTarget === 'both';
-  const hostLabel =
-    claudeSetup && codexSetup ? 'Claude Code + Codex' : claudeSetup ? 'Claude Code' : 'Codex';
+  const claudeSetup = setupTarget === 'claude' || setupTarget === 'both' || setupTarget === 'all';
+  const codexSetup = setupTarget === 'codex' || setupTarget === 'both' || setupTarget === 'all';
+  const opencodeSetup = setupTarget === 'opencode' || setupTarget === 'all';
+  const hostParts = [
+    ...(claudeSetup ? ['Claude Code'] : []),
+    ...(codexSetup ? ['Codex'] : []),
+    ...(opencodeSetup ? ['OpenCode'] : []),
+  ];
+  const hostLabel = hostParts.join(' + ');
 
   const claudeSection = claudeSetup
     ? `
@@ -195,6 +200,103 @@ if [ -d "$SKILLS_DIR" ]; then
   done
   echo "[ok] Codex skills: $skill_installed installed, $skill_skipped already present"
 fi
+`
+    : '';
+
+  const opencodeSection = opencodeSetup
+    ? `
+# Check and install OpenCode (Soleri fork with title branding)
+if ! command -v opencode &>/dev/null; then
+  echo ""
+  INSTALLED=false
+  # Try Go install from Soleri fork (supports title branding)
+  if command -v go &>/dev/null; then
+    echo "Installing OpenCode (Soleri fork) via go install..."
+    if go install github.com/adrozdenko/opencode@latest 2>/dev/null; then
+      if command -v opencode &>/dev/null; then
+        echo "[ok] OpenCode installed from Soleri fork ($(opencode --version 2>/dev/null || echo 'installed'))"
+        INSTALLED=true
+      fi
+    fi
+  fi
+  # Fallback: upstream npm package (no title branding)
+  if [ "$INSTALLED" = false ]; then
+    echo "Installing OpenCode via npm (upstream — title branding requires Go)..."
+    npm install -g opencode-ai
+    if command -v opencode &>/dev/null; then
+      echo "[ok] OpenCode installed ($(opencode --version 2>/dev/null || echo 'unknown version'))"
+    else
+      echo ""
+      echo "Warning: Could not install OpenCode automatically."
+      echo "Install manually using one of:"
+      echo "  go install github.com/adrozdenko/opencode@latest  (recommended — includes title branding)"
+      echo "  npm install -g opencode-ai  (upstream)"
+      echo ""
+    fi
+  fi
+else
+  echo "[ok] OpenCode found ($(opencode --version 2>/dev/null || echo 'installed'))"
+fi
+
+# Register MCP server with OpenCode
+echo ""
+echo "Registering ${config.name} with OpenCode..."
+OPENCODE_CONFIG="$HOME/.opencode.json"
+AGENT_DIST="$AGENT_DIR/dist/index.js"
+
+OPENCODE_CONFIG="$OPENCODE_CONFIG" AGENT_NAME="$AGENT_NAME" AGENT_DIST="$AGENT_DIST" node <<'NODE'
+const fs = require('node:fs');
+const path = process.env.OPENCODE_CONFIG;
+const agentName = process.env.AGENT_NAME;
+const distPath = process.env.AGENT_DIST;
+
+let config = {};
+if (fs.existsSync(path)) {
+  try {
+    const raw = fs.readFileSync(path, 'utf-8');
+    const stripped = raw.replace(/^\\s*\\/\\/.*$/gm, '');
+    config = JSON.parse(stripped);
+  } catch {
+    config = {};
+  }
+}
+
+if (!config.mcp || typeof config.mcp !== 'object') {
+  config.mcp = {};
+}
+
+config.mcp[agentName] = {
+  type: 'local',
+  command: ['node', distPath],
+  enabled: true,
+};
+
+fs.writeFileSync(path, JSON.stringify(config, null, 2) + '\\n', 'utf-8');
+NODE
+echo "[ok] Registered ${config.name} as MCP server (OpenCode)"
+
+# Create launcher script — type "${config.id}" to start OpenCode
+LAUNCHER_PATH="/usr/local/bin/$AGENT_NAME"
+LAUNCHER_CONTENT="#!/usr/bin/env bash
+# Soleri agent launcher — starts OpenCode with $AGENT_NAME MCP agent
+cd \\"$AGENT_DIR\\" || exit 1
+exec opencode \\"\\$@\\""
+
+if [ -w "/usr/local/bin" ]; then
+  echo "$LAUNCHER_CONTENT" > "$LAUNCHER_PATH"
+  chmod +x "$LAUNCHER_PATH"
+  echo "[ok] Launcher created: type \\"${config.id}\\" to start OpenCode"
+else
+  echo "$LAUNCHER_CONTENT" > "$AGENT_DIR/scripts/$AGENT_NAME"
+  chmod +x "$AGENT_DIR/scripts/$AGENT_NAME"
+  if command -v sudo &>/dev/null; then
+    sudo ln -sf "$AGENT_DIR/scripts/$AGENT_NAME" "$LAUNCHER_PATH" 2>/dev/null && \\
+      echo "[ok] Launcher created: type \\"${config.id}\\" to start OpenCode" || \\
+      echo "Note: Run 'sudo ln -sf $AGENT_DIR/scripts/$AGENT_NAME $LAUNCHER_PATH' to enable \\"${config.id}\\" command"
+  else
+    echo "Note: Add $AGENT_DIR/scripts to PATH, or symlink $AGENT_DIR/scripts/$AGENT_NAME to /usr/local/bin/$AGENT_NAME"
+  fi
+fi
 `
     : '';
 
@@ -207,6 +309,9 @@ fi
       ? ['echo "  - Start a new Claude Code session (or restart if one is open)"']
       : []),
     ...(codexSetup ? ['echo "  - Start a new Codex session (or restart if one is open)"'] : []),
+    ...(opencodeSetup
+      ? ['echo "  - Start a new OpenCode session (or restart if one is open)"']
+      : []),
     `echo "  - Say: \\"Hello, ${config.name}!\\""`,
     'echo ""',
     `echo "${config.name} is ready."`,
@@ -248,6 +353,7 @@ fi
 ${claudeSection}
 ${hookPackSection}
 ${codexSection}
+${opencodeSection}
 ${nextSteps}
 `;
 }