dexto 1.6.15 → 1.6.16

package/dist/cli/commands/init.d.ts

@@ -1,3 +1,4 @@
+import type { ToolFactoryEntry } from '@dexto/agent-config';
 import type { Command } from 'commander';
 type ScaffoldEntryStatus = 'created' | 'existing';
 type RegistryUpdateStatus = 'created' | 'existing' | 'updated';
@@ -79,6 +80,11 @@ export interface InitCommandRegisterContext {
 type InitAgentCommandOptions = {
     subagent?: boolean;
     primary?: boolean;
+    displayName?: string;
+    description?: string;
+    systemPrompt?: string;
+    greeting?: string;
+    tools?: ToolFactoryEntry[];
 };
 export declare function createWorkspaceScaffold(workspaceRoot?: string): Promise<WorkspaceScaffoldResult>;
 export declare function createWorkspaceAgentScaffold(agentIdInput: string, options?: InitAgentCommandOptions, workspaceRoot?: string): Promise<WorkspaceAgentScaffoldResult>;

package/dist/cli/commands/init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/init.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/init.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAe,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAezE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAuCzC,KAAK,mBAAmB,GAAG,SAAS,GAAG,UAAU,CAAC;AAClD,KAAK,oBAAoB,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,CAAC;AAE/D,MAAM,WAAW,uBAAuB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,mBAAmB,CAAA;KAAE,CAAC;IAC1D,WAAW,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,mBAAmB,CAAA;KAAE,CAAC,CAAC;CACrE;AAED,MAAM,WAAW,4BAA4B;IACzC,SAAS,EAAE,uBAAuB,CAAC;IACnC,QAAQ,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,oBAAoB,CAAA;KAAE,CAAC;IACzD,WAAW,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,mBAAmB,CAAA;KAAE,CAAC;IAC3D,YAAY,EAAE;QAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,MAAM,EAAE,KAAK,GAAG,WAAW,CAAA;KAAE,CAAC;CACpE;AAED,MAAM,WAAW,4BAA4B;IACzC,SAAS,EAAE,uBAAuB,CAAC;IACnC,SAAS,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,mBAAmB,CAAA;KAAE,CAAC;CAC5D;AAED,MAAM,WAAW,2BAA2B;IACxC,SAAS,EAAE,uBAAuB,CAAC;IACnC,QAAQ,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,OAAO,CAAC,oBAAoB,EAAE,SAAS,CAAC,CAAA;KAAE,CAAC;IAC7E,YAAY,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,KAAK,GAAG,UAAU,CAAA;KAAE,CAAC;CAC5D;AAED,MAAM,WAAW,2BAA2B;IACxC,SAAS,EAAE,uBAAuB,CAAC;IACnC,QAAQ,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,SAAS,GAAG,UAAU,CAAA;KAAE,CAAC;IAC3D,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,MAAM,EAAE,KAAK,GAAG,UAAU,GAAG,YAAY,CAAC;CAC7C;AAED,MAAM,WAAW,qBAAqB;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,sBAAsB,EAAE,OAAO,CAAC;IAChC,sBAAsB,EAAE,OAAO,CAAC;IAChC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,iBAAiB,EAAE,OAAO,GAAG,IAAI,CAAC;IAClC,MAAM,EAAE,KAAK,CAAC;QACV,EAAE,EAAE,MAAM,CAAC;QACX,SAAS,EAAE,OAAO,CAAC;QACnB,UAAU,EAAE,OAAO,CAAC;QACpB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;KAChC,CAAC,CAAC;IACH,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,sBAAsB,EAAE,MAAM,CAAC;CAClC;AAED,MAAM,WAAW,0BAA0B;IACvC,OAAO,EAAE,OAAO,CAAC;CACpB;AAED,KAAK,uBAAuB,GAAG;IAC3B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,gBAAgB,EAAE,CAAC;CAC9B,CAAC;AA4lCF,wBAAsB,uBAAuB,CACzC,aAAa,GAAE,MAAsB,GACtC,OAAO,CAAC,uBAAuB,CAAC,CAgClC;AAED,wBAAsB,4BAA4B,CAC9C,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,uBAA4B,EACrC,aAAa,GAAE,MAAsB,GACtC,OAAO,CAAC,4BAA4B,CAAC,CA8GvC;AAED,wBAAsB,4BAA4B,CAC9C,YAAY,EAAE,MAAM,EACpB,aAAa,GAAE,MAAsB,GACtC,OAAO,CAAC,4BAA4B,CAAC,CAgBvC;AAED,wBAAsB,wBAAwB,CAC1C,YAAY,EAAE,MAAM,EACpB,aAAa,GAAE,MAAsB,GACtC,OAAO,CAAC,2BAA2B,CAAC,CAqCtC;AAED,wBAAsB,mCAAmC,CACrD,eAAe,EAAE,MAAM,EACvB,aAAa,GAAE,MAAsB,GACtC,OAAO,CAAC,2BAA2B,CAAC,CAmDtC;AAkGD,wBAAsB,sBAAsB,CACxC,aAAa,GAAE,MAAsB,GACtC,OAAO,CAAC,qBAAqB,CAAC,CA8ChC;AA4ED,wBAAsB,iBAAiB,CAAC,aAAa,GAAE,MAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CAa5F;AAED,wBAAsB,sBAAsB,CACxC,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,OAAO,GAAE,uBAA4B,EACrC,aAAa,GAAE,MAAsB,GACtC,OAAO,CAAC,IAAI,CAAC,CAuDf;AAED,wBAAsB,sBAAsB,CACxC,OAAO,EAAE,MAAM,EACf,aAAa,GAAE,MAAsB,GACtC,OAAO,CAAC,IAAI,CAAC,CAaf;AAED,wBAAsB,wBAAwB,CAC1C,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,aAAa,GAAE,MAAsB,GACtC,OAAO,CAAC,IAAI,CAAC,CAaf;AAED,wBAAsB,uBAAuB,CACzC,aAAa,GAAE,MAAsB,GACtC,OAAO,CAAC,IAAI,CAAC,CAIf;AAED,wBAAgB,mBAAmB,CAAC,EAAE,OAAO,EAAE,EAAE,0BAA0B,GAAG,IAAI,CAmGjF"}

package/dist/cli/commands/init.js

@@ -1,17 +1,21 @@
 import * as p from '@clack/prompts';
-import { deriveDisplayName, findProjectRegistryPath as findSharedProjectRegistryPath, getPrimaryApiKeyEnvVar, getProjectRegistryPath as getCanonicalProjectRegistryPath, ProjectRegistrySchema, readProjectRegistry as readSharedProjectRegistry, writeConfigFile, } from '@dexto/agent-management';
+import { createDextoAgentFromConfig, deriveDisplayName, findProjectRegistryPath as findSharedProjectRegistryPath, getPrimaryApiKeyEnvVar, getProjectRegistryPath as getCanonicalProjectRegistryPath, ProjectRegistrySchema, readProjectRegistry as readSharedProjectRegistry, writeConfigFile, } from '@dexto/agent-management';
 import chalk from 'chalk';
+import { spawn } from 'node:child_process';
 import { promises as fs } from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
+import { z } from 'zod';
 import { ExitSignal, safeExit, withAnalytics } from '../../analytics/wrapper.js';
+import { getEffectiveLLMConfig } from '../../config/effective-llm.js';
 import { getDeployConfigPath, isWorkspaceDeployAgent, loadDeployConfig } from './deploy/config.js';
 import { discoverPrimaryWorkspaceAgent } from './deploy/entry-agent.js';
-import { selectOrExit, textOrExit } from '../utils/prompt-helpers.js';
+import { confirmOrExit, multiselectOrExit, selectOrExit, textOrExit, } from '../utils/prompt-helpers.js';
+import { ensureImageImporterConfigured } from '../utils/image-importer.js';
 const AGENTS_FILENAME = 'AGENTS.md';
 const WORKSPACE_DIRECTORIES = ['agents', 'skills'];
 const DEFAULT_AGENT_PROVIDER = 'openai';
 const DEFAULT_AGENT_MODEL = 'gpt-5.3-codex';
-const DEFAULT_AGENT_VERSION = '0.1.0';
 const DEFAULT_AGENTS_MD = `<!-- dexto-workspace -->
 
 # Dexto Workspace
@@ -27,7 +31,99 @@ This workspace can define project-specific agents and skills.
 - If no workspace agent is defined, Dexto uses your global default agent locally
 - Cloud deploys without a workspace agent use the managed cloud default agent
 `;
+const CORE_AGENT_TOOL_ENTRIES = [
+    {
+        type: 'builtin-tools',
+        enabledTools: ['ask_user', 'invoke_skill', 'sleep'],
+    },
+];
+const ALWAYS_ENABLED_AGENT_TOOL_ENTRIES = [
+    { type: 'creator-tools' },
+    { type: 'agent-spawner' },
+];
+const AGENT_TOOL_BUNDLES = [
+    {
+        id: 'workspace',
+        label: 'Filesystem & Terminal',
+        hint: 'Read files and run commands in the workspace',
+        entries: [{ type: 'filesystem-tools' }, { type: 'process-tools' }],
+    },
+    {
+        id: 'research',
+        label: 'Research and web',
+        hint: 'Search the web, fetch URLs, and gather outside context',
+        entries: [
+            {
+                type: 'builtin-tools',
+                enabledTools: ['code_search', 'http_request', 'web_search'],
+            },
+        ],
+    },
+    {
+        id: 'planning',
+        label: 'Planning and tasks',
+        hint: 'Track todos and keep structured plans',
+        entries: [{ type: 'todo-tools' }, { type: 'plan-tools' }],
+    },
+    {
+        id: 'memory',
+        label: 'Memory and history',
+        hint: 'Search conversation history, logs, and stored memories',
+        entries: [{ type: 'lifecycle-tools' }],
+    },
+    {
+        id: 'automation',
+        label: 'Automation',
+        hint: 'Schedule recurring jobs and proactive work',
+        entries: [{ type: 'scheduler-tools' }],
+    },
+];
+const DEFAULT_AGENT_TOOL_BUNDLE_IDS = ['workspace', 'planning'];
 const ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const PROMPT_GENERATOR_AGENT_ID = 'init-agent-prompt-generator';
+const GeneratedSystemPromptPayloadSchema = z
+    .object({
+    systemPrompt: z.string().trim().min(1),
+})
+    .strict();
+const AGENT_PROMPT_GENERATOR_SYSTEM_PROMPT = [
+    'You design production-grade system prompts for Dexto agents.',
+    'Your output will be written directly into agent YAML.',
+    '',
+    'Return only valid JSON with this exact shape:',
+    '{"systemPrompt":"..."}',
+    '',
+    'Prompt requirements:',
+    '- Start with "You are <agent name>..."',
+    '- Turn the role description into a strong, practical operating prompt',
+    '- Keep it general enough to work across different workspaces',
+    '- Focus on responsibilities, operating principles, communication style, and constraints',
+    '- Instruct the agent to understand the current workspace and context before acting',
+    '- Tell the agent to surface risks, assumptions, and follow-up work when relevant',
+    '- Mention tools abstractly instead of naming specific tool ids unless explicitly requested',
+    '- If the agent is a subagent, include delegation guidance for working on behalf of a parent agent',
+    '- Do not include markdown code fences or extra wrapper text',
+].join('\n');
+function buildInteractiveAgentIdentity(nameInput) {
+    const trimmed = nameInput.trim();
+    if (!trimmed) {
+        throw new Error('Agent name is required.');
+    }
+    const agentId = trimmed
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    if (!agentId) {
+        throw new Error('Agent name must include letters or numbers.');
+    }
+    return {
+        agentId: normalizeScaffoldId(agentId, 'agent'),
+        displayName: /[\sA-Z]/.test(trimmed) ? trimmed : deriveDisplayName(agentId),
+    };
+}
+function getAgentDisplayName(agentId, options) {
+    return options.displayName?.trim() || deriveDisplayName(agentId);
+}
 function isSubagentEntry(entry) {
     return (entry.tags?.includes('subagent') ?? false) || Boolean(entry.parentAgentId);
 }
@@ -118,6 +214,9 @@ async function loadInitialAgentLlmConfig() {
     };
 }
 function buildAgentDescription(agentId, options) {
+    if (options.description?.trim()) {
+        return options.description.trim();
+    }
     if (options.subagent) {
         return `Workspace sub-agent '${agentId}' for delegated tasks.`;
     }
@@ -126,107 +225,463 @@ function buildAgentDescription(agentId, options) {
     }
     return `Workspace agent '${agentId}' for this project.`;
 }
