@soleri/cli 9.3.1 → 9.4.0

package/src/main.ts

@@ -21,6 +21,7 @@ import { registerSkills } from './commands/skills.js';
 import { registerAgent } from './commands/agent.js';
 import { registerTelegram } from './commands/telegram.js';
 import { registerStaging } from './commands/staging.js';
+import { registerYolo } from './commands/yolo.js';
 
 const require = createRequire(import.meta.url);
 const { version } = require('../package.json');
@@ -82,4 +83,5 @@ registerSkills(program);
 registerAgent(program);
 registerTelegram(program);
 registerStaging(program);
+registerYolo(program);
 program.parse();

package/vitest.config.ts

@@ -6,5 +6,6 @@ export default defineConfig({
     testTimeout: 15_000,
     pool: 'forks',
     teardownTimeout: 10_000,
+    exclude: ['**/node_modules/**', '**/.claude/worktrees/**'],
   },
 });

package/src/__tests__/archetypes.test.ts

@@ -1,84 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { ARCHETYPES } from '../prompts/archetypes.js';
-import {
-  CORE_SKILLS,
-  SKILL_CATEGORIES,
-  DOMAIN_OPTIONS,
-  PRINCIPLE_CATEGORIES,
-} from '../prompts/playbook.js';
-
-const allDomainValues = DOMAIN_OPTIONS.map((d) => d.value);
-const allPrincipleValues = PRINCIPLE_CATEGORIES.flatMap((c) => c.options.map((o) => o.value));
-const allOptionalSkillValues = SKILL_CATEGORIES.flatMap((c) => c.options.map((o) => o.value));
-
-describe('Archetypes', () => {
-  it('should have unique values', () => {
-    const values = ARCHETYPES.map((a) => a.value);
-    expect(new Set(values).size).toBe(values.length);
-  });
-
-  it('should all have tier field', () => {
-    for (const a of ARCHETYPES) {
-      expect(a.tier).toMatch(/^(free|premium)$/);
-    }
-  });
-
-  it('should have at least 9 archetypes', () => {
-    expect(ARCHETYPES.length).toBeGreaterThanOrEqual(9);
-  });
-
-  it('should reference only valid domains', () => {
-    for (const a of ARCHETYPES) {
-      for (const d of a.defaults.domains) {
-        expect(allDomainValues).toContain(d);
-      }
-    }
-  });
-
-  it('should reference only valid principles', () => {
-    for (const a of ARCHETYPES) {
-      for (const pr of a.defaults.principles) {
-        expect(allPrincipleValues).toContain(pr);
-      }
-    }
-  });
-
-  it('should not include core skills in archetype skills', () => {
-    const coreSet = new Set<string>(CORE_SKILLS);
-    for (const a of ARCHETYPES) {
-      for (const s of a.defaults.skills) {
-        expect(coreSet.has(s)).toBe(false);
-      }
-    }
-  });
-
-  it('should reference only valid optional skills', () => {
-    for (const a of ARCHETYPES) {
-      for (const s of a.defaults.skills) {
-        expect(allOptionalSkillValues).toContain(s);
-      }
-    }
-  });
-
-  it('should include Accessibility Guardian', () => {
-    expect(ARCHETYPES.find((a) => a.value === 'accessibility-guardian')).toBeDefined();
-  });
-
-  it('should include Documentation Writer', () => {
-    expect(ARCHETYPES.find((a) => a.value === 'documentation-writer')).toBeDefined();
-  });
-});
-
-describe('Core Skills', () => {
-  it('should include writing-plans and executing-plans', () => {
-    expect(CORE_SKILLS).toContain('writing-plans');
-    expect(CORE_SKILLS).toContain('executing-plans');
-  });
-
-  it('should not appear in optional skill categories', () => {
-    const coreSet = new Set<string>(CORE_SKILLS);
-    for (const s of allOptionalSkillValues) {
-      expect(coreSet.has(s)).toBe(false);
-    }
-  });
-});

package/src/__tests__/create.test.ts

