@proletariat/cli 0.3.50 → 0.3.52

package/dist/commands/monday/connect.js

@@ -0,0 +1,212 @@
+import { Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { colors } from '../../lib/colors.js';
+import { shouldOutputJson, outputSuccessAsJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+import { MondayClient, isMondayConfigured, loadMondayConfig, saveMondayApiToken, saveMondayBoard, saveMondayAccountName, clearMondayConfig, getMondayApiToken, getMondayBoardId, } from '../../lib/monday/index.js';
+export default class MondayConnect extends PMOCommand {
+    static description = 'Connect PRLT to Monday.com and store workspace credentials';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --board 1234567890',
+        '<%= config.bin %> <%= command.id %> --check',
+        '<%= config.bin %> <%= command.id %> --disconnect',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        board: Flags.string({
+            description: 'Monday board ID to sync tickets to',
+        }),
+        check: Flags.boolean({
+            description: 'Only check if Monday configuration is valid',
+            default: false,
+        }),
+        force: Flags.boolean({
+            description: 'Force re-authentication even if already configured',
+            default: false,
+        }),
+        disconnect: Flags.boolean({
+            description: 'Remove stored Monday credentials',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(MondayConnect);
+        const jsonMode = shouldOutputJson(flags);
+        const db = this.storage.getDatabase();
+        if (flags.disconnect) {
+            clearMondayConfig(db);
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    disconnected: true,
+                    message: 'Monday configuration removed.',
+                }, createMetadata('monday connect', flags));
+                return;
+            }
+            this.log(colors.success('Monday configuration removed.'));
+            return;
+        }
+        if (flags.check) {
+            await this.checkConnection(flags, jsonMode);
+            return;
+        }
+        const existingConfig = loadMondayConfig(db);
+        if (existingConfig && !flags.force) {
+            try {
+                const client = new MondayClient(existingConfig.apiToken);
+                const info = await client.verify();
+                if (jsonMode) {
+                    outputSuccessAsJson({
+                        authenticated: true,
+                        account: info.accountName,
+                        user: info.userName,
+                        boardId: existingConfig.boardId ?? null,
+                        boardName: existingConfig.boardName ?? null,
+                        message: 'Already authenticated. Use --force to re-authenticate.',
+                    }, createMetadata('monday connect', flags));
+                    return;
+                }
+                this.log(colors.success('Already connected to Monday.com'));
+                this.log(colors.textMuted(`  Account: ${info.accountName}`));
+                this.log(colors.textMuted(`  User: ${info.userName}`));
+                if (existingConfig.boardId) {
+                    this.log(colors.textMuted(`  Board: ${existingConfig.boardName ?? 'Unknown'} (${existingConfig.boardId})`));
+                }
+                this.log('');
+                this.log(colors.textMuted('Use --force to re-authenticate.'));
+                return;
+            }
+            catch {
+                // Stored token is invalid, proceed with re-authentication.
+            }
+        }
+        let apiToken = getMondayApiToken(db);
+        if (!apiToken) {
+            if (jsonMode) {
+                outputErrorAsJson('API_TOKEN_REQUIRED', 'Monday API token required. Set MONDAY_API_TOKEN or PRLT_MONDAY_API_TOKEN, or run interactively.', createMetadata('monday connect', flags));
+                this.exit(1);
+            }
+            const answers = await inquirer.prompt([{
+                    type: 'password',
+                    name: 'token',
+                    message: 'Enter your Monday API token:',
+                    mask: '*',
+                    validate: (value) => value.trim().length > 0 || 'API token is required',
+                }]);
+            apiToken = answers.token;
+        }
+        if (!apiToken) {
+            this.error('Monday API token is required.');
+        }
+        const client = new MondayClient(apiToken);
+        let boardId = flags.board ?? getMondayBoardId(db);
+        if (!boardId && !jsonMode) {
+            const answers = await inquirer.prompt([{
+                    type: 'input',
+                    name: 'boardId',
+                    message: 'Enter Monday board ID for ticket sync:',
+                    validate: (value) => value.trim().length > 0 || 'Board ID is required',
+                }]);
+            boardId = answers.boardId;
+        }
+        try {
+            const info = await client.verify();
+            saveMondayApiToken(db, apiToken);
+            saveMondayAccountName(db, info.accountName);
+            let boardName = null;
+            if (boardId) {
+                const board = await client.getBoard(boardId);
+                if (!board) {
+                    if (jsonMode) {
+                        outputErrorAsJson('BOARD_NOT_FOUND', `Monday board ${boardId} was not found or is inaccessible.`, createMetadata('monday connect', flags));
+                        this.exit(1);
+                    }
+                    this.error(`Monday board ${boardId} was not found or is inaccessible.`);
+                }
+                boardName = board.name;
+                saveMondayBoard(db, board.id, board.name);
+                boardId = board.id;
+            }
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    authenticated: true,
+                    account: info.accountName,
+                    user: info.userName,
+                    email: info.email ?? null,
+                    boardId: boardId ?? null,
+                    boardName,
+                }, createMetadata('monday connect', flags));
+                return;
+            }
+            this.log(colors.success(`Connected to Monday account: ${info.accountName}`));
+            this.log(colors.textMuted(`  Signed in as ${info.userName}${info.email ? ` (${info.email})` : ''}`));
+            if (boardId) {
+                this.log(colors.textMuted(`  Default board: ${boardName ?? 'Unknown'} (${boardId})`));
+            }
+            else {
+                this.log(colors.warning('No board selected yet.'));
+                this.log(colors.textMuted('  Run "prlt monday connect --board <board-id>" to set one.'));
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (jsonMode) {
+                outputErrorAsJson('MONDAY_AUTH_FAILED', `Authentication failed: ${message}`, createMetadata('monday connect', flags));
+                this.exit(1);
+            }
+            this.error(`Authentication failed: ${message}`);
+        }
+    }
+    async checkConnection(flags, jsonMode) {
+        const db = this.storage.getDatabase();
+        if (!isMondayConfigured(db)) {
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    configured: false,
+                    message: 'Monday is not configured. Run "prlt monday connect" first.',
+                }, createMetadata('monday connect', flags));
+                return;
+            }
+            this.log(colors.warning('Monday is not configured.'));
+            this.log(colors.textMuted('Run "prlt monday connect" first.'));
+            this.exit(1);
+        }
+        const config = loadMondayConfig(db);
+        try {
+            const client = new MondayClient(config.apiToken);
+            const info = await client.verify();
+            let board = null;
+            if (config.boardId) {
+                const fetched = await client.getBoard(config.boardId);
+                board = fetched ? { id: fetched.id, name: fetched.name } : null;
+            }
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    configured: true,
+                    connected: true,
+                    account: info.accountName,
+                    user: info.userName,
+                    boardId: config.boardId ?? null,
+                    boardName: board?.name ?? config.boardName ?? null,
+                }, createMetadata('monday connect', flags));
+                return;
+            }
+            this.log(colors.success('Monday connection is active'));
+            this.log(colors.textMuted(`  Account: ${info.accountName}`));
+            this.log(colors.textMuted(`  User: ${info.userName}`));
+            if (config.boardId) {
+                this.log(colors.textMuted(`  Board: ${board?.name ?? config.boardName ?? 'Unknown'} (${config.boardId})`));
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (jsonMode) {
+                outputErrorAsJson('MONDAY_AUTH_INVALID', `Stored Monday token is invalid or expired: ${message}`, createMetadata('monday connect', flags));
+                this.exit(1);
+            }
+            this.log(colors.error('Stored Monday token is invalid or expired.'));
+            this.log(colors.textMuted('Run "prlt monday connect --force" to re-authenticate.'));
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/monday/sync.d.ts

@@ -0,0 +1,14 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class MondaySyncCommand extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        ticket: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    execute(): Promise<void>;
+    private syncSingleTicket;
+}