-async function buildAgentConfig(agentId, options) {
-    const llmConfig = await loadInitialAgentLlmConfig();
-    const displayName = deriveDisplayName(agentId);
-    const description = buildAgentDescription(agentId, options);
-    const llm = {
-        provider: llmConfig.provider,
-        model: llmConfig.model,
-        apiKey: llmConfig.apiKey,
-    };
-    return {
-        image: '@dexto/image-local',
-        agentId,
-        agentCard: {
-            name: displayName,
-            description,
-            url: `https://example.com/agents/${agentId}`,
-            version: DEFAULT_AGENT_VERSION,
-        },
-        systemPrompt: options.subagent
+function buildDefaultGeneratedPrompt(displayName, options) {
+    const roleLabel = options.subagent ? 'specialized workspace subagent' : 'workspace agent';
+    return [
+        `You are ${displayName}, a ${roleLabel}.`,
+        '',
+        'Your role and focus:',
+        '- Replace this section with the responsibilities you want this agent to own.',
+        '',
+        'Operating principles:',
+        '- Read the relevant files and current state before taking action.',
+        '- Keep responses concrete, direct, and grounded in the workspace.',
+        '- Make the smallest correct change that moves the task forward.',
+        '- Call out assumptions, risks, and follow-up work clearly.',
+        ...(options.subagent
             ? [
-                `You are ${displayName}, a specialized sub-agent for this workspace.`,
-                '',
-                'Complete delegated tasks efficiently and concisely.',
-                'Read the relevant files before responding.',
-                'Return a clear result to the parent agent with concrete findings or next steps.',
-            ].join('\n')
-            : [
-                `You are ${displayName}, the workspace agent for this project.`,
                 '',
-                'Help the user understand, edit, run, and deploy the files in this workspace.',
-                'Read relevant files before making changes.',
-                'Keep changes focused and explain what changed.',
-            ].join('\n'),
-        greeting: options.subagent
-            ? `Ready to help as ${displayName}.`
-            : 'Ready to work in this workspace.',
-        llm,
-        permissions: {
-            mode: 'manual',
-            allowedToolsStorage: 'storage',
-        },
-    };
+                'Delegation guidance:',
+                '- Complete delegated work efficiently and return a crisp result to the parent agent.',
+            ]
+            : []),
+    ].join('\n');
 }