@@ -1,207 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { previewScaffold, scaffold } from '@soleri/forge/lib';
-import type { AgentConfig } from '@soleri/forge/lib';
-import { installPack } from '../hook-packs/installer.js';
-
-describe('create command', { timeout: 30_000 }, () => {
-  let tempDir: string;
-
-  const testConfig: AgentConfig = {
-    id: 'test-agent',
-    name: 'TestAgent',
-    role: 'A test agent',
-    description: 'This agent is used for testing the CLI create command.',
-    domains: ['testing', 'quality'],
-    principles: ['Test everything', 'Quality first'],
-    greeting: 'Hello! I am TestAgent, here to help with testing.',
-    outputDir: '',
-  };
-
-  beforeEach(() => {
-    tempDir = join(tmpdir(), `cli-create-test-${Date.now()}`);
-    mkdirSync(tempDir, { recursive: true });
-    testConfig.outputDir = tempDir;
-  });
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  it('should preview scaffold without creating files', () => {
-    const preview = previewScaffold(testConfig);
-
-    expect(preview.agentDir).toBe(join(tempDir, 'test-agent'));
-    expect(preview.persona.name).toBe('TestAgent');
-    expect(preview.domains).toEqual(['testing', 'quality']);
-    expect(preview.files.length).toBeGreaterThan(10);
-    expect(existsSync(preview.agentDir)).toBe(false);
-  });
-
-  it('should scaffold agent successfully', () => {
-    const result = scaffold(testConfig);
-
-    expect(result.success).toBe(true);
-    expect(result.agentDir).toBe(join(tempDir, 'test-agent'));
-    expect(result.filesCreated.length).toBeGreaterThan(10);
-    expect(existsSync(join(tempDir, 'test-agent', 'package.json'))).toBe(true);
-    expect(existsSync(join(tempDir, 'test-agent', 'src', 'index.ts'))).toBe(true);
-  });
-
-  it('should fail if directory already exists', () => {
-    scaffold(testConfig);
-    const result = scaffold(testConfig);
-
-    expect(result.success).toBe(false);
-    expect(result.summary).toContain('already exists');
-  });
-
-  it('should not create facade files (v5.0 uses runtime factories from @soleri/core)', () => {
-    scaffold(testConfig);
-
-    // v5.0: facades are created at runtime by createDomainFacades() — no generated files
-    expect(existsSync(join(tempDir, 'test-agent', 'src', 'facades'))).toBe(false);
-
-    // Entry point should reference createDomainFacades
-    const entry = readFileSync(join(tempDir, 'test-agent', 'src', 'index.ts'), 'utf-8');
-    expect(entry).toContain('createDomainFacades');
-    expect(entry).toContain('"testing"');
-    expect(entry).toContain('"quality"');
-  });
-
-  it('should create intelligence data files for each domain', () => {
-    scaffold(testConfig);
-
-    const testingBundle = JSON.parse(
-      readFileSync(
-        join(tempDir, 'test-agent', 'src', 'intelligence', 'data', 'testing.json'),
-        'utf-8',
-      ),
-    );
-    expect(testingBundle.domain).toBe('testing');
-    expect(testingBundle.entries.length).toBeGreaterThanOrEqual(0);
-    if (testingBundle.entries.length > 0) {
-      expect(testingBundle.entries[0].id).toBe('testing-seed');
-      expect(testingBundle.entries[0].tags).toContain('seed');
-    }
-  });
-
-  it('should read config from file for non-interactive mode', () => {
-    const configPath = join(tempDir, 'agent.json');
-    writeFileSync(configPath, JSON.stringify(testConfig), 'utf-8');
-
-    const raw = JSON.parse(readFileSync(configPath, 'utf-8'));
-    expect(raw.id).toBe('test-agent');
-    expect(raw.domains).toEqual(['testing', 'quality']);
-  });
-
-  // ─── Hook pack integration tests ──────────────────────────────
-
-  it('should create .claude/ directory when hookPacks specified', () => {
-    const configWithHooks: AgentConfig = {
-      ...testConfig,
-      hookPacks: ['typescript-safety'],
-    };
-    const result = scaffold(configWithHooks);
-
-    expect(result.success).toBe(true);
-    expect(existsSync(join(tempDir, 'test-agent', '.claude'))).toBe(true);
-  });
-
-  it('should install hookify files to agent .claude/ via installPack', () => {
-    const configWithHooks: AgentConfig = {
-      ...testConfig,
-      hookPacks: ['typescript-safety'],
-    };
-    const result = scaffold(configWithHooks);
-    expect(result.success).toBe(true);
-
-    // Simulate what create.ts does: install packs into agent dir
-    const { installed } = installPack('typescript-safety', { projectDir: result.agentDir });
-    expect(installed.length).toBeGreaterThan(0);
-
-    // Verify hookify files exist in agent .claude/
-    const claudeDir = join(result.agentDir, '.claude');
-    const hookFiles = readdirSync(claudeDir).filter(
-      (f) => f.startsWith('hookify.') && f.endsWith('.local.md'),
-    );
-    expect(hookFiles.length).toBeGreaterThan(0);
-    expect(hookFiles.some((f) => f.includes('no-any-types'))).toBe(true);
-  });
-
-  it('should not create .claude/ when hookPacks is empty or undefined', () => {
-    const result = scaffold(testConfig);
-
-    expect(result.success).toBe(true);
-    expect(existsSync(join(tempDir, 'test-agent', '.claude'))).toBe(false);
-  });
-
-  it('should include hook packs in preview when hookPacks specified', () => {
-    const configWithHooks: AgentConfig = {
-      ...testConfig,
-      hookPacks: ['typescript-safety'],
-    };
-    const preview = previewScaffold(configWithHooks);
-
-    const hookEntry = preview.files.find((f) => f.path === '.claude/');
-    expect(hookEntry).toBeDefined();
-    expect(hookEntry!.description).toContain('typescript-safety');
-  });
-
-  it('should include Hook Packs section in CLAUDE.md when hookPacks specified', () => {
-    const configWithHooks: AgentConfig = {
-      ...testConfig,
-      hookPacks: ['typescript-safety'],
-    };
-    scaffold(configWithHooks);
-
-    const claudeMd = readFileSync(
-      join(tempDir, 'test-agent', 'src', 'activation', 'claude-md-content.ts'),
-      'utf-8',
-    );
-    expect(claudeMd).toContain('Hook Packs');
-    expect(claudeMd).toContain('typescript-safety');
-  });
-
-  it('should not include Hook Packs section in CLAUDE.md when hookPacks undefined', () => {
-    scaffold(testConfig);
-
-    const claudeMd = readFileSync(
-      join(tempDir, 'test-agent', 'src', 'activation', 'claude-md-content.ts'),
-      'utf-8',
-    );
-    expect(claudeMd).not.toContain('Hook Packs');
-  });
-
-  it('should include hook copy logic in setup.sh when hookPacks specified', () => {
-    const configWithHooks: AgentConfig = {
-      ...testConfig,
-      hookPacks: ['typescript-safety'],
-    };
-    scaffold(configWithHooks);
-
-    const setupSh = readFileSync(join(tempDir, 'test-agent', 'scripts', 'setup.sh'), 'utf-8');
-    expect(setupSh).toContain('Installing hook packs');
-    expect(setupSh).toContain('hookify.');
-    expect(setupSh).toContain('GLOBAL_CLAUDE_DIR');
-  });
-
-  it('should not include hook copy logic in setup.sh when hookPacks undefined', () => {
-    scaffold(testConfig);
-
-    const setupSh = readFileSync(join(tempDir, 'test-agent', 'scripts', 'setup.sh'), 'utf-8');
-    expect(setupSh).not.toContain('Installing hook packs');
-  });
-
-  it('should mention hook packs in scaffold summary', () => {
-    const configWithHooks: AgentConfig = {
-      ...testConfig,
-      hookPacks: ['typescript-safety', 'a11y'],
-    };
-    const result = scaffold(configWithHooks);
-
-    expect(result.summary).toContain('2 hook pack(s) bundled in .claude/');
-  });
-});

