@soleri/cli 1.9.0 → 1.10.1

package/src/prompts/archetypes.ts

@@ -9,6 +9,7 @@ export interface Archetype {
   value: string;
   label: string;
   hint: string;
+  tier: 'free' | 'premium';
   defaults: {
     role: string;
     description: string;
@@ -25,6 +26,7 @@ export const ARCHETYPES: Archetype[] = [
     value: 'code-reviewer',
     label: 'Code Reviewer',
     hint: 'Catches bugs, enforces patterns, reviews PRs before merge',
+    tier: 'free',
     defaults: {
       role: 'Catches bugs, enforces code patterns, and reviews pull requests before merge',
       description:
@@ -32,17 +34,12 @@ export const ARCHETYPES: Archetype[] = [
       domains: ['code-review', 'architecture'],
       principles: [
         'Actionable feedback only',
+        'Readable over clever',
+        'Small PR scope',
         'Respect existing patterns',
-        'Simplicity over cleverness',
-      ],
-      skills: [
-        'writing-plans',
-        'executing-plans',
-        'code-patrol',
-        'fix-and-learn',
-        'second-opinion',
       ],
-      tone: 'pragmatic',
+      skills: ['code-patrol', 'fix-and-learn', 'second-opinion'],
+      tone: 'mentor',
       greetingTemplate: (name) =>
         `Hello! I'm ${name}. Drop a PR link or paste code — I'll review it for bugs, patterns, and quality.`,
     },
@@ -51,6 +48,7 @@ export const ARCHETYPES: Archetype[] = [
     value: 'security-auditor',
     label: 'Security Auditor',
     hint: 'OWASP Top 10, dependency scanning, secrets detection',
+    tier: 'free',
     defaults: {
       role: 'Identifies vulnerabilities and enforces secure coding practices',
       description:
@@ -61,14 +59,9 @@ export const ARCHETYPES: Archetype[] = [
         'Fail closed, not open',
         'Zero trust by default',
         'Least privilege always',
+        'Defense in depth',
       ],
-      skills: [
-        'writing-plans',
-        'executing-plans',
-        'code-patrol',
-        'fix-and-learn',
-        'vault-navigator',
-      ],
+      skills: ['code-patrol', 'fix-and-learn', 'vault-navigator'],
       tone: 'precise',
       greetingTemplate: (name) =>
         `Hello! I'm ${name}. I help identify vulnerabilities and enforce secure coding practices across your codebase.`,
@@ -78,25 +71,20 @@ export const ARCHETYPES: Archetype[] = [
     value: 'api-architect',
     label: 'API Architect',
     hint: 'REST/GraphQL design, contract validation, versioning',
+    tier: 'free',
     defaults: {
       role: 'Designs and validates APIs for consistency, usability, and correctness',
       description:
         'This agent reviews API designs for RESTful conventions, GraphQL best practices, versioning strategy, error handling, pagination patterns, and contract consistency. It catches breaking changes before they ship.',
       domains: ['api-design', 'architecture'],
       principles: [
-        'Convention over configuration',
+        'Backward compatibility by default',
+        'Consumer-driven contracts',
         'Design for the consumer, not the implementer',
-        'Respect existing patterns',
         'Every migration must be reversible',
       ],
-      skills: [
-        'writing-plans',
-        'executing-plans',
-        'vault-navigator',
-        'vault-capture',
-        'second-opinion',
-      ],
-      tone: 'mentor',
+      skills: ['vault-navigator', 'vault-capture', 'second-opinion'],
+      tone: 'pragmatic',
       greetingTemplate: (name) =>
         `Hello! I'm ${name}. Share your API design or schema — I'll review it for consistency, usability, and best practices.`,
     },
@@ -105,6 +93,7 @@ export const ARCHETYPES: Archetype[] = [
     value: 'test-engineer',
     label: 'Test Engineer',
     hint: 'Test generation, coverage analysis, TDD workflow',
+    tier: 'free',
     defaults: {
       role: 'Generates tests, analyzes coverage, and enforces test-driven development',
       description:
@@ -112,18 +101,12 @@ export const ARCHETYPES: Archetype[] = [
       domains: ['testing', 'code-review'],
       principles: [
         'Test everything that can break',
+        'Deterministic tests only',
+        'Test at boundaries, not internals',
         'Simplicity over cleverness',
-        'Actionable feedback only',
-        'Respect existing patterns',
       ],
-      skills: [
-        'writing-plans',
-        'executing-plans',
-        'test-driven-development',
-        'fix-and-learn',
-        'code-patrol',
-      ],
-      tone: 'pragmatic',
+      skills: ['test-driven-development', 'fix-and-learn', 'code-patrol'],
+      tone: 'mentor',
       greetingTemplate: (name) =>
         `Hello! I'm ${name}. Point me at code that needs tests — I'll generate comprehensive suites and identify coverage gaps.`,
     },
@@ -132,6 +115,7 @@ export const ARCHETYPES: Archetype[] = [
     value: 'devops-pilot',
     label: 'DevOps Pilot',
     hint: 'CI/CD pipelines, infrastructure, deployment automation',
+    tier: 'free',
     defaults: {
       role: 'Manages CI/CD pipelines, infrastructure, and deployment automation',
       description:
@@ -139,17 +123,11 @@ export const ARCHETYPES: Archetype[] = [
       domains: ['devops', 'architecture'],
       principles: [
         'Automate everything repeatable',
-        'Graceful degradation over hard failures',
+        'Infrastructure as code',
+        'Blast radius awareness',
         'Observability built in from day one',
-        'Convention over configuration',
-      ],
-      skills: [
-        'writing-plans',
-        'executing-plans',
-        'vault-navigator',
-        'fix-and-learn',
-        'knowledge-harvest',
       ],
+      skills: ['vault-navigator', 'fix-and-learn', 'knowledge-harvest'],
       tone: 'pragmatic',
       greetingTemplate: (name) =>
         `Hello! I'm ${name}. I help with CI/CD, infrastructure, and deployment — describe your setup or issue.`,
@@ -159,24 +137,19 @@ export const ARCHETYPES: Archetype[] = [
     value: 'database-architect',
     label: 'Database Architect',
     hint: 'Schema design, migrations, query optimization',
+    tier: 'free',
     defaults: {
       role: 'Designs database schemas, manages migrations, and optimizes queries',
       description:
         'This agent reviews database designs for normalization, indexing strategy, migration safety, query performance, and data integrity. It supports SQL and NoSQL patterns.',
       domains: ['database', 'performance'],
       principles: [
+        'Schema evolution over breaking changes',
+        'Query performance first',
         'Every migration must be reversible',
         'Convention over configuration',
-        'Test everything that can break',
-        'Simplicity over cleverness',
-      ],
-      skills: [
-        'writing-plans',
-        'executing-plans',
-        'vault-navigator',
-        'vault-capture',
-        'knowledge-harvest',
       ],
+      skills: ['vault-navigator', 'vault-capture', 'knowledge-harvest'],
       tone: 'precise',
       greetingTemplate: (name) =>
         `Hello! I'm ${name}. Share your schema, migration, or query — I'll review it for correctness and performance.`,
@@ -186,6 +159,7 @@ export const ARCHETYPES: Archetype[] = [
     value: 'full-stack',
     label: 'Full-Stack Assistant',
     hint: 'General-purpose dev helper across the entire stack',
+    tier: 'free',
     defaults: {
       role: 'A general-purpose development assistant across the full stack',
       description:
@@ -193,20 +167,177 @@ export const ARCHETYPES: Archetype[] = [
       domains: ['code-review', 'testing', 'architecture'],
       principles: [
         'Simplicity over cleverness',
+        'Progressive enhancement',
         'Test everything that can break',
         'Respect existing patterns',
       ],
-      skills: [
-        'writing-plans',
-        'executing-plans',
-        'test-driven-development',
-        'code-patrol',
-        'fix-and-learn',
-        'vault-navigator',
-      ],
+      skills: ['test-driven-development', 'code-patrol', 'fix-and-learn', 'vault-navigator'],
       tone: 'mentor',
       greetingTemplate: (name) =>
         `Hello! I'm ${name}. I help across the full stack — frontend, backend, testing, deployment. What are you working on?`,
     },
   },
+  {
+    value: 'accessibility-guardian',
+    label: 'Accessibility Guardian',
+    hint: 'WCAG compliance, semantic HTML, keyboard navigation audits',
+    tier: 'free',
+    defaults: {
+      role: 'Audits code for WCAG compliance and accessibility best practices',
+      description:
+        'This agent reviews components and pages for accessibility issues including WCAG 2.1 violations, missing ARIA labels, keyboard navigation gaps, color contrast failures, and semantic HTML problems. It provides fix suggestions with severity ratings.',
+      domains: ['accessibility', 'code-review'],
+      principles: [
+        'WCAG compliance is non-negotiable',
+        'Semantic HTML before ARIA',
+        'Keyboard navigation for every interaction',
+        'Actionable feedback only',
+      ],
+      skills: ['code-patrol', 'second-opinion'],
+      tone: 'precise',
+      greetingTemplate: (name) =>
+        `Hello! I'm ${name}. I audit your code for accessibility — WCAG compliance, keyboard navigation, screen reader support, and more.`,
+    },
+  },
+  {
+    value: 'documentation-writer',
+    label: 'Documentation Writer',
+    hint: 'Technical docs, API references, example-driven guides',
+    tier: 'free',
+    defaults: {
+      role: 'Creates and maintains clear, example-driven technical documentation',
+      description:
+        'This agent helps write and maintain technical documentation including API references, getting-started guides, architecture docs, and changelogs. It follows docs-as-code practices and ensures every concept has a working example.',
+      domains: ['documentation', 'developer-experience'],
+      principles: [
+        'Clarity over completeness',
+        'Every concept needs an example',
+        'Docs rot faster than code — keep current',
+        'Design for the consumer, not the implementer',
+      ],
+      skills: ['knowledge-harvest', 'vault-navigator'],
+      tone: 'mentor',
+      greetingTemplate: (name) =>
+        `Hello! I'm ${name}. I help write and maintain clear, example-driven documentation. What needs documenting?`,
+    },
+  },
+
+  // ─── Premium Archetypes ──────────────────────────────────────────
+  {
+    value: 'design-system-architect',
+    label: 'Design System Architect',
+    hint: 'Tokens, component APIs, accessibility, atomic design hierarchy',
+    tier: 'premium',
+    defaults: {
+      role: 'Designs and enforces design systems with semantic tokens, component APIs, and accessibility baselines',
+      description:
+        'This agent architects design systems end-to-end: semantic token hierarchies, component variant APIs, atomic design classification, spacing and typography scales, color contrast enforcement, and cross-platform consistency. It bridges design and engineering with a token-first methodology.',
+      domains: ['architecture', 'accessibility', 'code-review', 'design-tokens', 'frontend'],
+      principles: [
+        'Semantic tokens over primitives',
+        'Component variant enum over boolean props',
+        'Atomic design classification for component hierarchy',
+        'Token enforcement: blocked then forbidden then preferred',
+        'Respect existing design system patterns',
+        'Every component needs accessibility baseline',
+      ],
+      skills: ['code-patrol', 'vault-navigator', 'vault-capture', 'knowledge-harvest'],
+      tone: 'precise',
+      greetingTemplate: (name) =>
+        `Hello! I'm ${name}. I architect design systems — tokens, component APIs, accessibility, and cross-platform consistency. Show me your system or describe what you need.`,
+    },
+  },
+  {
+    value: 'frontend-craftsman',
+    label: 'Frontend Craftsman',
+    hint: 'Stack-aware implementation, UX patterns, performance budgets, accessibility',
+    tier: 'premium',
+    defaults: {
+      role: 'Builds production-grade frontends with stack-specific expertise, UX-informed structure, and performance discipline',
+      description:
+        'This agent combines deep stack knowledge (React, Next.js, Vue, Svelte, Flutter, SwiftUI) with UX design principles, performance budgets, and accessibility-first development. It provides implementation guidance tailored to your specific framework and UI patterns.',
+      domains: ['code-review', 'testing', 'performance', 'accessibility', 'frontend'],
+      principles: [
+        'Stack-aware implementation over generic advice',
+        'UX patterns inform code structure',
+        'Performance budget before feature scope',
+        'Accessible by default, not bolted on after',
+        'Convention over configuration',
+      ],
+      skills: ['test-driven-development', 'code-patrol', 'fix-and-learn', 'vault-navigator'],
+      tone: 'mentor',
+      greetingTemplate: (name) =>
+        `Hello! I'm ${name}. I build production-grade frontends with stack-specific expertise, performance discipline, and accessibility built in. What are you working on?`,
+    },
+  },
+  {
+    value: 'ux-intelligence',
+    label: 'UX Intelligence Agent',
+    hint: 'User behavior, conversion optimization, inclusive design, ethical patterns',
+    tier: 'premium',
+    defaults: {
+      role: 'Applies user behavior research to design decisions for conversion, accessibility, and ethical UX',
+      description:
+        'This agent brings UX research intelligence to every design decision: onboarding flows, form optimization, navigation patterns, data entry, search UX, touch targets, animation, performance perception, and AI interaction patterns. It measures conversion impact and ensures inclusive, ethical design.',
+      domains: ['accessibility', 'performance', 'testing', 'frontend', 'ux-design'],
+      principles: [
+        'User behavior drives design decisions',
+        'Accessibility is not a feature, it is a baseline',
+        'Measure conversion impact of every UX change',
+        'Progressive disclosure over information overload',
+        'Design for the consumer, not the implementer',
+      ],
+      skills: ['vault-navigator', 'vault-capture', 'second-opinion', 'knowledge-harvest'],
+      tone: 'mentor',
+      greetingTemplate: (name) =>
+        `Hello! I'm ${name}. I help make UX decisions backed by user behavior research — onboarding, forms, navigation, accessibility, and conversion optimization.`,
+    },
+  },
+  {
+    value: 'knowledge-curator',
+    label: 'Knowledge Curator',
+    hint: 'Vault lifecycle, cross-project patterns, domain vocabulary, knowledge architecture',
+    tier: 'premium',
+    defaults: {
+      role: 'Manages knowledge capture, curation, and cross-project pattern extraction for organizational learning',
+      description:
+        'This agent manages the full knowledge lifecycle: capturing patterns at the moment of discovery, curating vault entries for quality and consistency, extracting cross-project patterns, maintaining domain vocabulary, and ensuring knowledge is searchable and actionable.',
+      domains: ['documentation', 'architecture', 'code-review', 'knowledge-management'],
+      principles: [
+        'Knowledge-gather before execute, always',
+        'Vault is the single source of truth',
+        'Capture lessons at the moment of discovery',
+        'Cross-project patterns beat project-local fixes',
+        'Domain vocabulary must be explicit and extensible',
+      ],
+      skills: ['vault-navigator', 'vault-capture', 'knowledge-harvest', 'brain-debrief'],
+      tone: 'precise',
+      greetingTemplate: (name) =>
+        `Hello! I'm ${name}. I manage knowledge — capturing patterns, curating quality, and extracting insights across projects. What knowledge needs attention?`,
+    },
+  },
+  {
+    value: 'architecture-sentinel',
+    label: 'Architecture Sentinel',
+    hint: 'Governance gates, protocol enforcement, reversible migrations, graceful degradation',
+    tier: 'premium',
+    defaults: {
+      role: 'Enforces architectural governance with checkpoint gates, protocol enforcement, and data-driven decision making',
+      description:
+        'This agent guards architectural integrity through two-gate approval (plan then execute), checkpoint-based protocol enforcement, data-driven architecture decisions, reversible migration strategies, and graceful degradation patterns. It ensures systems fail closed and degrade gracefully.',
+      domains: ['architecture', 'security', 'code-review', 'testing', 'governance'],
+      principles: [
+        'Two-gate approval: plan then execute, never skip',
+        'Protocol enforcement via checkpoint gates',
+        'Data-driven architecture: logic in config, not code',
+        'Every migration must be reversible',
+        'Fail closed, not open',
+        'Graceful degradation over hard failures',
+      ],
+      skills: ['code-patrol', 'vault-navigator', 'second-opinion', 'knowledge-harvest'],
+      tone: 'precise',
+      greetingTemplate: (name) =>
+        `Hello! I'm ${name}. I enforce architectural governance — approval gates, protocol checkpoints, reversible migrations, and graceful degradation. What needs review?`,
+    },
+  },
 ];

package/src/prompts/create-wizard.ts

@@ -6,7 +6,7 @@
  * is Enter / arrow keys / space bar.
  */
 import * as p from '@clack/prompts';
-import type { AgentConfig } from '@soleri/forge/lib';
+import type { AgentConfigInput } from '@soleri/forge/lib';
 import { ARCHETYPES, type Archetype } from './archetypes.js';
 import {
   DOMAIN_OPTIONS,
@@ -31,10 +31,10 @@ function slugify(name: string): string {
 }
 
 /**
- * Run the interactive create wizard and return an AgentConfig.
+ * Run the interactive create wizard and return an AgentConfigInput.
  * Returns null if the user cancels at any point.
  */
-export async function runCreateWizard(initialName?: string): Promise<AgentConfig | null> {
+export async function runCreateWizard(initialName?: string): Promise<AgentConfigInput | null> {
   p.intro('Create a new Soleri agent');
 
   // ─── Step 1: Archetype ────────────────────────────────────
@@ -51,18 +51,37 @@ export async function runCreateWizard(initialName?: string): Promise<AgentConfig
     },
   ];
 
-  const archetypeValue = await p.select({
-    message: 'What kind of agent are you building?',
+  const archetypeValues = await p.multiselect({
+    message: 'What kind of agent are you building? (select one or more)',
     options: archetypeChoices,
+    required: false,
   });
 
-  if (p.isCancel(archetypeValue)) return null;
+  if (p.isCancel(archetypeValues)) return null;
+
+  const selectedValues = archetypeValues as string[];
+  const isCustom = selectedValues.includes('_custom') || selectedValues.length === 0;
+  const selectedArchetypes = ARCHETYPES.filter((a) => selectedValues.includes(a.value));
 
-  const archetype: Archetype | undefined = ARCHETYPES.find((a) => a.value === archetypeValue);
-  const isCustom = archetypeValue === '_custom';
+  // Merge defaults from all selected archetypes
+  function mergeDefaults(archetypes: Archetype[]) {
+    if (archetypes.length === 0) return null;
+    const domains = [...new Set(archetypes.flatMap((a) => a.defaults.domains))];
+    const principles = [...new Set(archetypes.flatMap((a) => a.defaults.principles))];
+    const skills = [...new Set(archetypes.flatMap((a) => a.defaults.skills))];
+    const tones = [...new Set(archetypes.map((a) => a.defaults.tone))];
+    return { domains, principles, skills, tones };
+  }
+
+  const merged = mergeDefaults(selectedArchetypes);
 
   // ─── Step 2: Display name ─────────────────────────────────
-  const nameDefault = archetype ? archetype.label : undefined;
+  const nameDefault =
+    selectedArchetypes.length === 1
+      ? selectedArchetypes[0].label
+      : selectedArchetypes.length > 1
+        ? selectedArchetypes.map((a) => a.label).join(' + ')
+        : undefined;
 
   const name = (await p.text({
     message: 'Display name',
@@ -75,46 +94,40 @@ export async function runCreateWizard(initialName?: string): Promise<AgentConfig
 
   if (p.isCancel(name)) return null;
 
-  // ─── Step 3: Agent ID (auto-derived, confirm or edit) ─────
-  const autoId = slugify(name);
-
-  const id = (await p.text({
-    message: 'Agent ID (auto-generated, press Enter to accept)',
-    placeholder: autoId,
-    initialValue: autoId,
-    validate: (v = '') => {
-      if (!/^[a-z][a-z0-9-]*$/.test(v)) return 'Must be kebab-case (e.g., "my-agent")';
-    },
-  })) as string;
-
-  if (p.isCancel(id)) return null;
+  // ─── Step 3: Agent ID (auto-derived from name) ─────────────
+  const id = slugify(name);
 
   // ─── Step 4: Role ─────────────────────────────────────────
   let role: string;
 
-  if (isCustom) {
-    p.note(
-      [
-        CUSTOM_ROLE_GUIDANCE.instruction,
-        '',
-        'Examples:',
-        ...CUSTOM_ROLE_GUIDANCE.examples.map((e) => `  "${e}"`),
-      ].join('\n'),
-      '\u2726 Custom Agent Playbook',
-    );
+  if (isCustom || selectedArchetypes.length > 1) {
+    if (isCustom) {
+      p.note(
+        [
+          CUSTOM_ROLE_GUIDANCE.instruction,
+          '',
+          'Examples:',
+          ...CUSTOM_ROLE_GUIDANCE.examples.map((e) => `  "${e}"`),
+        ].join('\n'),
+        '\u2726 Custom Agent Playbook',
+      );
+    }
 
-    const customRole = (await p.text({
-      message: 'What does your agent do? (one sentence)',
+    const rolePrompt = (await p.text({
+      message:
+        selectedArchetypes.length > 1
+          ? 'Combined role (describe what this multi-purpose agent does)'
+          : 'What does your agent do? (one sentence)',
       placeholder: 'Validates GraphQL schemas against federation rules',
       validate: (v) => {
         if (!v || v.length > 100) return 'Required (max 100 chars)';
       },
     })) as string;
 
-    if (p.isCancel(customRole)) return null;
-    role = customRole;
+    if (p.isCancel(rolePrompt)) return null;
+    role = rolePrompt;
   } else {
-    const prefilledRole = archetype!.defaults.role;
+    const prefilledRole = selectedArchetypes[0].defaults.role;
     const editedRole = (await p.text({
       message: 'Role (pre-filled, press Enter to accept)',
       initialValue: prefilledRole,
@@ -130,29 +143,34 @@ export async function runCreateWizard(initialName?: string): Promise<AgentConfig
   // ─── Step 5: Description ──────────────────────────────────
   let description: string;
 
-  if (isCustom) {
-    p.note(
-      [
-        CUSTOM_DESCRIPTION_GUIDANCE.instruction,
-        '',
-        'Example:',
-        ...CUSTOM_DESCRIPTION_GUIDANCE.examples.map((e) => `  "${e}"`),
-      ].join('\n'),
-      '\u2726 Description',
-    );
+  if (isCustom || selectedArchetypes.length > 1) {
+    if (isCustom) {
+      p.note(
+        [
+          CUSTOM_DESCRIPTION_GUIDANCE.instruction,
+          '',
+          'Example:',
+          ...CUSTOM_DESCRIPTION_GUIDANCE.examples.map((e) => `  "${e}"`),
+        ].join('\n'),
+        '\u2726 Description',
+      );
+    }
 
-    const customDesc = (await p.text({
-      message: 'Describe your agent in detail',
+    const descPrompt = (await p.text({
+      message:
+        selectedArchetypes.length > 1
+          ? 'Combined description (what does this multi-purpose agent do?)'
+          : 'Describe your agent in detail',
       placeholder: 'This agent helps developers with...',
       validate: (v) => {
         if (!v || v.length < 10 || v.length > 500) return 'Required (10-500 chars)';
       },
     })) as string;
 
-    if (p.isCancel(customDesc)) return null;
-    description = customDesc;
+    if (p.isCancel(descPrompt)) return null;
+    description = descPrompt;
   } else {
-    const prefilledDesc = archetype!.defaults.description;
+    const prefilledDesc = selectedArchetypes[0].defaults.description;
     const editedDesc = (await p.text({
       message: 'Description (pre-filled, press Enter to accept)',
       initialValue: prefilledDesc,
@@ -166,7 +184,7 @@ export async function runCreateWizard(initialName?: string): Promise<AgentConfig
   }
 
   // ─── Step 6: Domains (multiselect) ────────────────────────
-  const preselectedDomains = new Set(archetype?.defaults.domains ?? []);
+  const preselectedDomains = new Set(merged?.domains ?? []);
 
   const domainChoices = [
     ...DOMAIN_OPTIONS.map((d) => ({
@@ -228,14 +246,16 @@ export async function runCreateWizard(initialName?: string): Promise<AgentConfig
   }
 
   // ─── Step 7: Principles (multiselect) ─────────────────────
-  const preselectedPrinciples = new Set(archetype?.defaults.principles ?? []);
+  const preselectedPrinciples = new Set(merged?.principles ?? []);
 
   // Flatten categories into a single options list with group labels
-  const principleChoices = PRINCIPLE_CATEGORIES.flatMap((cat) => cat.options.map((o) => ({
+  const principleChoices = PRINCIPLE_CATEGORIES.flatMap((cat) =>
+    cat.options.map((o) => ({
       value: o.value,
       label: o.label,
       hint: cat.label,
-    })));
+    })),
+  );
 
   principleChoices.push({
     value: '_custom',
@@ -289,7 +309,16 @@ export async function runCreateWizard(initialName?: string): Promise<AgentConfig
   }
 
   // ─── Step 8: Communication tone ───────────────────────────
-  const defaultTone = archetype?.defaults.tone ?? 'pragmatic';
+  let defaultTone: 'precise' | 'mentor' | 'pragmatic';
+
+  if (merged && merged.tones.length === 1) {
+    defaultTone = merged.tones[0];
+  } else if (merged && merged.tones.length > 1) {
+    p.note(`Selected archetypes use different tones: ${merged.tones.join(', ')}`, 'Tone Conflict');
+    defaultTone = 'pragmatic';
+  } else {
+    defaultTone = 'pragmatic';
+  }
 
   const tone = await p.select({
     message: 'Communication tone',
@@ -304,7 +333,7 @@ export async function runCreateWizard(initialName?: string): Promise<AgentConfig
   if (p.isCancel(tone)) return null;
 
   // ─── Step 9: Skills (multiselect) ─────────────────────────
-  const preselectedSkills = new Set(archetype?.defaults.skills ?? []);
+  const preselectedSkills = new Set(merged?.skills ?? []);
 
   p.note(`Always included: ${CORE_SKILLS.join(', ')}`, 'Core Skills');
 
@@ -328,9 +357,10 @@ export async function runCreateWizard(initialName?: string): Promise<AgentConfig
   const selectedSkills = [...CORE_SKILLS, ...(skillSelection as string[])];
 
   // ─── Step 10: Greeting (auto or custom) ───────────────────
-  const autoGreeting = archetype
-    ? archetype.defaults.greetingTemplate(name)
-    : `Hello! I'm ${name}. I ${role[0].toLowerCase()}${role.slice(1)}.`;
+  const autoGreeting =
+    selectedArchetypes.length === 1
+      ? selectedArchetypes[0].defaults.greetingTemplate(name)
+      : `Hello! I'm ${name}. I ${role[0].toLowerCase()}${role.slice(1)}.`;
 
   const greetingChoice = await p.select({
     message: 'Greeting message',
@@ -390,6 +420,31 @@ export async function runCreateWizard(initialName?: string): Promise<AgentConfig
 
   if (p.isCancel(outputDir)) return null;
 
+  // ─── Step 12: Setup target ────────────────────────────────
+  const setupTarget = await p.select({
+    message: 'Setup target',
+    options: [
+      {
+        value: 'claude',
+        label: 'Claude Code',
+        hint: 'Generate/setup Claude integrations (default)',
+      },
+      {
+        value: 'codex',
+        label: 'Codex',
+        hint: 'Generate/setup Codex integrations',
+      },
+      {
+        value: 'both',
+        label: 'Both',
+        hint: 'Generate/setup for Claude Code and Codex',
+      },
+    ],
+    initialValue: 'claude',
+  });
+
+  if (p.isCancel(setupTarget)) return null;
+
   return {
     id,
     name,
@@ -401,5 +456,6 @@ export async function runCreateWizard(initialName?: string): Promise<AgentConfig
     greeting,
     outputDir,
     skills: selectedSkills,
+    setupTarget: setupTarget as 'claude' | 'codex' | 'both',
   };
 }