-function buildRegistryEntry(agentId, options) {
-    const description = buildAgentDescription(agentId, options);
+function buildScaffoldSystemPrompt(displayName, options) {
+    if (options.subagent) {
+        return [
+            `You are ${displayName}, a specialized sub-agent for this workspace.`,
+            '',
+            'Complete delegated tasks efficiently and concisely.',
+            'Read the relevant files before responding.',
+            'Return a clear result to the parent agent with concrete findings or next steps.',
+        ].join('\n');
+    }
+    return [
+        `You are ${displayName}, the workspace agent for this project.`,
+        '',
+        'Help the user understand, edit, run, and deploy the files in this workspace.',
+        'Read relevant files before making changes.',
+        'Keep changes focused and explain what changed.',
+    ].join('\n');
+}
+function buildSystemPromptConfig(systemPrompt) {
     return {
-        id: agentId,
-        name: deriveDisplayName(agentId),
-        description,
-        configPath: `./${agentId}/${agentId}.yml`,
-        ...(options.subagent ? { tags: ['subagent'] } : {}),
+        contributors: [
+            {
+                id: 'primary',
+                type: 'static',
+                priority: 0,
+                content: systemPrompt,
+            },
+            {
+                id: 'date',
+                type: 'dynamic',
+                priority: 10,
+                source: 'date',
+            },
+            {
+                id: 'env',
+                type: 'dynamic',
+                priority: 15,
+                source: 'env',
+            },
+        ],
     };
 }
-function addSubagentTag(entry) {
-    const tags = new Set(entry.tags ?? []);
-    tags.add('subagent');
+function extractJsonObjectFromResponse(content) {
+    const trimmed = content.trim();
+    if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
+        return trimmed;
+    }
+    const fencedMatch = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    if (fencedMatch?.[1]) {
+        return fencedMatch[1].trim();
+    }
+    const firstBrace = trimmed.indexOf('{');
+    const lastBrace = trimmed.lastIndexOf('}');
+    if (firstBrace >= 0 && lastBrace > firstBrace) {
+        return trimmed.slice(firstBrace, lastBrace + 1);
+    }
+    throw new Error('Prompt generator did not return valid JSON.');
+}
+function parseGeneratedSystemPromptResponse(content) {
+    const parsed = JSON.parse(extractJsonObjectFromResponse(content));
+    return GeneratedSystemPromptPayloadSchema.parse(parsed).systemPrompt;
+}
+function buildPromptGenerationRequest(displayName, roleDescription, options) {
+    return [
+        'Generate a Dexto system prompt from this brief.',
+        '',
+        `Agent name: ${displayName}`,
+        `Agent type: ${options.subagent ? 'workspace subagent' : 'workspace agent'}`,
+        `Role description: ${normalizeInteractiveDescription(roleDescription)}`,
+        '',
+        'Additional guidance:',
+        '- Make the prompt concrete and opinionated, not generic filler',
+        '- Prefer short sections and useful bullet points over long prose',
+        '- Assume tool access may vary by workspace, so keep tool guidance capability-based',
+        '- Avoid references to specific repositories, companies, or file names',
+        '',
+        'Return JSON only.',
+    ].join('\n');
+}
+async function generateAgentSystemPromptFromDescription(displayName, roleDescription, options) {
+    await ensureImageImporterConfigured();
+    const effectiveLLM = await getEffectiveLLMConfig();
+    if (!effectiveLLM) {
+        throw new Error('No active LLM configuration is available for prompt generation. Configure one with `dexto setup` first.');
+    }
+    const spinner = p.spinner();
+    spinner.start('Generating system prompt...');
+    const generatorAgent = await createDextoAgentFromConfig({
+        agentIdOverride: PROMPT_GENERATOR_AGENT_ID,
+        enrichOptions: {
+            isInteractiveCli: false,
+            skipPluginDiscovery: true,
+        },
+        config: {
+            image: '@dexto/image-local',
+            systemPrompt: buildSystemPromptConfig(AGENT_PROMPT_GENERATOR_SYSTEM_PROMPT),
+            llm: {
+                provider: effectiveLLM.provider,
+                model: effectiveLLM.model,
+                ...(effectiveLLM.apiKey ? { apiKey: effectiveLLM.apiKey } : {}),
+                ...(effectiveLLM.baseURL ? { baseURL: effectiveLLM.baseURL } : {}),
+            },
+            storage: {
+                cache: { type: 'in-memory' },
+                database: { type: 'in-memory' },
+                blob: { type: 'in-memory' },
+            },
+            permissions: {
+                mode: 'auto-deny',
+                allowedToolsStorage: 'memory',
+            },
+            elicitation: {
+                enabled: false,
+            },
+            tools: [],
+        },
+    });
+    try {
+        await generatorAgent.start();
+        const session = await generatorAgent.createSession(PROMPT_GENERATOR_AGENT_ID);
+        const response = await generatorAgent.generate(buildPromptGenerationRequest(displayName, roleDescription, options), session.id);
+        const systemPrompt = parseGeneratedSystemPromptResponse(response.content);
+        spinner.stop(chalk.green('Generated system prompt'));
+        return systemPrompt;
+    }
+    catch (error) {
+        spinner.stop(chalk.red('Failed to generate system prompt'));
+        throw new Error(`Could not generate a system prompt automatically: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    finally {
+        await generatorAgent.stop().catch(() => undefined);
+    }
+}
+function encodePromptForTextInput(systemPrompt) {
+    return systemPrompt.replace(/\n/g, '\\n');
+}
+function decodePromptFromTextInput(systemPrompt) {
+    return systemPrompt.replace(/\\n/g, '\n').trim();
+}
+function normalizeInteractiveDescription(description) {
+    const trimmed = description.trim().replace(/\s+/g, ' ');
+    if (!trimmed) {
+        return trimmed;
+    }
+    return /[.!?]$/.test(trimmed) ? trimmed : `${trimmed}.`;
+}
+function cloneToolEntry(entry) {
+    const maybeEnabledTools = entry.enabledTools;
     return {
         ...entry,
-        tags: Array.from(tags).sort(),
+        ...(Array.isArray(maybeEnabledTools)
+            ? {
+                enabledTools: maybeEnabledTools.filter((tool) => typeof tool === 'string'),
+            }
+            : {}),
     };
 }
-function validateInitAgentOptions(options) {
-    if (options.primary && options.subagent) {
-        throw new Error('A sub-agent cannot also be the primary workspace agent.');
+function mergeToolEntries(entries) {
+    const merged = new Map();
+    for (const entry of entries) {
+        const existing = merged.get(entry.type);
+        if (!existing) {
+            merged.set(entry.type, cloneToolEntry(entry));
+            continue;
+        }
+        const existingEnabledTools = existing.enabledTools;
+        const nextEnabledTools = entry.enabledTools;
+        if (Array.isArray(existingEnabledTools) && Array.isArray(nextEnabledTools)) {
+            merged.set(entry.type, {
+                ...existing,
+                enabledTools: Array.from(new Set([
+                    ...existingEnabledTools.filter((tool) => typeof tool === 'string'),
+                    ...nextEnabledTools.filter((tool) => typeof tool === 'string'),
+                ])),
+            });
+            continue;
+        }
+        if (!Array.isArray(existingEnabledTools) && Array.isArray(nextEnabledTools)) {
+            continue;
+        }
+        if (Array.isArray(existingEnabledTools) && !Array.isArray(nextEnabledTools)) {
+            merged.set(entry.type, cloneToolEntry(entry));
+            continue;
+        }
+        merged.set(entry.type, cloneToolEntry(entry));
+    }
+    return Array.from(merged.values());
+}
+function buildToolConfigFromBundleIds(bundleIds) {
+    const selectedBundleEntries = bundleIds.flatMap((bundleId) => {
+        const bundle = AGENT_TOOL_BUNDLES.find((entry) => entry.id === bundleId);
+        return bundle?.entries ?? [];
+    });
+    return mergeToolEntries([
+        ...CORE_AGENT_TOOL_ENTRIES,
+        ...ALWAYS_ENABLED_AGENT_TOOL_ENTRIES,
+        ...selectedBundleEntries,
+    ]);
+}
+function formatBundleSelection(bundleIds) {
+    if (bundleIds.length === 0) {
+        return 'Core utilities only';
+    }
+    return bundleIds
+        .map((bundleId) => AGENT_TOOL_BUNDLES.find((bundle) => bundle.id === bundleId)?.label ?? bundleId)
+        .join(', ');
+}
+function renderPromptPreview(systemPrompt) {
+    console.log(`\n${chalk.cyan.bold('System Prompt Preview')}`);
+    console.log(chalk.dim('Review the full prompt before continuing.\n'));
+    console.log(systemPrompt);
+    console.log();
+}
+function getPreferredEditorCommand() {
+    const envEditor = process.env.VISUAL?.trim() || process.env.EDITOR?.trim();
+    if (envEditor) {
+        return envEditor;
     }
+    return process.platform === 'win32' ? 'notepad' : 'vi';
 }
-async function promptForAgentId(kind) {
-    const placeholder = kind === 'subagent'
-        ? 'explore-agent'
-        : kind === 'primary'
-            ? 'review-agent'
-            : 'helper-agent';
-    return await textOrExit({
-        message: 'Agent id',
-        placeholder,
+async function openFileInEditor(editorCommand, filePath) {
+    await new Promise((resolve, reject) => {
+        const child = spawn(editorCommand, [filePath], {
+            stdio: 'inherit',
+            shell: true,
+        });
+        child.once('error', reject);
+        child.once('exit', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`Editor exited with code ${code ?? 'unknown'}.`));
+        });
+    });
+}
+async function editSystemPromptInEditor(displayName, options, initialPrompt) {
+    const editorCommand = getPreferredEditorCommand();
+    const initialContent = initialPrompt ?? buildDefaultGeneratedPrompt(displayName, options);
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'dexto-agent-prompt-'));
+    const promptPath = path.join(tempDir, 'system-prompt.md');
+    try {
+        await fs.writeFile(promptPath, `${initialContent}\n`, 'utf8');
+        p.log.info(`Opening ${chalk.cyan(editorCommand)} for prompt editing. Save and close the editor to continue.`);
+        while (true) {
+            await openFileInEditor(editorCommand, promptPath);
+            const editedPrompt = (await fs.readFile(promptPath, 'utf8')).trim();
+            if (editedPrompt) {
+                return editedPrompt;
+            }
+            p.log.warn('System prompt was empty. Reopening the editor.');
+        }
+    }
+    finally {
+        await fs.rm(tempDir, { recursive: true, force: true }).catch(() => undefined);
+    }
+}
+async function promptForAgentName(initialValue) {
+    const rawName = await textOrExit({
+        message: 'Agent name',
+        ...(initialValue ? { initialValue } : {}),
+        placeholder: 'Review Agent',
         validate(value) {
             try {
-                normalizeScaffoldId(value, 'agent');
+                buildInteractiveAgentIdentity(value);
                 return undefined;
             }
             catch (error) {
-                return error instanceof Error ? error.message : 'Invalid agent id';
+                return error instanceof Error ? error.message : 'Invalid agent name';
             }
         },
     }, 'Agent initialization cancelled');
+    return buildInteractiveAgentIdentity(rawName);
 }
-async function resolveInitAgentInput(agentIdInput, options, workspaceRoot) {
-    validateInitAgentOptions(options);
-    if (agentIdInput) {
+async function promptForAvailableAgentName(workspaceRoot) {
+    const resolvedWorkspaceRoot = path.resolve(workspaceRoot);
+    let initialValue;
+    while (true) {
+        const identity = await promptForAgentName(initialValue);
+        const registryState = await loadWorkspaceProjectRegistry(resolvedWorkspaceRoot);
+        const existingEntry = getWorkspaceAgentEntry(registryState.registry, identity.agentId);
+        if (!existingEntry) {
+            return identity;
+        }
+        p.log.warn(`Agent '${identity.agentId}' already exists in ${path.relative(resolvedWorkspaceRoot, registryState.path)}. Choose a different name or run \`dexto init agent ${identity.agentId}\` to update the existing agent.`);
+        initialValue = identity.displayName;
+    }
+}
+async function promptForCustomSystemPrompt(displayName, options, initialPrompt) {
+    try {
+        return await editSystemPromptInEditor(displayName, options, initialPrompt);
+    }
+    catch (error) {
+        p.log.warn(`Could not open an editor cleanly. Falling back to inline prompt editing. ${error instanceof Error ? error.message : String(error)}`);
+        const rawPrompt = await textOrExit({
+            message: 'System prompt (use \\n for line breaks)',
+            initialValue: encodePromptForTextInput(initialPrompt ?? buildDefaultGeneratedPrompt(displayName, options)),
+            placeholder: encodePromptForTextInput(buildDefaultGeneratedPrompt(displayName, options)),
+            validate(value) {
+                const decoded = decodePromptFromTextInput(value);
+                return decoded ? undefined : 'System prompt is required';
+            },
+        }, 'Agent initialization cancelled');
+        return decodePromptFromTextInput(rawPrompt);
+    }
+}
+async function promptForReviewedCustomSystemPrompt(displayName, options, initialPrompt) {
+    let customPrompt = initialPrompt ?? '';
+    while (true) {
+        customPrompt = await promptForCustomSystemPrompt(displayName, options, customPrompt);
+        renderPromptPreview(customPrompt);
+        const confirmed = await confirmOrExit({
+            message: 'Use this system prompt?',
+            initialValue: true,
+        }, 'Agent initialization cancelled');
+        if (confirmed) {
+            return customPrompt;
+        }
+    }
+}
+async function promptForAgentSystemPrompt(displayName, options) {
+    const effectiveLLM = await getEffectiveLLMConfig();
+    if (!effectiveLLM) {
+        p.log.info('No active LLM configuration found. Opening the prompt editor instead. Run `dexto setup` to enable automatic prompt generation.');
         return {
-            agentId: normalizeScaffoldId(agentIdInput, 'agent'),
-            options,
+            mode: 'custom',
+            systemPrompt: await promptForReviewedCustomSystemPrompt(displayName, options),
+            description: null,
         };
     }
-    if (options.subagent || options.primary) {
-        const kind = options.subagent ? 'subagent' : 'primary';
+    const promptMode = await selectOrExit({
+        message: 'How do you want to create the system prompt?',
+        initialValue: 'generate',
+        options: [
+            {
+                value: 'generate',
+                label: 'Generate from description',
+                hint: 'Start from a short role description and review the full prompt',
+            },
+            {
+                value: 'custom',
+                label: 'Write custom prompt',
+                hint: 'Enter your own prompt text directly',
+            },
+        ],
+    }, 'Agent initialization cancelled');
+    if (promptMode === 'custom') {
         return {
-            agentId: normalizeScaffoldId(await promptForAgentId(kind), 'agent'),
-            options,
+            mode: 'custom',
+            systemPrompt: await promptForReviewedCustomSystemPrompt(displayName, options),
+            description: null,
         };
     }
+    let roleDescription = await textOrExit({
+        message: 'Describe this agent’s role',
+        placeholder: 'Reviews code changes, finds risks, and suggests focused fixes.',
+        validate(value) {
+            return value.trim() ? undefined : 'Role description is required';
+        },
+    }, 'Agent initialization cancelled');
+    let systemPrompt = await generateAgentSystemPromptFromDescription(displayName, roleDescription, options);
+    while (true) {
+        renderPromptPreview(systemPrompt);
+        const action = await selectOrExit({
+            message: 'What do you want to do with this prompt?',
+            initialValue: 'continue',
+            options: [
+                {
+                    value: 'continue',
+                    label: 'Continue',
+                    hint: 'Use this prompt as-is',
+                },
+                {
+                    value: 'edit',
+                    label: 'Edit prompt',
+                    hint: 'Make direct changes to the generated prompt',
+                },
+                {
+                    value: 'regenerate',
+                    label: 'Regenerate',
+                    hint: 'Update the role description and rebuild the prompt',
+                },
+            ],
+        }, 'Agent initialization cancelled');
+        if (action === 'continue') {
+            return {
+                mode: 'generate',
+                systemPrompt,
+                description: normalizeInteractiveDescription(roleDescription),
+            };
+        }
+        if (action === 'edit') {
+            systemPrompt = await promptForCustomSystemPrompt(displayName, options, systemPrompt);
+            continue;
+        }
+        roleDescription = await textOrExit({
+            message: 'Describe this agent’s role',
+            initialValue: roleDescription,
+            validate(value) {
+                return value.trim() ? undefined : 'Role description is required';
+            },
+        }, 'Agent initialization cancelled');
+        systemPrompt = await generateAgentSystemPromptFromDescription(displayName, roleDescription, options);
+    }
+}
+async function promptForAgentToolBundles() {
+    return await multiselectOrExit({
+        message: 'Select tool bundles (agent creation is enabled by default)',
+        initialValues: DEFAULT_AGENT_TOOL_BUNDLE_IDS,
+        options: AGENT_TOOL_BUNDLES.map((bundle) => ({
+            value: bundle.id,
+            label: bundle.label,
+            hint: bundle.hint,
+        })),
+    }, 'Agent initialization cancelled');
+}
+async function describePlannedAgentRole(options, workspaceRoot) {
+    const registryState = await loadWorkspaceProjectRegistry(path.resolve(workspaceRoot));
+    const currentPrimaryAgentId = getEffectiveWorkspacePrimaryAgentId(registryState.registry);
+    if (options.subagent) {
+        return currentPrimaryAgentId
+            ? `Subagent (will link to ${currentPrimaryAgentId})`
+            : 'Subagent (no primary agent available yet)';
+    }
+    if (options.primary) {
+        return currentPrimaryAgentId
+            ? `Primary agent (replaces ${currentPrimaryAgentId})`
+            : 'Primary agent';
+    }
+    return currentPrimaryAgentId ? 'Additional agent' : 'Primary agent (first workspace agent)';
+}
+async function resolveInteractiveAgentRoleOptions(options, workspaceRoot) {
+    if (options.subagent || options.primary) {
+        return options;
+    }
     const registryState = await loadWorkspaceProjectRegistry(path.resolve(workspaceRoot));
     const currentPrimaryAgentId = getEffectiveWorkspacePrimaryAgentId(registryState.registry);
     const kind = await selectOrExit({
@@ -252,10 +707,116 @@ async function resolveInitAgentInput(agentIdInput, options, workspaceRoot) {
             },
         ],
     }, 'Agent initialization cancelled');
-    const resolvedOptions = kind === 'primary' ? { primary: true } : kind === 'subagent' ? { subagent: true } : {};
     return {
-        agentId: normalizeScaffoldId(await promptForAgentId(kind), 'agent'),
-        options: resolvedOptions,
+        ...options,
+        ...(kind === 'primary' ? { primary: true } : {}),
+        ...(kind === 'subagent' ? { subagent: true } : {}),
+    };
+}
+async function buildAgentConfig(agentId, options) {
+    const llmConfig = await loadInitialAgentLlmConfig();
+    const displayName = getAgentDisplayName(agentId, options);
+    const systemPrompt = options.systemPrompt ?? buildScaffoldSystemPrompt(displayName, options);
+    const usesAskUser = options.tools === undefined ||
+        options.tools.some((entry) => {
+            if (entry.type !== 'builtin-tools' || entry.enabled === false) {
+                return false;
+            }
+            const maybeEnabledTools = entry.enabledTools;
+            return (!Array.isArray(maybeEnabledTools) ||
+                maybeEnabledTools.some((tool) => tool === 'ask_user'));
+        });
+    const llm = {
+        provider: llmConfig.provider,
+        model: llmConfig.model,
+        apiKey: llmConfig.apiKey,
+    };
+    return {
+        image: '@dexto/image-local',
+        systemPrompt: buildSystemPromptConfig(systemPrompt),
+        greeting: options.greeting ??
+            (options.subagent
+                ? `Ready to help as ${displayName}.`
+                : 'Ready to work in this workspace.'),
+        llm,
+        ...(options.tools ? { tools: options.tools } : {}),
+        permissions: {
+            mode: 'manual',
+            allowedToolsStorage: 'storage',
+        },
+        ...(usesAskUser
+            ? {
+                elicitation: {
+                    enabled: true,
+                },
+            }
+            : {}),
+    };
+}
+function buildRegistryEntry(agentId, options) {
+    const description = buildAgentDescription(agentId, options);
+    return {
+        id: agentId,
+        name: getAgentDisplayName(agentId, options),
+        description,
+        configPath: `./${agentId}/${agentId}.yml`,
+        ...(options.subagent ? { tags: ['subagent'] } : {}),
+    };
+}
+function addSubagentTag(entry) {
+    const tags = new Set(entry.tags ?? []);
+    tags.add('subagent');
+    return {
+        ...entry,
+        tags: Array.from(tags).sort(),
+    };
+}
+function validateInitAgentOptions(options) {
+    if (options.primary && options.subagent) {
+        throw new Error('A sub-agent cannot also be the primary workspace agent.');
+    }
+}
+async function resolveInitAgentInput(agentIdInput, options, workspaceRoot) {
+    validateInitAgentOptions(options);
+    if (agentIdInput) {
+        return {
+            agentId: normalizeScaffoldId(agentIdInput, 'agent'),
+            options,
+        };
+    }
+    const resolvedOptions = await resolveInteractiveAgentRoleOptions(options, workspaceRoot);
+    const identity = await promptForAvailableAgentName(workspaceRoot);
+    const promptResult = await promptForAgentSystemPrompt(identity.displayName, resolvedOptions);
+    const bundleIds = await promptForAgentToolBundles();
+    const roleSummary = await describePlannedAgentRole(resolvedOptions, workspaceRoot);
+    const selectedTools = buildToolConfigFromBundleIds(bundleIds);
+    p.note([
+        `${chalk.cyan('Name:')} ${chalk.bold(identity.displayName)}`,
+        `${chalk.cyan('Id:')} ${chalk.dim(identity.agentId)}`,
+        `${chalk.cyan('Workspace role:')} ${roleSummary}`,
+        `${chalk.cyan('System prompt:')} ${promptResult.mode === 'generate' ? 'Generated from description' : 'Custom'}`,
+        `${chalk.cyan('Tool bundles:')} ${formatBundleSelection(bundleIds)}`,
+        `${chalk.cyan('Core utilities:')} ask_user, invoke_skill, sleep`,
+        `${chalk.cyan('Agent creation:')} enabled by default`,
+    ].join('\n'), 'Agent Summary');
+    const confirmed = await confirmOrExit({
+        message: 'Create this agent?',
+        initialValue: true,
+    }, 'Agent initialization cancelled');
+    if (!confirmed) {
+        return null;
+    }
+    return {
+        agentId: identity.agentId,
+        options: {
+            ...resolvedOptions,
+            displayName: identity.displayName,
+            description: promptResult.description ??
+                buildAgentDescription(identity.agentId, resolvedOptions),
+            systemPrompt: promptResult.systemPrompt,
+            greeting: `Ready to help as ${identity.displayName}.`,
+            tools: selectedTools,
+        },
     };
 }
 function buildSkillTemplate(skillId) {
@@ -684,6 +1245,10 @@ export async function handleInitCommand(workspaceRoot = process.cwd()) {
 export async function handleInitAgentCommand(agentIdInput, options = {}, workspaceRoot = process.cwd()) {
     p.intro(chalk.inverse('Dexto Init Agent'));
     const resolved = await resolveInitAgentInput(agentIdInput, options, workspaceRoot);
+    if (!resolved) {
+        p.outro(chalk.yellow('Agent initialization cancelled.'));
+        return;
+    }
     const result = await createWorkspaceAgentScaffold(resolved.agentId, resolved.options, workspaceRoot);
     const subagentLinkResult = resolved.options.subagent
         ? await linkWorkspaceSubagentToPrimaryAgent(resolved.agentId, workspaceRoot)

package/dist/cli/commands/setup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/setup.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA6DxB,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0ClB,CAAC;AAEP,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAClE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AA6JtE;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,OAAO,CAAC,oBAAoB,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAmC9F"}
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/setup.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA+DxB,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0ClB,CAAC;AAEP,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAClE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAqKtE;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,OAAO,CAAC,oBAAoB,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAmC9F"}

package/dist/cli/commands/setup.js

@@ -1,12 +1,15 @@
 // packages/cli/src/cli/commands/setup.ts
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
 import chalk from 'chalk';
 import { z } from 'zod';
 import open from 'open';
 import { acceptsAnyModel, CodexAppServerClient, createCodexBaseURL, getDefaultModelForProvider, getCodexAuthModeLabel, getCodexProviderDisplayName, getCuratedModelsForProvider, getReasoningProfile, getSupportedModels, isCodexBaseURL, LLM_PROVIDERS, LLM_REGISTRY, logger, parseCodexBaseURL, isValidProviderModel, supportsCustomModels, requiresApiKey, resolveApiKeyForProvider, } from '@dexto/core';
-import { createInitialPreferences, saveGlobalPreferences, loadGlobalPreferences, getGlobalPreferencesPath, updateGlobalPreferences, setActiveModel, isDextoAuthEnabled, loadCustomModels, saveCustomModel, deleteCustomModel, globalPreferencesExist, } from '@dexto/agent-management';
+import { createInitialPreferences, saveGlobalPreferences, loadGlobalPreferences, getGlobalPreferencesPath, updateGlobalPreferences, setActiveModel, isDextoAuthEnabled, loadCustomModels, saveCustomModel, deleteCustomModel, globalPreferencesExist, getDextoGlobalPath, } from '@dexto/agent-management';
 import { interactiveApiKeySetup, hasApiKeyConfigured } from '../utils/api-key-setup.js';
 import { selectProvider, getProviderDisplayName, getProviderEnvVar, providerRequiresBaseURL, getDefaultModel, } from '../utils/provider-setup.js';
 import { setupLocalModels, setupOllamaModels, hasSelectedModel, getModelFromResult, } from '../utils/local-model-setup.js';
+import { executeCommand } from '../utils/self-management.js';
 import { requiresSetup } from '../utils/setup-utils.js';
 import { canUseDextoProvider } from '../utils/dexto-setup.js';
 import { handleAutoLogin } from './auth/login.js';
@@ -69,6 +72,13 @@ const REASONING_VARIANT_HINTS = {
     max: 'Maximum reasoning within provider limits',
     xhigh: 'Extra high reasoning',
 };
+const OPENAI_CODEX_PACKAGE = '@openai/codex';
+const DEXTO_DEPS_PACKAGE_JSON = {
+    name: 'dexto-deps',
+    version: '1.0.0',
+    private: true,
+    description: 'Managed dependencies for Dexto',
+};
 function toReasoningVariantLabel(variant, defaultVariant) {
     const normalized = variant.toLowerCase();
     const withKnownCasing = normalized === 'xhigh'
@@ -420,6 +430,104 @@ function getConfiguredProviderDisplayName(provider, baseURL) {
 function isCodexConfigured(provider, baseURL) {
     return provider === 'openai-compatible' && isCodexBaseURL(baseURL);
 }
+async function ensureDextoDepsPackageJson() {
+    const depsDir = getDextoGlobalPath('deps');
+    await fs.mkdir(depsDir, { recursive: true });
+    const packageJsonPath = path.join(depsDir, 'package.json');
+    try {
+        await fs.access(packageJsonPath);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+        await fs.writeFile(packageJsonPath, JSON.stringify(DEXTO_DEPS_PACKAGE_JSON, null, 2), 'utf-8');
+    }
+    return depsDir;
+}
+function isMissingCodexCliError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const code = error.code;
+    return (error.message.includes('Codex CLI not found on PATH') ||
+        error.message.includes('spawn codex ENOENT') ||
+        (code === 'ENOENT' && error.message.includes('spawn')));
+}
+function getCodexSetupErrorMessage(error) {
+    if (isMissingCodexCliError(error)) {
+        return 'Codex CLI not found on PATH. Install Codex to use ChatGPT Login in Dexto.';
+    }
+    return error instanceof Error ? error.message : String(error);
+}
+async function resolveCodexInstaller() {
+    const candidates = [
+        {
+            command: 'npm',
+            args: ['install', OPENAI_CODEX_PACKAGE, '--no-audit', '--no-fund'],
+            label: 'npm',
+        },
+        {
+            command: 'pnpm',
+            args: ['add', OPENAI_CODEX_PACKAGE],
+            label: 'pnpm',
+        },
+        {
+            command: 'bun',
+            args: ['add', OPENAI_CODEX_PACKAGE],
+            label: 'bun',
+        },
+    ];
+    for (const candidate of candidates) {
+        const probe = await executeCommand(candidate.command, ['--version']);
+        if (probe.code === 0) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function getCodexInstallerFailureMessage(installer, result) {
+    const details = `${result.stderr}\n${result.stdout}`
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    const lastLine = details.at(-1);
+    return lastLine
+        ? `Failed to install the OpenAI Codex CLI via ${installer.label}: ${lastLine}`
+        : `Failed to install the OpenAI Codex CLI via ${installer.label}.`;
+}
+async function installManagedCodexCli() {
+    const depsDir = await ensureDextoDepsPackageJson();
+    const installer = await resolveCodexInstaller();
+    if (!installer) {
+        throw new Error('Could not find npm, pnpm, or bun to install the OpenAI Codex CLI automatically.');
+    }
+    const result = await executeCommand(installer.command, installer.args, { cwd: depsDir });
+    if (result.code !== 0) {
+        throw new Error(getCodexInstallerFailureMessage(installer, result));
+    }
+}
+async function createCodexClientForSetup() {
+    try {
+        return await CodexAppServerClient.create();
+    }
+    catch (error) {
+        if (!isMissingCodexCliError(error)) {
+            throw error;
+        }
+        const spinner = p.spinner();
+        spinner.start('Installing OpenAI Codex CLI...');
+        try {
+            await installManagedCodexCli();
+            spinner.stop('OpenAI Codex CLI installed');
+        }
+        catch (installError) {
+            spinner.stop('OpenAI Codex CLI installation failed');
+            throw installError;
+        }
+        return await CodexAppServerClient.create();
+    }
+}
 async function ensureCodexChatGPTLogin(client) {
     const spinner = p.spinner();
     spinner.start('Starting ChatGPT login with Codex...');
@@ -510,7 +618,7 @@ async function handleCodexProviderSetup(options = {}) {
     console.log(chalk.cyan('\nChatGPT Login Setup\n'));
     let client = null;
     try {
-        client = await CodexAppServerClient.create();
+        client = await createCodexClientForSetup();
         const account = await ensureCodexChatGPTSession(client);
         if (!account || account.account?.type !== 'chatgpt') {
             return abort('Setup cancelled');
@@ -579,7 +687,7 @@ async function handleCodexProviderSetup(options = {}) {
         return true;
     }
     catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorMessage = getCodexSetupErrorMessage(error);
         p.log.error(`ChatGPT Login setup failed: ${errorMessage}`);
         return abort('Setup cancelled', 1);
     }
@@ -601,7 +709,7 @@ async function handleCodexChatGPTLoginRefresh(options = {}) {
     console.log(chalk.cyan('\nChatGPT Login\n'));
     let client = null;
     try {
-        client = await CodexAppServerClient.create();
+        client = await createCodexClientForSetup();
         const account = await ensureCodexChatGPTSession(client);
         if (!account || account.account?.type !== 'chatgpt') {
             return abort('ChatGPT login cancelled');
@@ -610,7 +718,7 @@ async function handleCodexChatGPTLoginRefresh(options = {}) {
         return true;
     }
     catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorMessage = getCodexSetupErrorMessage(error);
         p.log.error(`ChatGPT Login failed: ${errorMessage}`);
         return abort('ChatGPT login cancelled', 1);
     }

package/dist/cli/utils/image-importer.d.ts

@@ -0,0 +1,2 @@
+export declare function ensureImageImporterConfigured(): Promise<void>;
+//# sourceMappingURL=image-importer.d.ts.map

package/dist/cli/utils/image-importer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-importer.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/image-importer.ts"],"names":[],"mappings":"AAKA,wBAAsB,6BAA6B,IAAI,OAAO,CAAC,IAAI,CAAC,CAOnE"}

package/dist/cli/utils/image-importer.js

@@ -0,0 +1,10 @@
+import { setImageImporter } from '@dexto/agent-config';
+import { importImageModule } from './image-store.js';
+let imageImporterConfigured = false;
+export async function ensureImageImporterConfigured() {
+    if (imageImporterConfigured) {
+        return;
+    }
+    setImageImporter((specifier) => importImageModule(specifier));
+    imageImporterConfigured = true;
+}

package/dist/cli/utils/prompt-helpers.d.ts

@@ -8,6 +8,7 @@ import * as p from '@clack/prompts';
 type SelectOptions = Parameters<typeof p.select>[0];
 type TextOptions = Parameters<typeof p.text>[0];
 type ConfirmOptions = Parameters<typeof p.confirm>[0];
+type MultiselectOptions = Parameters<typeof p.multiselect>[0];
 /**
  * Select prompt that exits on cancel.
  * Use for linear flows where cancel should abort the entire operation.
@@ -43,5 +44,10 @@ export declare function textOrExit(options: TextOptions, cancelMessage?: string)
  * }, 'Operation cancelled');
  */
 export declare function confirmOrExit(options: ConfirmOptions, cancelMessage?: string): Promise<boolean>;
+/**
+ * Multiselect prompt that exits on cancel.
+ * Use for linear flows where cancel should abort the entire operation.
+ */
+export declare function multiselectOrExit<T extends string>(options: MultiselectOptions, cancelMessage?: string): Promise<T[]>;
 export {};
 //# sourceMappingURL=prompt-helpers.d.ts.map

package/dist/cli/utils/prompt-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prompt-helpers.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/prompt-helpers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,CAAC,MAAM,gBAAgB,CAAC;AAMpC,KAAK,aAAa,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AACpD,KAAK,WAAW,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;AAChD,KAAK,cAAc,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;AAMtD;;;;;;;;;GASG;AACH,wBAAsB,YAAY,CAAC,CAAC,SAAS,MAAM,EAC/C,OAAO,EAAE,aAAa,EACtB,aAAa,SAAc,GAC5B,OAAO,CAAC,CAAC,CAAC,CAOZ;AAED;;;;;;;;;GASG;AACH,wBAAsB,UAAU,CAC5B,OAAO,EAAE,WAAW,EACpB,aAAa,SAAc,GAC5B,OAAO,CAAC,MAAM,CAAC,CAOjB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAC/B,OAAO,EAAE,cAAc,EACvB,aAAa,SAAc,GAC5B,OAAO,CAAC,OAAO,CAAC,CAOlB"}
+{"version":3,"file":"prompt-helpers.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/prompt-helpers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,CAAC,MAAM,gBAAgB,CAAC;AAMpC,KAAK,aAAa,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AACpD,KAAK,WAAW,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;AAChD,KAAK,cAAc,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;AACtD,KAAK,kBAAkB,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;AAM9D;;;;;;;;;GASG;AACH,wBAAsB,YAAY,CAAC,CAAC,SAAS,MAAM,EAC/C,OAAO,EAAE,aAAa,EACtB,aAAa,SAAc,GAC5B,OAAO,CAAC,CAAC,CAAC,CAOZ;AAED;;;;;;;;;GASG;AACH,wBAAsB,UAAU,CAC5B,OAAO,EAAE,WAAW,EACpB,aAAa,SAAc,GAC5B,OAAO,CAAC,MAAM,CAAC,CAOjB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAC/B,OAAO,EAAE,cAAc,EACvB,aAAa,SAAc,GAC5B,OAAO,CAAC,OAAO,CAAC,CAOlB;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,CAAC,SAAS,MAAM,EACpD,OAAO,EAAE,kBAAkB,EAC3B,aAAa,SAAc,GAC5B,OAAO,CAAC,CAAC,EAAE,CAAC,CAOd"}

package/dist/cli/utils/prompt-helpers.js

@@ -64,3 +64,15 @@ export async function confirmOrExit(options, cancelMessage = 'Cancelled') {
     }
     return result;
 }
+/**
+ * Multiselect prompt that exits on cancel.
+ * Use for linear flows where cancel should abort the entire operation.
+ */
+export async function multiselectOrExit(options, cancelMessage = 'Cancelled') {
+    const result = await p.multiselect(options);
+    if (p.isCancel(result)) {
+        p.cancel(cancelMessage);
+        process.exit(0);
+    }
+    return result;
+}

package/dist/index-main.js

@@ -44,7 +44,7 @@ const cliVersion = resolveCliVersion();
 // Set CLI version for Dexto Gateway usage tracking
 process.env.DEXTO_CLI_VERSION = cliVersion;
 import { logger, getProviderFromModel, getAllSupportedModels, startLlmRegistryAutoUpdate, DextoAgent, isPath, resolveApiKeyForProvider, getPrimaryApiKeyEnvVar, } from '@dexto/core';
-import { applyImageDefaults, cleanNullValues, AgentConfigSchema, loadImage, resolveServicesFromConfig, setImageImporter, toDextoAgentOptions, } from '@dexto/agent-config';
+import { applyImageDefaults, cleanNullValues, AgentConfigSchema, loadImage, resolveServicesFromConfig, toDextoAgentOptions, } from '@dexto/agent-config';
 import { getDextoPackageRoot, resolveAgentPath, loadAgentConfig, findDextoProjectRoot, globalPreferencesExist, loadGlobalPreferences, resolveBundledScript, enrichAgentConfig, isDextoAuthEnabled, } from '@dexto/agent-management';
 import { validateCliOptions, handleCliOptionsError } from './cli/utils/options.js';
 import { validateAgentConfig } from './cli/utils/config-validation.js';
@@ -60,19 +60,11 @@ import { registerPluginCommand } from './cli/commands/plugin/register.js';
 import { registerAgentsCommand } from './cli/commands/agents/register.js';
 import { registerDeployCommand } from './cli/commands/deploy/register.js';
 import { registerInitCommand } from './cli/commands/init.js';
+import { ensureImageImporterConfigured } from './cli/utils/image-importer.js';
 const program = new Command();
-let imageImporterConfigured = false;
 let dextoApiKeyBootstrapped = false;
 let versionCheckPromise = null;
 let llmRegistryAutoUpdateStarted = false;
-async function ensureImageImporterConfigured() {
-    if (imageImporterConfigured) {
-        return;
-    }
-    const { importImageModule } = await import('./cli/utils/image-store.js');
-    setImageImporter((specifier) => importImageModule(specifier));
-    imageImporterConfigured = true;
-}
 async function ensureDextoApiKeyBootstrap() {
     if (dextoApiKeyBootstrapped) {
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dexto",
-  "version": "1.6.15",
+  "version": "1.6.16",
   "type": "module",
   "bin": {
     "dexto": "./dist/index.js"
@@ -34,16 +34,16 @@
     "ws": "^8.18.1",
     "yaml": "^2.7.1",
     "zod": "^3.25.0",
-    "@dexto/agent-config": "1.6.15",
-    "@dexto/agent-management": "1.6.15",
-    "@dexto/analytics": "1.6.15",
-    "@dexto/core": "1.6.15",
-    "@dexto/image-local": "1.6.15",
-    "@dexto/image-logger-agent": "1.6.15",
-    "@dexto/registry": "1.6.15",
-    "@dexto/server": "1.6.15",
-    "@dexto/storage": "1.6.15",
-    "@dexto/tui": "1.6.15"
+    "@dexto/agent-config": "1.6.16",
+    "@dexto/agent-management": "1.6.16",
+    "@dexto/analytics": "1.6.16",
+    "@dexto/core": "1.6.16",
+    "@dexto/image-local": "1.6.16",
+    "@dexto/image-logger-agent": "1.6.16",
+    "@dexto/registry": "1.6.16",
+    "@dexto/server": "1.6.16",
+    "@dexto/storage": "1.6.16",
+    "@dexto/tui": "1.6.16"
   },
   "devDependencies": {
     "@types/ws": "^8.5.11",