package/src/prompts/archetypes.ts

@@ -1,343 +0,0 @@
-/**
- * Pre-built agent archetypes that pre-fill the wizard.
- * Each archetype provides sensible defaults for role, description,
- * domains, principles, skills, and greeting — so the user can
- * scaffold a full agent with minimal typing.
- */
-
-export interface Archetype {
-  value: string;
-  label: string;
-  hint: string;
-  tier: 'free' | 'premium';
-  defaults: {
-    role: string;
-    description: string;
-    domains: string[];
-    principles: string[];
-    skills: string[];
-    tone: 'precise' | 'mentor' | 'pragmatic';
-    greetingTemplate: (name: string) => string;
-  };
-}
-
-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:
-        'This agent reviews code for quality issues, anti-patterns, naming conventions, test coverage gaps, and architectural violations. It provides actionable feedback with concrete fix suggestions.',
-      domains: ['code-review', 'architecture'],
-      principles: [
-        'Actionable feedback only',
-        'Readable over clever',
-        'Small PR scope',
-        'Respect existing patterns',
-      ],
-      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.`,
-    },
-  },
-  {
-    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:
-        'This agent scans code for security issues including OWASP Top 10, dependency vulnerabilities, secrets exposure, injection risks, and insecure configurations. It provides remediation guidance with severity ratings.',
-      domains: ['security', 'code-review'],
-      principles: [
-        'Security first',
-        'Fail closed, not open',
-        'Zero trust by default',
-        'Least privilege always',
-        'Defense in depth',
-      ],
-      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.`,
-    },
-  },
-  {
-    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: [
-        'Backward compatibility by default',
-        'Consumer-driven contracts',
-        'Design for the consumer, not the implementer',
-        'Every migration must be reversible',
-      ],
-      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.`,
-    },
-  },
-  {
-    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:
-        'This agent helps write comprehensive test suites, identifies coverage gaps, suggests edge cases, and guides TDD workflows. It supports unit, integration, and end-to-end testing strategies.',
-      domains: ['testing', 'code-review'],
-      principles: [
-        'Test everything that can break',
-        'Deterministic tests only',
-        'Test at boundaries, not internals',
-        'Simplicity over cleverness',
-      ],
-      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.`,
-    },
-  },
-  {
-    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:
-        'This agent helps design and maintain CI/CD pipelines, Docker configurations, infrastructure as code, monitoring setup, and deployment strategies. It follows reliability engineering best practices.',
-      domains: ['devops', 'architecture'],
-      principles: [
-        'Automate everything repeatable',
-        'Infrastructure as code',
-        'Blast radius awareness',
-        'Observability built in from day one',
-      ],
-      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.`,
-    },
-  },
-  {
-    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',
-      ],
-      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.`,
-    },
-  },
-  {
-    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:
-        'This agent helps with frontend, backend, database, testing, and deployment tasks. It provides balanced guidance across the entire stack without deep specialization in any single area.',
-      domains: ['code-review', 'testing', 'architecture'],
-      principles: [
-        'Simplicity over cleverness',
-        'Progressive enhancement',
-        'Test everything that can break',
-        'Respect existing patterns',
-      ],
-      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?`,
-    },
-  },
-];