package/dist/commands/monday/sync.js

@@ -0,0 +1,178 @@
+import { Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { colors } from '../../lib/colors.js';
+import { shouldOutputJson, outputSuccessAsJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+import { MondayClient, MondayMapper, MondaySync, isMondayConfigured, loadMondayConfig, } from '../../lib/monday/index.js';
+export default class MondaySyncCommand extends PMOCommand {
+    static description = 'Sync PMO tickets to Monday.com board items';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>                     # Sync project tickets to Monday board',
+        '<%= config.bin %> <%= command.id %> --ticket TKT-001    # Sync one ticket',
+        '<%= config.bin %> <%= command.id %> --dry-run           # Preview sync operations',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        ticket: Flags.string({
+            description: 'PMO ticket ID to sync',
+        }),
+        'dry-run': Flags.boolean({
+            description: 'Preview what would be synced without writing to Monday',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(MondaySyncCommand);
+        const jsonMode = shouldOutputJson(flags);
+        const db = this.storage.getDatabase();
+        if (!isMondayConfigured(db)) {
+            if (jsonMode) {
+                outputErrorAsJson('MONDAY_NOT_CONFIGURED', 'Monday is not configured. Run "prlt monday connect" first.', createMetadata('monday sync', flags));
+                this.exit(1);
+            }
+            this.error('Monday is not configured. Run "prlt monday connect" first.');
+        }
+        const config = loadMondayConfig(db);
+        if (!config.boardId) {
+            if (jsonMode) {
+                outputErrorAsJson('MONDAY_BOARD_REQUIRED', 'No Monday board configured. Run "prlt monday connect --board <id>" first.', createMetadata('monday sync', flags));
+                this.exit(1);
+            }
+            this.error('No Monday board configured. Run "prlt monday connect --board <id>" first.');
+        }
+        const client = new MondayClient(config.apiToken);
+        const mapper = new MondayMapper(db);
+        const sync = new MondaySync(client, mapper);
+        if (flags.ticket) {
+            await this.syncSingleTicket(flags.ticket, config.boardId, sync, jsonMode, flags);
+            return;
+        }
+        const projectId = await this.requireProject({
+            jsonMode: jsonMode ? {
+                flags,
+                commandName: 'monday sync',
+                baseCommand: `${this.config.bin} monday sync`,
+            } : undefined,
+        });
+        const tickets = await this.storage.listTickets(projectId);
+        if (tickets.length === 0) {
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    synced: 0,
+                    created: 0,
+                    skipped: 0,
+                    message: `No tickets found for project ${projectId}.`,
+                }, createMetadata('monday sync', flags));
+                return;
+            }
+            this.log(colors.warning(`No tickets found for project ${projectId}.`));
+            return;
+        }
+        if (flags['dry-run']) {
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    dryRun: true,
+                    action: 'sync-all',
+                    projectId,
+                    boardId: config.boardId,
+                    tickets: tickets.map((ticket) => ({
+                        ticketId: ticket.id,
+                        itemName: sync.ticketToItemName(ticket),
+                        mapped: mapper.getByTicketId(ticket.id) !== null,
+                    })),
+                }, createMetadata('monday sync', flags));
+                return;
+            }
+            this.log(colors.textMuted(`Would sync ${tickets.length} ticket(s) from ${projectId} to Monday board ${config.boardId}.`));
+            return;
+        }
+        let syncedCount = 0;
+        let createdCount = 0;
+        const errors = [];
+        for (const ticket of tickets) {
+            try {
+                // eslint-disable-next-line no-await-in-loop
+                const result = await sync.syncTicket(ticket, config.boardId);
+                syncedCount++;
+                if (result.created)
+                    createdCount++;
+            }
+            catch (error) {
+                errors.push({
+                    ticketId: ticket.id,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        if (jsonMode) {
+            outputSuccessAsJson({
+                action: 'sync-all',
+                projectId,
+                boardId: config.boardId,
+                synced: syncedCount,
+                created: createdCount,
+                skipped: tickets.length - syncedCount,
+                errors,
+            }, createMetadata('monday sync', flags));
+            return;
+        }
+        this.log(colors.success(`Synced ${syncedCount}/${tickets.length} ticket(s) to Monday`));
+        this.log(colors.textMuted(`  Created new items: ${createdCount}`));
+        if (errors.length > 0) {
+            this.log(colors.warning(`  Errors: ${errors.length}`));
+            for (const error of errors.slice(0, 5)) {
+                this.log(colors.textMuted(`    ${error.ticketId}: ${error.error}`));
+            }
+        }
+    }
+    async syncSingleTicket(ticketId, boardId, sync, jsonMode, flags) {
+        const ticket = await this.storage.getTicket(ticketId);
+        if (!ticket) {
+            if (jsonMode) {
+                outputErrorAsJson('TICKET_NOT_FOUND', `Ticket ${ticketId} not found.`, createMetadata('monday sync', flags));
+                this.exit(1);
+            }
+            this.error(`Ticket ${ticketId} not found.`);
+        }
+        if (flags['dry-run']) {
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    dryRun: true,
+                    action: 'sync-ticket',
+                    ticketId,
+                    boardId,
+                    itemName: sync.ticketToItemName(ticket),
+                }, createMetadata('monday sync', flags));
+                return;
+            }
+            this.log(colors.textMuted(`Would sync ${ticketId} to Monday board ${boardId}.`));
+            return;
+        }
+        try {
+            const result = await sync.syncTicket(ticket, boardId);
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    action: 'sync-ticket',
+                    ticketId,
+                    boardId,
+                    itemId: result.itemId,
+                    created: result.created,
+                }, createMetadata('monday sync', flags));
+                return;
+            }
+            if (result.created) {
+                this.log(colors.success(`Created Monday item for ${ticketId}`));
+            }
+            else {
+                this.log(colors.success(`Updated Monday item for ${ticketId}`));
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (jsonMode) {
+                outputErrorAsJson('MONDAY_SYNC_FAILED', `Failed to sync ${ticketId}: ${message}`, createMetadata('monday sync', flags));
+                this.exit(1);
+            }
+            this.error(`Failed to sync ${ticketId}: ${message}`);
+        }
+    }
+}

