plazbot-cli 0.4.1 → 0.5.0

package/dist/commands/agent/ai-config.js

@@ -1,16 +1,21 @@
-import { Command } from 'commander';
+import { Command, Option } from 'commander';
 import { Agent } from 'plazbot';
 import inquirer from 'inquirer';
 import { getStoredCredentials } from '../../utils/credentials.js';
 import { logger } from '../../utils/logger.js';
-import { addExamples } from '../../utils/help.js';
+import { addExamples, addNotes } from '../../utils/help.js';
 import { describeAgentLoadError } from '../../utils/agent-errors.js';
 import { createSpinner, theme, section, kvPair } from '../../utils/ui.js';
-// Catalogo de modelos sincronizado con el front (AIModelSection.tsx).
-// Si se actualiza el dropdown del front, actualizar aqui tambien.
-const MODELS = {
+import { jsonOption, isJsonMode, printJson, fail, CliError } from '../../utils/output.js';
+import { requireInteractive } from '../../utils/confirm.js';
+export const AI_PROVIDERS = [
+    { value: 'openai', label: 'OpenAI' },
+    { value: 'claude', label: 'Anthropic (Claude)' },
+    { value: 'gemini', label: 'Google (Gemini)' },
+];
+export const AI_MODELS = {
     openai: [
-        // GPT-5.4 (flagship actual)
+        // GPT-5.4 (current flagship)
         'gpt-5.4', 'gpt-5.4-mini', 'gpt-5.4-nano',
         // GPT-5.2
         'gpt-5.2',
@@ -22,7 +27,7 @@ const MODELS = {
         'gpt-4.1', 'gpt-4.1-mini', 'gpt-4.1-nano',
         // GPT-4o
         'gpt-4o', 'gpt-4o-mini',
-        // Razonamiento (o-series)
+        // Reasoning (o-series)
         'o4-mini', 'o3', 'o3-mini', 'o1-2024-12-17',
         // Legacy
         'gpt-4-turbo', 'gpt-3.5-turbo',
@@ -38,7 +43,7 @@ const MODELS = {
         'claude-opus-4-1-20250805', 'claude-opus-4-20250514', 'claude-sonnet-4-20250514',
     ],
     gemini: [
-        // Gemini 3.1 (flagship actual)
+        // Gemini 3.1 (current flagship)
         'gemini-3.1-pro-preview', 'gemini-3.1-flash-lite-preview',
         // Gemini 2.5
         'gemini-2.5-pro', 'gemini-2.5-flash', 'gemini-2.5-flash-lite',
@@ -46,17 +51,135 @@ const MODELS = {
         'gemini-2.0-flash',
     ],
 };
-const DEFAULT_MODEL = {
+export const DEFAULT_AI_MODEL = {
     openai: 'gpt-4o',
     claude: 'claude-sonnet-4-6',
     gemini: 'gemini-2.5-pro',
 };
+export const DEFAULT_TEMPERATURE = 0.7;
+export const DEFAULT_MAX_TOKENS = 4096;
+export const MAX_TOKENS_LIMIT = 128000;
+const PROVIDER_ALIASES = {
+    openai: 'openai',
+    gpt: 'openai',
+    claude: 'claude',
+    anthropic: 'claude',
+    gemini: 'gemini',
+    google: 'gemini',
+};
+/** Maps user input (openai, anthropic, claude, google, gemini) to the API provider value. */
+export function normalizeProvider(value) {
+    const provider = PROVIDER_ALIASES[String(value || '').trim().toLowerCase()];
+    if (!provider) {
+        throw new CliError(`Unknown AI provider "${value}".`, 'invalid_provider', 'Use one of: openai, anthropic (claude), google (gemini).');
+    }
+    return provider;
+}
+/** Validates a temperature (0-2). */
+export function parseTemperature(value) {
+    const raw = String(value ?? '').trim();
+    const n = Number(raw);
+    if (raw === '' || !Number.isFinite(n) || n < 0 || n > 2) {
+        throw new CliError(`Invalid temperature "${value}".`, 'invalid_temperature', 'Use a number between 0 and 2 (e.g. 0.7).');
+    }
+    return n;
+}
+/** Validates max tokens (integer, 1-128000). */
+export function parseMaxTokens(value) {
+    const raw = String(value ?? '').trim();
+    const n = Number(raw);
+    if (raw === '' || !Number.isInteger(n) || n < 1 || n > MAX_TOKENS_LIMIT) {
+        throw new CliError(`Invalid max tokens "${value}".`, 'invalid_max_tokens', `Use a whole number between 1 and ${MAX_TOKENS_LIMIT} (e.g. 4096).`);
+    }
+    return n;
+}
+/** Masks a secret so it is never printed in full: "sk-p…a1B2". */
+export function maskToken(token) {
+    if (!token)
+        return '';
+    const t = String(token);
+    if (t.length <= 10)
+        return '••••';
+    return `${t.slice(0, 4)}…${t.slice(-4)}`;
+}
+/** Inquirer validator built from a parser that throws CliError. */
+export function validateWith(parser) {
+    return (v) => {
+        try {
+            parser(v);
+            return true;
+        }
+        catch (e) {
+            return e instanceof CliError ? `${e.message} ${e.hint || ''}`.trim() : 'Invalid value';
+        }
+    };
+}
+function warnIfUnknownModel(provider, model) {
+    if (!AI_MODELS[provider].includes(model)) {
+        logger.warning(`Model "${model}" is not in the known ${provider} list. It will be saved as is; make sure the provider accepts it.`);
+    }
+}
+function publicProviders(providers) {
+    return (providers || []).map((p) => ({
+        provider: p.provider,
+        model: p.model,
+        apiToken: maskToken(p.apiToken),
+        temperature: p.temperature,
+        maxTokens: p.maxTokens,
+        isDefault: !!p.isDefault,
+    }));
+}
+function printCurrentConfig(agentData, agentId) {
+    console.log(section('AI configuration - ' + (agentData.name || agentId)));
+    const providers = agentData.aiProviders || [];
+    if (providers.length > 0 && agentData.customAIConfig) {
+        providers.forEach((p) => {
+            console.log(kvPair('  Provider', p.provider));
+            console.log(kvPair('  Model', p.model));
+            console.log(kvPair('  API token', p.apiToken ? maskToken(p.apiToken) : theme.warning('not set')));
+            console.log(kvPair('  Temperature', String(p.temperature ?? DEFAULT_TEMPERATURE)));
+            console.log(kvPair('  Max tokens', String(p.maxTokens ?? '-')));
+            console.log(kvPair('  Default', p.isDefault ? 'Yes' : 'No'));
+            console.log();
+        });
+    }
+    else {
+        console.log(theme.muted('\n  Using the platform default AI (Plazbot)\n'));
+    }
+}
+function stripIds(data) {
+    const { id: _id1, _id: _id2, ...rest } = data;
+    return rest;
+}
 export const aiConfigCommand = new Command('ai-config')
-    .description('Configure the agent AI provider')
-    .argument('<agentId>', 'Agent ID')
+    .description("Show or change the agent's AI provider, model and API token")
+    .argument('<agentId>', 'Agent ID (e.g. age_AbcDef123)')
+    .option('--show', 'Print the current AI configuration and exit (tokens are masked)')
+    .addOption(new Option('--provider <provider>', 'AI provider: openai, anthropic (claude) or google (gemini)'))
+    .option('--model <id>', 'Model ID (default depends on the provider, e.g. gpt-4o, claude-sonnet-4-6)')
+    .option('--api-token <token>', "Provider API key (kept from the current config when the provider doesn't change)")
+    .option('--temperature <0-2>', `Sampling temperature between 0 and 2 (default: ${DEFAULT_TEMPERATURE})`)
+    .option('--max-tokens <n>', `Maximum tokens per response, 1-${MAX_TOKENS_LIMIT} (default: ${DEFAULT_MAX_TOKENS})`)
+    .option('--default', 'Drop the custom provider and use the platform default AI')
+    .addOption(jsonOption())
     .option('--dev', 'Use development environment', false)
     .action(async (agentId, options) => {
     try {
+        const hasSetFlags = !!(options.provider || options.model || options.apiToken || options.temperature !== undefined || options.maxTokens !== undefined);
+        if (options.default && hasSetFlags) {
+            throw new CliError('--default cannot be combined with --provider, --model, --api-token, --temperature or --max-tokens.', 'conflicting_flags');
+        }
+        if (options.show && (hasSetFlags || options.default)) {
+            throw new CliError('--show cannot be combined with flags that change the configuration.', 'conflicting_flags');
+        }
+        // Validate flag values before any API call
+        const flagProvider = options.provider ? normalizeProvider(options.provider) : undefined;
+        const flagTemperature = options.temperature !== undefined ? parseTemperature(options.temperature) : undefined;
+        const flagMaxTokens = options.maxTokens !== undefined ? parseMaxTokens(options.maxTokens) : undefined;
+        const interactive = !options.show && !options.default && !hasSetFlags;
+        if (interactive) {
+            requireInteractive('The AI configuration menu', `Pass flags instead, e.g. plazbot agent ai-config ${agentId} --provider openai --model gpt-4o --api-token sk-..., or use --show / --default.`);
+        }
         const credentials = await getStoredCredentials();
         const agent = new Agent({
             workspaceId: credentials.workspace,
@@ -74,79 +197,157 @@ export const aiConfigCommand = new Command('ai-config')
         }
         catch (loadErr) {
             spinner.stop();
-            logger.error(describeAgentLoadError(loadErr, agentId, credentials, { dev: options.dev }));
-            process.exit(1);
+            throw new CliError(describeAgentLoadError(loadErr, agentId, credentials, { dev: options.dev }), 'agent_not_found');
         }
-        console.log(section('AI Configuration - ' + (agentData.name || agentId)));
         const currentProviders = agentData.aiProviders || [];
-        if (currentProviders.length > 0 && agentData.customAIConfig) {
-            console.log(theme.bold('\n  Current configuration:'));
-            currentProviders.forEach((p) => {
-                console.log(kvPair('  Provider', p.provider));
-                console.log(kvPair('  Model', p.model));
-                console.log(kvPair('  Temperature', String(p.temperature)));
-                console.log(kvPair('  Max Tokens', String(p.maxTokens)));
-                console.log(kvPair('  Default', p.isDefault ? 'Yes' : 'No'));
-            });
+        const current = agentData.customAIConfig
+            ? (currentProviders.find((p) => p.isDefault) || currentProviders[0])
+            : undefined;
+        const saveDefault = async () => {
+            const s = createSpinner('Switching to the platform default AI...');
+            s.start();
+            await agent.updateAgent(agentId, stripIds({ ...agentData, customAIConfig: false, aiProviders: [] }));
+            s.succeed('Using the platform default AI (Plazbot)');
+            if (isJsonMode())
+                printJson({ id: agentId, provider: 'default', model: null, updated: true });
+        };
+        const saveProvider = async (p) => {
+            const s = createSpinner('Saving AI configuration...');
+            s.start();
+            await agent.updateAgent(agentId, stripIds({
+                ...agentData,
+                customAIConfig: true,
+                aiProviders: [{ ...p, isDefault: true }],
+            }));
+            s.succeed(`AI provider set: ${p.provider} / ${p.model} (token ${maskToken(p.apiToken)})`);
+            if (isJsonMode())
+                printJson({ id: agentId, provider: p.provider, model: p.model, updated: true });
+        };
+        // --show
+        if (options.show) {
+            if (isJsonMode()) {
+                printJson({
+                    id: agentId,
+                    name: agentData.name,
+                    customAIConfig: !!agentData.customAIConfig,
+                    providers: agentData.customAIConfig ? publicProviders(currentProviders) : [],
+                });
+            }
+            else {
+                printCurrentConfig(agentData, agentId);
+            }
+            return;
         }
-        else {
-            console.log(theme.muted('\n  Using default AI configuration (Plazbot)'));
+        // --default
+        if (options.default) {
+            await saveDefault();
+            return;
+        }
+        // Non-interactive set via flags
+        if (hasSetFlags) {
+            const provider = flagProvider || current?.provider;
+            if (!provider) {
+                throw new CliError('This agent uses the platform default AI, so --provider is required.', 'missing_provider', 'Pass --provider openai|anthropic|google and --api-token <token>.');
+            }
+            const sameProvider = !!current && current.provider === provider;
+            const apiToken = options.apiToken || (sameProvider ? current.apiToken : '');
+            if (!apiToken) {
+                throw new CliError(`An API token is required for ${provider}.`, 'missing_api_token', 'Pass it with --api-token <token>.');
+            }
+            const model = options.model || (sameProvider && current.model) || DEFAULT_AI_MODEL[provider];
+            warnIfUnknownModel(provider, model);
+            await saveProvider({
+                provider,
+                model,
+                apiToken,
+                temperature: flagTemperature ?? (sameProvider ? current.temperature : undefined) ?? DEFAULT_TEMPERATURE,
+                maxTokens: flagMaxTokens ?? (sameProvider ? current.maxTokens : undefined) ?? DEFAULT_MAX_TOKENS,
+            });
+            return;
         }
+        // Interactive
+        printCurrentConfig(agentData, agentId);
         const { action } = await inquirer.prompt([{
                 type: 'list',
                 name: 'action',
                 message: 'What would you like to do?',
                 choices: [
-                    { name: 'Configure new provider', value: 'set' },
-                    { name: 'Use default configuration', value: 'reset' },
+                    { name: 'Set a custom AI provider', value: 'set' },
+                    { name: 'Use the platform default AI', value: 'reset' },
                     { name: 'Exit', value: 'exit' },
                 ],
             }]);
         if (action === 'exit')
             return;
         if (action === 'reset') {
-            const { id, _id, ...resetConfig } = { ...agentData, customAIConfig: false, aiProviders: [] };
-            const resetSpinner = createSpinner('Resetting configuration...');
-            resetSpinner.start();
-            await agent.updateAgent(agentId, resetConfig);
-            resetSpinner.succeed('Using default configuration');
+            await saveDefault();
             return;
         }
-        // Configurar nuevo proveedor
-        const ai = await inquirer.prompt([
-            { type: 'list', name: 'provider', message: 'Provider:', choices: ['openai', 'claude', 'gemini'] },
-        ]);
-        const models = MODELS[ai.provider] || MODELS.openai;
-        const config = await inquirer.prompt([
-            { type: 'list', name: 'model', message: 'Model:', choices: models, default: DEFAULT_MODEL[ai.provider] },
-            { type: 'password', name: 'apiToken', message: 'API Token:', mask: '*', validate: (v) => v.length > 0 || 'Required' },
-            { type: 'number', name: 'temperature', message: 'Temperature (0-2):', default: 0.7 },
-            { type: 'number', name: 'maxTokens', message: 'Max tokens (1024-16384):', default: 4096 },
+        const { provider } = await inquirer.prompt([{
+                type: 'list',
+                name: 'provider',
+                message: 'Provider:',
+                choices: AI_PROVIDERS.map(p => ({ name: p.label, value: p.value })),
+                default: current?.provider || 'openai',
+            }]);
+        const providerId = provider;
+        const sameProvider = !!current && current.provider === providerId;
+        const keepToken = sameProvider && !!current.apiToken;
+        const answers = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'model',
+                message: 'Model:',
+                choices: AI_MODELS[providerId],
+                default: (sameProvider && AI_MODELS[providerId].includes(current.model)) ? current.model : DEFAULT_AI_MODEL[providerId],
+                pageSize: 12,
+            },
+            {
+                type: 'password',
+                name: 'apiToken',
+                message: keepToken ? `API token (leave empty to keep ${maskToken(current.apiToken)}):` : 'API token:',
+                mask: '*',
+                validate: (v) => (v.trim().length > 0 || keepToken) ? true : 'The API token is required',
+            },
+            {
+                type: 'input',
+                name: 'temperature',
+                message: 'Temperature (0-2):',
+                default: String((sameProvider ? current.temperature : undefined) ?? DEFAULT_TEMPERATURE),
+                validate: validateWith(parseTemperature),
+            },
+            {
+                type: 'input',
+                name: 'maxTokens',
+                message: `Max tokens per response (1-${MAX_TOKENS_LIMIT}):`,
+                default: String((sameProvider ? current.maxTokens : undefined) || DEFAULT_MAX_TOKENS),
+                validate: validateWith(parseMaxTokens),
+            },
         ]);
-        const { id: _uid, _id: _oid, ...updatedConfig } = {
-            ...agentData,
-            customAIConfig: true,
-            aiProviders: [{
-                    provider: ai.provider,
-                    model: config.model,
-                    apiToken: config.apiToken,
-                    temperature: config.temperature,
-                    maxTokens: config.maxTokens,
-                    isDefault: true,
-                }],
-        };
-        const updateSpinner = createSpinner('Saving configuration...');
-        updateSpinner.start();
-        await agent.updateAgent(agentId, updatedConfig);
-        updateSpinner.succeed(`Provider configured: ${ai.provider} / ${config.model}`);
+        await saveProvider({
+            provider: providerId,
+            model: answers.model,
+            apiToken: answers.apiToken.trim() || current.apiToken,
+            temperature: parseTemperature(answers.temperature),
+            maxTokens: parseMaxTokens(answers.maxTokens),
+        });
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : 'Unknown error';
-        logger.error(message);
-        process.exit(1);
+        fail(error);
     }
 });
 addExamples(aiConfigCommand, [
-    { description: 'Pick provider/model/API key for the agent interactively',
-        command: 'plazbot agent ai-config agt_AbcDef123' },
+    { description: 'Pick provider, model and API token interactively',
+        command: 'plazbot agent ai-config age_AbcDef123' },
+    { description: 'Show the current AI configuration as JSON (tokens masked)',
+        command: 'plazbot agent ai-config age_AbcDef123 --show --json' },
+    { description: 'Switch to Claude non-interactively',
+        command: 'plazbot agent ai-config age_AbcDef123 --provider anthropic --model claude-sonnet-4-6 --api-token sk-ant-xxx --temperature 0.5' },
+    { description: 'Go back to the platform default AI',
+        command: 'plazbot agent ai-config age_AbcDef123 --default' },
+]);
+addNotes(aiConfigCommand, [
+    'Changing only --model, --temperature or --max-tokens keeps the current provider and API token.',
+    `Known models: openai (${AI_MODELS.openai.length}), claude (${AI_MODELS.claude.length}), gemini (${AI_MODELS.gemini.length}). Unknown model IDs are accepted with a warning.`,
+    'API tokens are never printed in full.',
 ]);

package/dist/commands/agent/chat.js

@@ -2,9 +2,11 @@ import { Command } from 'commander';
 import { Agent } from 'plazbot';
 import { getStoredCredentials } from '../../utils/credentials.js';
 import { logger } from '../../utils/logger.js';
-import { addExamples } from '../../utils/help.js';
+import { addExamples, addNotes } from '../../utils/help.js';
 import { describeAgentLoadError } from '../../utils/agent-errors.js';
 import { section } from '../../utils/ui.js';
+import { fail, describeError } from '../../utils/output.js';
+import { requireInteractive } from '../../utils/confirm.js';
 import crypto from 'crypto';
 import readline from 'readline';
 import chalk from 'chalk';
@@ -19,11 +21,12 @@ const COMMANDS_HELP = `
 export const chatCommand = new Command('chat')
     .description('Start an interactive chat session with an agent')
     .argument('<agentId>', 'Agent ID')
-    .option('-s, --session-id <id>', 'Session ID (optional)')
-    .option('-m, --multiple-answers', 'Allow multiple answers', false)
+    .option('-s, --session-id <id>', 'Reuse a session ID to continue a conversation (default: a new random ID)')
+    .option('-m, --multiple-answers', 'Allow the agent to send several answers per turn', false)
     .option('--dev', 'Use development environment', false)
     .action(async (agentId, options) => {
     try {
+        requireInteractive('The interactive chat', `For scripts, send one message at a time: plazbot agent message ${agentId} -q "Hello" --json`);
         const credentials = await getStoredCredentials();
         const agent = new Agent({
             workspaceId: credentials.workspace,
@@ -143,8 +146,9 @@ export const chatCommand = new Command('chat')
                     askQuestion();
                 }
                 catch (error) {
-                    const message = error instanceof Error ? error.message : 'Unknown error';
-                    console.log(chalk.hex('#EF5350')(`\n  ✖ Error: ${message}\n`));
+                    // Error de un turno: se informa y la sesion sigue abierta
+                    const { message, hint } = describeError(error);
+                    console.log(chalk.hex('#EF5350')(`\n  Error: ${message}`) + (hint ? chalk.gray(`\n  ${hint}`) : '') + '\n');
                     askQuestion();
                 }
             });
@@ -152,18 +156,19 @@ export const chatCommand = new Command('chat')
         askQuestion();
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : 'Unknown error';
-        logger.error(message);
-        process.exit(1);
+        fail(error);
     }
 });
 addExamples(chatCommand, [
     { description: 'Open an interactive chat with the agent',
-        command: 'plazbot agent chat agt_AbcDef123' },
+        command: 'plazbot agent chat age_AbcDef123' },
     { description: 'Reuse a previous session ID to continue the conversation',
-        command: 'plazbot agent chat agt_AbcDef123 -s sess_AbcDef123' },
+        command: 'plazbot agent chat age_AbcDef123 -s sess_AbcDef123' },
     { description: 'Allow the agent to send multiple answers per turn',
-        command: 'plazbot agent chat agt_AbcDef123 -m' },
+        command: 'plazbot agent chat age_AbcDef123 -m' },
+]);
+addNotes(chatCommand, [
+    'Needs an interactive terminal. For scripts use: plazbot agent message <agentId> -q "..." --json',
 ]);
 function formatResponse(text) {
     if (!text)

package/dist/commands/agent/copy.js

@@ -2,11 +2,13 @@ import { Command } from 'commander';
 import { Agent } from 'plazbot';
 import { getStoredCredentials } from '../../utils/credentials.js';
 import { logger } from '../../utils/logger.js';
-import { addExamples } from '../../utils/help.js';
+import { addExamples, addNotes } from '../../utils/help.js';
 import { createSpinner } from '../../utils/ui.js';
+import { jsonOption, isJsonMode, printJson, fail, CliError } from '../../utils/output.js';
 export const copyCommand = new Command('copy')
-    .description('Clone an existing agent')
+    .description('Clone an agent inside the active workspace')
     .argument('<agentId>', 'Agent ID to clone')
+    .addOption(jsonOption('Print the result as JSON ({"sourceId","id","name"})'))
     .option('--dev', 'Use development environment', false)
     .action(async (agentId, options) => {
     try {
@@ -19,21 +21,55 @@ export const copyCommand = new Command('copy')
         });
         const spinner = createSpinner('Cloning agent...');
         spinner.start();
-        const result = await agent.copyAgent({ id: agentId });
-        spinner.succeed('Agent cloned successfully');
-        logger.title('Cloned agent');
-        if (result?.agentId || result?.id) {
-            logger.label('New ID', result.agentId || result.id);
+        let result;
+        try {
+            result = await agent.copyAgent({ id: agentId });
+        }
+        catch (err) {
+            spinner.fail('Could not clone the agent');
+            throw err;
+        }
+        if (result?.success === false) {
+            spinner.fail('Could not clone the agent');
+            throw new CliError(result.message || 'The API rejected the copy.', 'copy_failed');
+        }
+        const payload = result?.agent || result?.data || result || {};
+        const newId = result?.agentId || payload?.agentId || payload?.id;
+        let newName = payload?.name;
+        // La respuesta puede no traer el nombre: se consulta el agente nuevo (solo informativo)
+        if (newId && !newName) {
+            try {
+                const res = await agent.getAgentById({ id: newId });
+                newName = (res?.agent || res?.data || res)?.name;
+            }
+            catch {
+                // Cosmetico: el clon ya se creo
+            }
         }
-        logger.dim('\nThe cloned agent has the widget disabled by default.');
+        spinner.succeed(newName ? `Agent cloned as "${newName}"` : 'Agent cloned');
+        if (isJsonMode()) {
+            printJson({ sourceId: agentId, id: newId ?? null, name: newName ?? null });
+            return;
+        }
+        logger.title('Cloned agent');
+        logger.label('Source ID', agentId);
+        logger.label('New ID', newId || '—');
+        logger.label('Name', newName || '—');
+        console.log();
+        logger.dim('The cloned agent has the widget disabled.');
+        if (newId)
+            logger.dim(`Test it with: plazbot agent chat ${newId}`);
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : 'Unknown error';
-        logger.error(message);
-        process.exit(1);
+        fail(error);
     }
 });
 addExamples(copyCommand, [
-    { description: 'Clone an agent (widget stays disabled on the copy)',
-        command: 'plazbot agent copy agt_AbcDef123' },
+    { description: 'Clone an agent (the widget stays disabled on the copy)',
+        command: 'plazbot agent copy age_AbcDef123' },
+    { description: 'Clone and capture the new ID (scripts)',
+        command: "plazbot agent copy age_AbcDef123 --json | jq -r '.id'" },
+]);
+addNotes(copyCommand, [
+    'To copy an agent to another workspace use: plazbot agent cross-copy',
 ]);