@compilr-dev/cli 0.5.0 → 0.5.2

package/dist/ui/overlay/impl/custom-agent-form-overlay-v2.js

@@ -0,0 +1,711 @@
+/**
+ * Custom Agent Form Overlay V2
+ *
+ * Multi-step wizard for creating custom agents.
+ * Step 1: Basic Info (Agent ID, Display Name, Specialty, Personality)
+ * Step 2: Tool Profile (select profile or customize tool groups)
+ * Step 3: Skills (select which skills to enable)
+ * Step 4: Model Tier (select fast/balanced/powerful)
+ */
+import { BaseOverlayV2, renderBorder, wrapText } from '../../base/index.js';
+import { validateAgentId, isAgentIdTaken, } from '../../../multi-agent/custom-agents.js';
+import { PREDEFINED_ROLE_IDS } from '../../../multi-agent/types.js';
+import { TOOL_GROUPS, PROFILE_INFO, getGroupsByTier, createDefaultToolConfig, getToolsForProfile, } from '../../../multi-agent/tool-config.js';
+import { getDefinedSkillNames, checkSkillCompatibility, getSkillsByCategory, } from '../../../multi-agent/skill-requirements.js';
+import { MODEL_TIERS, TIER_INFO } from '../../../models/index.js';
+// Profile list for selection
+const PROFILE_LIST = [
+    'full',
+    'read-only',
+    'developer',
+    'security',
+    'docs',
+    'devops',
+    'qa',
+    'custom',
+];
+// =============================================================================
+// Overlay Implementation
+// =============================================================================
+export class CustomAgentFormOverlayV2 extends BaseOverlayV2 {
+    type = 'inline';
+    id = 'custom-agent-form-overlay-v2';
+    existingCustomAgents;
+    teamAgentIds;
+    constructor(options) {
+        const fields = [
+            {
+                id: 'agentId',
+                label: 'Agent ID',
+                hint: 'lowercase, no spaces, used as $agentId',
+                required: true,
+                maxLength: 20,
+                value: '',
+            },
+            {
+                id: 'displayName',
+                label: 'Display Name',
+                hint: 'human-readable name',
+                required: true,
+                maxLength: 50,
+                value: '',
+            },
+            {
+                id: 'specialty',
+                label: 'Specialty',
+                hint: 'what this agent specializes in',
+                required: true,
+                maxLength: 200,
+                value: '',
+            },
+            {
+                id: 'personality',
+                label: 'Personality',
+                hint: 'optional - how the agent approaches tasks',
+                required: false,
+                maxLength: 200,
+                value: '',
+            },
+        ];
+        super({
+            fields,
+            activeFieldIndex: 0,
+            cursorPos: 0,
+            currentStep: 'basic',
+            selectedProfile: 'full',
+            customGroups: new Set(),
+            profileListIndex: 0,
+            groupListIndex: 0,
+            inGroupSelection: false,
+            enabledSkills: new Set(),
+            skillListIndex: 0,
+            selectedModelTier: 'balanced',
+            tierListIndex: 1, // Default to balanced (index 1)
+        });
+        this.existingCustomAgents = options.existingCustomAgents;
+        this.teamAgentIds = options.teamAgentIds;
+        this.minHeight = 25;
+    }
+    renderContent(context) {
+        switch (this.state.currentStep) {
+            case 'basic':
+                return this.renderBasicStep(context);
+            case 'tools':
+                return this.renderToolsStep(context);
+            case 'skills':
+                return this.renderSkillsStep(context);
+            case 'tier':
+                return this.renderTierStep(context);
+            default:
+                return this.renderBasicStep(context);
+        }
+    }
+    renderBasicStep(context) {
+        const s = context.styles;
+        const lines = [];
+        const border = renderBorder(context.width, s);
+        // Header with step indicator
+        lines.push(border);
+        lines.push(` ${s.primaryBold('Create Custom Agent')} ${s.muted('- Step 1/4: Basic Info')}`);
+        lines.push(border);
+        lines.push('');
+        // Render each field
+        for (let i = 0; i < this.state.fields.length; i++) {
+            const field = this.state.fields[i];
+            const isActive = i === this.state.activeFieldIndex;
+            const requiredMark = field.required ? s.error('*') : ' ';
+            // Field label
+            const labelStyle = isActive ? s.primary : s.secondary;
+            lines.push(` ${requiredMark} ${labelStyle(field.label + ':')}`);
+            // Field input
+            if (isActive) {
+                // Show cursor in active field
+                const beforeCursor = field.value.slice(0, this.state.cursorPos);
+                const afterCursor = field.value.slice(this.state.cursorPos);
+                const cursor = s.primaryBold('│');
+                lines.push(`     ${beforeCursor}${cursor}${afterCursor}`);
+            }
+            else {
+                // Show value or placeholder
+                if (field.value) {
+                    lines.push(`     ${field.value}`);
+                }
+                else {
+                    lines.push(`     ${s.muted('(empty)')}`);
+                }
+            }
+            // Hint or error
+            if (field.error) {
+                lines.push(`     ${s.error('⚠ ' + field.error)}`);
+            }
+            else if (isActive) {
+                lines.push(`     ${s.muted(field.hint)}`);
+            }
+            else {
+                lines.push('');
+            }
+        }
+        lines.push('');
+        // Footer
+        lines.push(border);
+        lines.push(s.muted(' Tab/↓ Next  Shift+Tab/↑ Prev  Enter Continue  Ctrl+D Defaults  Esc Cancel'));
+        lines.push(border);
+        return lines;
+    }
+    renderToolsStep(context) {
+        const s = context.styles;
+        const lines = [];
+        const border = renderBorder(context.width, s);
+        // Header
+        lines.push(border);
+        lines.push(` ${s.primaryBold('Create Custom Agent')} ${s.muted('- Step 2/4: Tool Profile')}`);
+        lines.push(border);
+        lines.push('');
+        if (!this.state.inGroupSelection) {
+            // Profile selection
+            lines.push(` ${s.primary('Select a tool profile:')}`);
+            lines.push('');
+            for (let i = 0; i < PROFILE_LIST.length; i++) {
+                const profile = PROFILE_LIST[i];
+                const info = PROFILE_INFO[profile];
+                const isSelected = i === this.state.profileListIndex;
+                const isChosen = this.state.selectedProfile === profile;
+                const marker = isChosen ? s.success('●') : (isSelected ? s.primary('○') : ' ');
+                const labelStyle = isSelected ? s.primaryBold : (isChosen ? s.success : s.secondary);
+                lines.push(` ${marker} ${labelStyle(info.label)}`);
+                if (isSelected) {
+                    // Show description for selected item
+                    const wrapped = wrapText(info.description, context.width - 8);
+                    for (const line of wrapped) {
+                        lines.push(`     ${s.muted(line)}`);
+                    }
+                }
+            }
+            lines.push('');
+            lines.push(border);
+            lines.push(s.muted(' ↑/↓ Navigate  Enter Select  ← Back  Esc Cancel'));
+            lines.push(border);
+        }
+        else {
+            // Custom group selection
+            lines.push(` ${s.primary('Select tool groups for custom profile:')}`);
+            lines.push('');
+            const { direct, meta } = getGroupsByTier();
+            // Direct tools section
+            lines.push(` ${s.muted('─── Direct Tools ───')}`);
+            for (let i = 0; i < direct.length; i++) {
+                const groupId = direct[i];
+                this.renderGroupItem(lines, groupId, i, s);
+            }
+            // Meta tools section
+            lines.push('');
+            lines.push(` ${s.muted('─── Meta-Registry Tools (via use_tool) ───')}`);
+            for (let i = 0; i < meta.length; i++) {
+                const groupId = meta[i];
+                this.renderGroupItem(lines, groupId, direct.length + i, s);
+            }
+            lines.push('');
+            lines.push(border);
+            lines.push(s.muted(' ↑/↓ Navigate  Space Toggle  Enter Done  ← Back  Esc Cancel'));
+            lines.push(border);
+        }
+        return lines;
+    }
+    renderGroupItem(lines, groupId, index, s) {
+        // groupId is guaranteed to exist (from getGroupsByTier)
+        const group = TOOL_GROUPS[groupId];
+        const isSelected = index === this.state.groupListIndex;
+        const isEnabled = this.state.customGroups.has(groupId);
+        const marker = isEnabled ? s.success('[x]') : '[ ]';
+        const labelStyle = isSelected ? s.primaryBold : s.secondary;
+        const readOnlyBadge = group.readOnly ? s.muted(' (read-only)') : '';
+        lines.push(` ${marker} ${labelStyle(group.label)}${readOnlyBadge}`);
+    }
+    renderSkillsStep(context) {
+        const s = context.styles;
+        const lines = [];
+        const border = renderBorder(context.width, s);
+        // Header
+        lines.push(border);
+        lines.push(` ${s.primaryBold('Create Custom Agent')} ${s.muted('- Step 3/4: Skills')}`);
+        lines.push(border);
+        lines.push('');
+        lines.push(` ${s.primary('Select skills to enable:')}`);
+        lines.push(` ${s.muted('(Leave empty for all skills, or select specific skills)')}`);
+        lines.push('');
+        // Get available tools for compatibility check
+        const availableTools = this.getAvailableTools();
+        const categories = getSkillsByCategory();
+        let globalIndex = 0;
+        for (const [category, skills] of Object.entries(categories)) {
+            lines.push(` ${s.muted(`─── ${category.charAt(0).toUpperCase() + category.slice(1)} ───`)}`);
+            for (const skillName of skills) {
+                const compatibility = checkSkillCompatibility(skillName, availableTools);
+                const isSelected = globalIndex === this.state.skillListIndex;
+                const isEnabled = this.state.enabledSkills.has(skillName);
+                const isCompatible = compatibility.compatible;
+                const marker = isEnabled ? s.success('[x]') : '[ ]';
+                const labelStyle = isSelected
+                    ? (isCompatible ? s.primaryBold : s.error)
+                    : (isCompatible ? s.secondary : s.muted);
+                const incompatibleBadge = !isCompatible
+                    ? s.error(` (needs: ${compatibility.missingRequired.slice(0, 2).join(', ')}...)`)
+                    : '';
+                lines.push(` ${marker} ${labelStyle(skillName)}${incompatibleBadge}`);
+                globalIndex++;
+            }
+            lines.push('');
+        }
+        lines.push(border);
+        lines.push(s.muted(' ↑/↓ Navigate  Space Toggle  a Toggle All  Enter Next  ← Back  Esc Cancel'));
+        lines.push(border);
+        return lines;
+    }
+    getAvailableTools() {
+        return getToolsForProfile(this.state.selectedProfile, this.state.selectedProfile === 'custom' ? Array.from(this.state.customGroups) : undefined);
+    }
+    handleKey(key) {
+        // Escape - cancel
+        if (key.name === 'escape') {
+            return this.close({ cancelled: true });
+        }
+        // Ctrl+C - cancel
+        if (key.ctrl && key.name === 'c') {
+            return this.close({ cancelled: true });
+        }
+        switch (this.state.currentStep) {
+            case 'basic':
+                return this.handleBasicStepKey(key);
+            case 'tools':
+                return this.handleToolsStepKey(key);
+            case 'skills':
+                return this.handleSkillsStepKey(key);
+            case 'tier':
+                return this.handleTierStepKey(key);
+            default:
+                return this.noAction();
+        }
+    }
+    handleBasicStepKey(key) {
+        const field = this.state.fields[this.state.activeFieldIndex];
+        // Ctrl+D - use defaults (skip to create)
+        if (key.ctrl && key.name === 'd') {
+            return this.submitWithDefaults();
+        }
+        // Tab or Down - next field
+        if (key.name === 'tab' && !key.shift) {
+            return this.nextField();
+        }
+        if (key.name === 'down') {
+            return this.nextField();
+        }
+        // Shift+Tab or Up - previous field
+        if (key.name === 'tab' && key.shift) {
+            return this.prevField();
+        }
+        if (key.name === 'up') {
+            return this.prevField();
+        }
+        // Enter - validate and go to next step
+        if (key.name === 'return') {
+            return this.validateAndContinue();
+        }
+        // Backspace
+        if (key.name === 'backspace') {
+            if (this.state.cursorPos > 0) {
+                field.value = field.value.slice(0, this.state.cursorPos - 1) + field.value.slice(this.state.cursorPos);
+                this.state.cursorPos--;
+                field.error = undefined;
+            }
+            return this.rerender();
+        }
+        // Delete
+        if (key.name === 'delete') {
+            if (this.state.cursorPos < field.value.length) {
+                field.value = field.value.slice(0, this.state.cursorPos) + field.value.slice(this.state.cursorPos + 1);
+                field.error = undefined;
+            }
+            return this.rerender();
+        }
+        // Left arrow
+        if (key.name === 'left') {
+            if (this.state.cursorPos > 0) {
+                this.state.cursorPos--;
+            }
+            return this.rerender();
+        }
+        // Right arrow
+        if (key.name === 'right') {
+            if (this.state.cursorPos < field.value.length) {
+                this.state.cursorPos++;
+            }
+            return this.rerender();
+        }
+        // Home
+        if (key.name === 'home' || (key.ctrl && key.name === 'a')) {
+            this.state.cursorPos = 0;
+            return this.rerender();
+        }
+        // End
+        if (key.name === 'end' || (key.ctrl && key.name === 'e')) {
+            this.state.cursorPos = field.value.length;
+            return this.rerender();
+        }
+        // Printable character
+        if (key.char && key.char.length === 1 && !key.ctrl && !key.meta) {
+            // Check max length
+            if (field.value.length >= field.maxLength) {
+                return this.noAction();
+            }
+            // For agentId field, only allow lowercase letters, numbers, underscore
+            if (field.id === 'agentId') {
+                if (!/^[a-z0-9_]$/.test(key.char)) {
+                    // Auto-convert uppercase to lowercase
+                    if (/^[A-Z]$/.test(key.char)) {
+                        field.value = field.value.slice(0, this.state.cursorPos) + key.char.toLowerCase() + field.value.slice(this.state.cursorPos);
+                        this.state.cursorPos++;
+                        field.error = undefined;
+                        return this.rerender();
+                    }
+                    return this.noAction();
+                }
+            }
+            field.value = field.value.slice(0, this.state.cursorPos) + key.char + field.value.slice(this.state.cursorPos);
+            this.state.cursorPos++;
+            field.error = undefined;
+            return this.rerender();
+        }
+        return this.noAction();
+    }
+    handleToolsStepKey(key) {
+        // Left arrow - go back to basic step
+        if (key.name === 'left') {
+            if (this.state.inGroupSelection) {
+                this.state.inGroupSelection = false;
+            }
+            else {
+                this.state.currentStep = 'basic';
+            }
+            return this.rerender();
+        }
+        if (!this.state.inGroupSelection) {
+            // Profile selection
+            if (key.name === 'up') {
+                if (this.state.profileListIndex > 0) {
+                    this.state.profileListIndex--;
+                }
+                return this.rerender();
+            }
+            if (key.name === 'down') {
+                if (this.state.profileListIndex < PROFILE_LIST.length - 1) {
+                    this.state.profileListIndex++;
+                }
+                return this.rerender();
+            }
+            if (key.name === 'return' || key.name === 'space') {
+                const profile = PROFILE_LIST[this.state.profileListIndex];
+                this.state.selectedProfile = profile;
+                if (profile === 'custom') {
+                    // Enter group selection mode
+                    this.state.inGroupSelection = true;
+                    this.state.groupListIndex = 0;
+                }
+                else {
+                    // Go to skills step
+                    this.state.currentStep = 'skills';
+                }
+                return this.rerender();
+            }
+        }
+        else {
+            // Custom group selection
+            const { direct, meta } = getGroupsByTier();
+            const totalGroups = direct.length + meta.length;
+            if (key.name === 'up') {
+                if (this.state.groupListIndex > 0) {
+                    this.state.groupListIndex--;
+                }
+                return this.rerender();
+            }
+            if (key.name === 'down') {
+                if (this.state.groupListIndex < totalGroups - 1) {
+                    this.state.groupListIndex++;
+                }
+                return this.rerender();
+            }
+            if (key.name === 'space') {
+                // Toggle group
+                const allGroups = [...direct, ...meta];
+                const groupId = allGroups[this.state.groupListIndex];
+                if (this.state.customGroups.has(groupId)) {
+                    this.state.customGroups.delete(groupId);
+                }
+                else {
+                    this.state.customGroups.add(groupId);
+                }
+                return this.rerender();
+            }
+            if (key.name === 'return') {
+                // Validate at least one group is selected
+                if (this.state.customGroups.size === 0) {
+                    // Don't proceed without any groups
+                    return this.noAction();
+                }
+                // Go to skills step
+                this.state.currentStep = 'skills';
+                return this.rerender();
+            }
+        }
+        return this.noAction();
+    }
+    handleSkillsStepKey(key) {
+        const skillNames = getDefinedSkillNames();
+        const totalSkills = skillNames.length;
+        // Left arrow - go back to tools step
+        if (key.name === 'left') {
+            this.state.currentStep = 'tools';
+            return this.rerender();
+        }
+        // Up/Down - navigate skills
+        if (key.name === 'up') {
+            if (this.state.skillListIndex > 0) {
+                this.state.skillListIndex--;
+            }
+            return this.rerender();
+        }
+        if (key.name === 'down') {
+            if (this.state.skillListIndex < totalSkills - 1) {
+                this.state.skillListIndex++;
+            }
+            return this.rerender();
+        }
+        // Space - toggle skill
+        if (key.name === 'space') {
+            const flatSkills = Object.values(getSkillsByCategory()).flat();
+            const skillName = flatSkills[this.state.skillListIndex];
+            // Check compatibility before toggling
+            const availableTools = this.getAvailableTools();
+            const compatibility = checkSkillCompatibility(skillName, availableTools);
+            if (compatibility.compatible) {
+                if (this.state.enabledSkills.has(skillName)) {
+                    this.state.enabledSkills.delete(skillName);
+                }
+                else {
+                    this.state.enabledSkills.add(skillName);
+                }
+            }
+            return this.rerender();
+        }
+        // 'a' - toggle all compatible skills
+        if (key.char === 'a') {
+            const flatSkills = Object.values(getSkillsByCategory()).flat();
+            const availableTools = this.getAvailableTools();
+            const allCompatibleEnabled = flatSkills.every(skillName => {
+                const compatibility = checkSkillCompatibility(skillName, availableTools);
+                return !compatibility.compatible || this.state.enabledSkills.has(skillName);
+            });
+            if (allCompatibleEnabled) {
+                // Clear all
+                this.state.enabledSkills.clear();
+            }
+            else {
+                // Enable all compatible
+                for (const skillName of flatSkills) {
+                    const compatibility = checkSkillCompatibility(skillName, availableTools);
+                    if (compatibility.compatible) {
+                        this.state.enabledSkills.add(skillName);
+                    }
+                }
+            }
+            return this.rerender();
+        }
+        // Enter - go to tier step
+        if (key.name === 'return') {
+            this.state.currentStep = 'tier';
+            return this.rerender();
+        }
+        return this.noAction();
+    }
+    renderTierStep(context) {
+        const s = context.styles;
+        const lines = [];
+        const border = renderBorder(context.width, s);
+        // Header
+        lines.push(border);
+        lines.push(` ${s.primaryBold('Create Custom Agent')} ${s.muted('- Step 4/4: Model Tier')}`);
+        lines.push(border);
+        lines.push('');
+        lines.push(` ${s.primary('Select the default model tier for this agent:')}`);
+        lines.push('');
+        for (let i = 0; i < MODEL_TIERS.length; i++) {
+            const tier = MODEL_TIERS[i];
+            const info = TIER_INFO[tier];
+            const isSelected = i === this.state.tierListIndex;
+            const isChosen = this.state.selectedModelTier === tier;
+            const marker = isChosen ? s.success('●') : (isSelected ? s.primary('○') : ' ');
+            const labelStyle = isSelected ? s.primaryBold : (isChosen ? s.success : s.secondary);
+            // Show tier label with short description
+            lines.push(` ${marker} ${labelStyle(info.label)} ${s.muted(`- ${info.shortDescription}`)}`);
+            if (isSelected) {
+                // Show full description for selected item
+                const wrapped = wrapText(info.description, context.width - 8);
+                for (const line of wrapped) {
+                    lines.push(`     ${s.muted(line)}`);
+                }
+            }
+        }
+        lines.push('');
+        lines.push(border);
+        lines.push(s.muted(' ↑/↓ Navigate  Enter Create  ← Back  Esc Cancel'));
+        lines.push(border);
+        return lines;
+    }
+    handleTierStepKey(key) {
+        // Left arrow - go back to skills step
+        if (key.name === 'left') {
+            this.state.currentStep = 'skills';
+            return this.rerender();
+        }
+        // Up/Down - navigate tiers
+        if (key.name === 'up') {
+            if (this.state.tierListIndex > 0) {
+                this.state.tierListIndex--;
+                this.state.selectedModelTier = MODEL_TIERS[this.state.tierListIndex];
+            }
+            return this.rerender();
+        }
+        if (key.name === 'down') {
+            if (this.state.tierListIndex < MODEL_TIERS.length - 1) {
+                this.state.tierListIndex++;
+                this.state.selectedModelTier = MODEL_TIERS[this.state.tierListIndex];
+            }
+            return this.rerender();
+        }
+        // Space or Enter - select and submit
+        if (key.name === 'space') {
+            this.state.selectedModelTier = MODEL_TIERS[this.state.tierListIndex];
+            return this.rerender();
+        }
+        if (key.name === 'return') {
+            return this.submit();
+        }
+        return this.noAction();
+    }
+    nextField() {
+        if (this.state.activeFieldIndex < this.state.fields.length - 1) {
+            this.state.activeFieldIndex++;
+            this.state.cursorPos = this.state.fields[this.state.activeFieldIndex].value.length;
+        }
+        return this.rerender();
+    }
+    prevField() {
+        if (this.state.activeFieldIndex > 0) {
+            this.state.activeFieldIndex--;
+            this.state.cursorPos = this.state.fields[this.state.activeFieldIndex].value.length;
+        }
+        return this.rerender();
+    }
+    validateBasicInfo() {
+        let hasErrors = false;
+        for (const field of this.state.fields) {
+            field.error = undefined;
+            if (field.required && !field.value.trim()) {
+                field.error = `${field.label} is required`;
+                hasErrors = true;
+                continue;
+            }
+            // Special validation for agentId
+            if (field.id === 'agentId' && field.value) {
+                const idValidation = validateAgentId(field.value);
+                if (!idValidation.valid) {
+                    field.error = idValidation.error;
+                    hasErrors = true;
+                    continue;
+                }
+                const taken = isAgentIdTaken(field.value, this.existingCustomAgents, this.teamAgentIds, [...PREDEFINED_ROLE_IDS]);
+                if (taken.taken) {
+                    field.error = taken.reason;
+                    hasErrors = true;
+                }
+            }
+        }
+        return !hasErrors;
+    }
+    validateAndContinue() {
+        if (!this.validateBasicInfo()) {
+            // Focus first field with error
+            const firstErrorIndex = this.state.fields.findIndex(f => f.error);
+            if (firstErrorIndex >= 0) {
+                this.state.activeFieldIndex = firstErrorIndex;
+                this.state.cursorPos = this.state.fields[firstErrorIndex].value.length;
+            }
+            return this.rerender();
+        }
+        // Go to tools step
+        this.state.currentStep = 'tools';
+        return this.rerender();
+    }
+    submitWithDefaults() {
+        if (!this.validateBasicInfo()) {
+            // Focus first field with error
+            const firstErrorIndex = this.state.fields.findIndex(f => f.error);
+            if (firstErrorIndex >= 0) {
+                this.state.activeFieldIndex = firstErrorIndex;
+                this.state.cursorPos = this.state.fields[firstErrorIndex].value.length;
+            }
+            return this.rerender();
+        }
+        // Submit with default toolConfig, empty skills, and balanced tier
+        const getFieldValue = (id) => {
+            return this.state.fields.find(f => f.id === id)?.value.trim() ?? '';
+        };
+        return this.close({
+            cancelled: false,
+            agent: {
+                id: getFieldValue('agentId'),
+                displayName: getFieldValue('displayName'),
+                specialty: getFieldValue('specialty'),
+                personality: getFieldValue('personality') || undefined,
+                toolConfig: createDefaultToolConfig(),
+                enabledSkills: [],
+                modelTier: 'balanced', // Default tier
+            },
+        });
+    }
+    submit() {
+        const getFieldValue = (id) => {
+            return this.state.fields.find(f => f.id === id)?.value.trim() ?? '';
+        };
+        // Build tool config
+        const toolConfig = {
+            profile: this.state.selectedProfile,
+        };
+        if (this.state.selectedProfile === 'custom') {
+            toolConfig.customGroups = Array.from(this.state.customGroups);
+        }
+        return this.close({
+            cancelled: false,
+            agent: {
+                id: getFieldValue('agentId'),
+                displayName: getFieldValue('displayName'),
+                specialty: getFieldValue('specialty'),
+                personality: getFieldValue('personality') || undefined,
+                toolConfig,
+                enabledSkills: Array.from(this.state.enabledSkills),
+                modelTier: this.state.selectedModelTier,
+            },
+        });
+    }
+    getCloseSummary(result) {
+        const s = this.getStyles();
+        if (result.cancelled) {
+            return s.muted('Custom agent creation cancelled');
+        }
+        if (result.agent) {
+            const profileLabel = PROFILE_INFO[result.agent.toolConfig.profile].label;
+            const tierLabel = TIER_INFO[result.agent.modelTier].label;
+            return s.success(`✓ Created $${result.agent.id}`) + s.muted(` (${result.agent.displayName}, ${profileLabel}, ${tierLabel})`);
+        }
+        return null;
+    }
+}