package/dist/commands/orchestrator/start.d.ts

@@ -10,6 +10,12 @@ export declare function buildOrchestratorSessionName(hqName: string, name?: stri
  * Returns all tmux session names that start with 'prlt-orchestrator-'.
  */
 export declare function findRunningOrchestratorSessions(hostSessions: string[]): string[];
+export declare function resolveOrchestratorName(name?: string): string;
+export declare function buildOrchestratorAttachCommand(name: string): string;
+export declare function extractOrchestratorNameFromSession(sessionName: string, hqName: string): string | null;
+export declare function collectReservedOrchestratorNames(agentNames: string[], hostSessions: string[], hqName: string): Set<string>;
+export declare function buildAvailableOrchestratorNames(reserved: Set<string>, maxNames?: number): string[];
+export declare function findGlobalOrchestratorNameConflict(name: string, reserved: Set<string>): string | null;
 export default class OrchestratorStart extends PromptCommand {
     static description: string;
     static examples: string[];

package/dist/commands/orchestrator/start.js

@@ -9,9 +9,10 @@ import { getHeadquartersNameFromPath } from '../../lib/machine-config.js';
 import { shouldOutputJson, outputErrorAsJson, outputSuccessAsJson, createMetadata, buildPromptConfig, outputPromptAsJson, } from '../../lib/prompt-json.js';
 import { styles } from '../../lib/styles.js';
 import { DEFAULT_EXECUTION_CONFIG, } from '../../lib/execution/types.js';
-import { runExecution } from '../../lib/execution/runners.js';
+import { runExecution, hostCredentialsExist } from '../../lib/execution/runners.js';
 import { getHostTmuxSessionNames } from '../../lib/execution/session-utils.js';
 import { ExecutionStorage } from '../../lib/execution/storage.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
 import { loadExecutionConfig, getTerminalApp, getShell, detectShell, detectTerminalApp, } from '../../lib/execution/config.js';
 /**
  * Sanitize a name segment for use in tmux session names.
@@ -39,6 +40,68 @@ export function buildOrchestratorSessionName(hqName, name = 'main') {
 export function findRunningOrchestratorSessions(hostSessions) {
     return hostSessions.filter(s => s.startsWith('prlt-orchestrator-'));
 }
+export function resolveOrchestratorName(name) {
+    const normalized = name?.trim();
+    return normalized && normalized.length > 0 ? normalized : 'main';
+}
+export function buildOrchestratorAttachCommand(name) {
+    return name === 'main'
+        ? 'prlt orchestrator attach'
+        : `prlt orchestrator attach --name ${name}`;
+}
+export function extractOrchestratorNameFromSession(sessionName, hqName) {
+    const prefix = `prlt-orchestrator-${sanitizeName(hqName) || 'default'}-`;
+    if (!sessionName.startsWith(prefix)) {
+        return null;
+    }
+    const extracted = sessionName.slice(prefix.length);
+    return extracted.length > 0 ? extracted : null;
+}
+export function collectReservedOrchestratorNames(agentNames, hostSessions, hqName) {
+    const reserved = new Set();
+    for (const agentName of agentNames) {
+        const normalized = resolveOrchestratorName(sanitizeName(agentName).toLowerCase());
+        reserved.add(normalized);
+    }
+    for (const session of hostSessions) {
+        const extracted = extractOrchestratorNameFromSession(session, hqName);
+        if (!extracted)
+            continue;
+        reserved.add(resolveOrchestratorName(extracted.toLowerCase()));
+    }
+    return reserved;
+}
+function nextAvailableName(baseName, reserved) {
+    const normalizedBase = resolveOrchestratorName(baseName.toLowerCase());
+    if (!reserved.has(normalizedBase)) {
+        return normalizedBase;
+    }
+    let suffix = 2;
+    while (reserved.has(`${normalizedBase}-${suffix}`)) {
+        suffix += 1;
+    }
+    return `${normalizedBase}-${suffix}`;
+}
+export function buildAvailableOrchestratorNames(reserved, maxNames = 8) {
+    const orderedBases = ['main', ...Array.from(reserved).sort()];
+    const suggestions = [];
+    const taken = new Set(reserved);
+    for (const base of orderedBases) {
+        const candidate = nextAvailableName(base, taken);
+        if (suggestions.includes(candidate))
+            continue;
+        suggestions.push(candidate);
+        taken.add(candidate);
+        if (suggestions.length >= maxNames) {
+            break;
+        }
+    }
+    return suggestions;
+}
+export function findGlobalOrchestratorNameConflict(name, reserved) {
+    const normalized = resolveOrchestratorName(sanitizeName(name).toLowerCase());
+    return reserved.has(normalized) ? normalized : null;
+}
 export default class OrchestratorStart extends PromptCommand {
     static description = 'Start the orchestrator agent in a tmux session';
     static examples = [
@@ -93,7 +156,6 @@ export default class OrchestratorStart extends PromptCommand {
     async run() {
         const { flags } = await this.parse(OrchestratorStart);
         const jsonMode = shouldOutputJson(flags);
-        const orchestratorName = flags.name || 'main';
         // Resolve HQ path first (needed for scoped session name)
         const hqPath = findHQRoot(process.cwd());
         if (!hqPath) {
@@ -103,26 +165,68 @@ export default class OrchestratorStart extends PromptCommand {
             }
             this.error('Not in an HQ workspace. Run "prlt init" first.');
         }
-        // Build session name scoped to this HQ
+        // Resolve orchestrator name (interactive prompt when --name is omitted)
+        const workspaceInfo = getWorkspaceInfo();
         const hqName = getHeadquartersNameFromPath(hqPath);
+        const hostSessions = getHostTmuxSessionNames();
+        const reservedAgentNames = new Set(workspaceInfo.agents.map(agent => resolveOrchestratorName(sanitizeName(agent.name).toLowerCase())));
+        const reservedNames = collectReservedOrchestratorNames(workspaceInfo.agents.map(agent => agent.name), hostSessions, hqName);
+        let orchestratorName = resolveOrchestratorName(flags.name);
+        if (!flags.name && !jsonMode) {
+            const availableNames = buildAvailableOrchestratorNames(reservedNames);
+            const { selectedName } = await this.prompt([{
+                    type: 'list',
+                    name: 'selectedName',
+                    message: 'Select orchestrator name:',
+                    choices: [
+                        ...availableNames.map(name => ({
+                            name,
+                            value: name,
+                            command: `prlt orchestrator start --name ${name} --json`,
+                        })),
+                        { name: 'Custom...', value: '__custom__' },
+                    ],
+                }]);
+            if (selectedName === '__custom__') {
+                const defaultCustomName = availableNames[0] || 'main';
+                const { customName } = await this.prompt([{
+                        type: 'input',
+                        name: 'customName',
+                        message: 'Enter orchestrator name:',
+                        default: defaultCustomName,
+                        validate: (input) => {
+                            const normalized = resolveOrchestratorName(sanitizeName(String(input ?? '')).toLowerCase());
+                            if (reservedNames.has(normalized)) {
+                                return `Name "${normalized}" is already in use by an agent or orchestrator session.`;
+                            }
+                            return true;
+                        },
+                    }]);
+                orchestratorName = resolveOrchestratorName(customName);
+            }
+            else {
+                orchestratorName = resolveOrchestratorName(selectedName);
+            }
+        }
+        const attachCommand = buildOrchestratorAttachCommand(orchestratorName);
+        const attachArgs = orchestratorName === 'main' ? [] : ['--name', orchestratorName];
+        // Build session name scoped to this HQ
         const sessionName = buildOrchestratorSessionName(hqName, orchestratorName);
         // Check if orchestrator is already running
-        const hostSessions = getHostTmuxSessionNames();
         if (hostSessions.includes(sessionName)) {
             if (jsonMode) {
-                outputErrorAsJson('ALREADY_RUNNING', `Orchestrator is already running (session: ${sessionName}). Use "prlt orchestrator attach${flags.name ? ` --name ${flags.name}` : ''}" to reattach.`, createMetadata('orchestrator start', flags));
+                outputErrorAsJson('ALREADY_RUNNING', `Orchestrator is already running (session: ${sessionName}). Use "${attachCommand}" to reattach.`, createMetadata('orchestrator start', flags));
                 return;
             }
             this.log('');
             this.log(styles.warning(`Orchestrator is already running (session: ${sessionName})`));
             this.log('');
-            const attachArgs = flags.name ? ['--name', flags.name] : [];
             const { choice } = await this.prompt([{
                     type: 'list',
                     name: 'choice',
                     message: 'What would you like to do?',
                     choices: [
-                        { name: 'Attach to running orchestrator', value: 'attach', command: `prlt orchestrator attach${flags.name ? ` --name ${flags.name}` : ''} --json` },
+                        { name: 'Attach to running orchestrator', value: 'attach', command: `${attachCommand} --json` },
                         { name: 'Cancel', value: 'cancel' },
                     ],
                 }], jsonMode ? { flags, commandName: 'orchestrator start' } : null);
@@ -131,6 +235,14 @@ export default class OrchestratorStart extends PromptCommand {
             }
             return;
         }
+        const conflict = findGlobalOrchestratorNameConflict(orchestratorName, reservedAgentNames);
+        if (conflict) {
+            if (jsonMode) {
+                outputErrorAsJson('NAME_CONFLICT', `Orchestrator name "${conflict}" is already in use by a staff/temp agent. Choose a unique name with --name.`, createMetadata('orchestrator start', flags));
+                return;
+            }
+            this.error(`Orchestrator name "${conflict}" is already in use by a staff/temp agent. Choose a different name.`);
+        }
         // Executor selection
         let selectedExecutor;
         if (flags.executor) {
@@ -156,6 +268,32 @@ export default class OrchestratorStart extends PromptCommand {
                 }]);
             selectedExecutor = executor;
         }
+        // Validate Claude Code authentication for claude-code executor
+        if (selectedExecutor === 'claude-code' && !hostCredentialsExist()) {
+            const errorMsg = 'Claude Code authentication is not available. This usually happens when the macOS keychain is locked in SSH sessions.';
+            const remediation = [
+                '',
+                'To fix this, choose one of the following:',
+                '',
+                '1. Unlock the keychain:',
+                '   security unlock-keychain',
+                '',
+                '2. Set the ANTHROPIC_API_KEY environment variable:',
+                '   export ANTHROPIC_API_KEY=your-api-key',
+                '',
+                '3. Login to Claude Code:',
+                '   claude /login',
+                '',
+            ].join('\n');
+            if (jsonMode) {
+                outputErrorAsJson('AUTH_UNAVAILABLE', errorMsg + '\n' + remediation, createMetadata('orchestrator start', flags));
+                return;
+            }
+            this.log('');
+            this.log(styles.error(errorMsg));
+            this.log(remediation);
+            return;
+        }
         // Permission mode selection
         let permissionMode;
         if (flags['skip-permissions']) {
@@ -261,9 +399,9 @@ export default class OrchestratorStart extends PromptCommand {
         }
         else {
             const displayChoices = [
-                { name: 'New terminal tab — opens attached to the tmux session', value: 'terminal', command: `prlt orchestrator start${flags.name ? ` --name ${flags.name}` : ''} --json` },
-                { name: 'Current session — attach to tmux here (foreground, blocking)', value: 'foreground', command: `prlt orchestrator start${flags.name ? ` --name ${flags.name}` : ''} --foreground --json` },
-                { name: 'Background — start detached, attach later', value: 'background', command: `prlt orchestrator start${flags.name ? ` --name ${flags.name}` : ''} --background --json` },
+                { name: 'New terminal tab — opens attached to the tmux session', value: 'terminal', command: `prlt orchestrator start${orchestratorName !== 'main' ? ` --name ${orchestratorName}` : ''} --json` },
+                { name: 'Current session — attach to tmux here (foreground, blocking)', value: 'foreground', command: `prlt orchestrator start${orchestratorName !== 'main' ? ` --name ${orchestratorName}` : ''} --foreground --json` },
+                { name: 'Background — start detached, attach later', value: 'background', command: `prlt orchestrator start${orchestratorName !== 'main' ? ` --name ${orchestratorName}` : ''} --background --json` },
             ];
             const displayMessage = 'How do you want to view the orchestrator?';
             if (jsonMode) {
@@ -346,7 +484,7 @@ export default class OrchestratorStart extends PromptCommand {
             if (displayMode === 'background') {
                 this.log(styles.success(`Orchestrator started in background`));
                 this.log(styles.muted(`   Session: ${result.sessionId || sessionName}`));
-                this.log(styles.muted(`   Attach with: prlt orchestrator attach${flags.name ? ` --name ${flags.name}` : ''}`));
+                this.log(styles.muted(`   Attach with: ${attachCommand}`));
             }
             else {
                 this.log(styles.success(`Orchestrator started`));