@proletariat/cli 0.3.45 → 0.3.47

package/dist/commands/linear/status.js

@@ -0,0 +1,88 @@
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { colors } from '../../lib/colors.js';
+import { shouldOutputJson, outputSuccessAsJson, createMetadata, } from '../../lib/prompt-json.js';
+import { LinearClient, isLinearConfigured, loadLinearConfig, } from '../../lib/linear/index.js';
+import { LinearMapper } from '../../lib/linear/mapper.js';
+export default class LinearStatus extends PMOCommand {
+    static description = 'Show Linear integration status and connection info';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+    };
+    async execute() {
+        const { flags } = await this.parse(LinearStatus);
+        const jsonMode = shouldOutputJson(flags);
+        const db = this.storage.getDatabase();
+        if (!isLinearConfigured(db)) {
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    configured: false,
+                    message: 'Linear is not configured. Run "prlt linear auth" to connect.',
+                }, createMetadata('linear status', flags));
+                return;
+            }
+            this.log(colors.warning('Linear is not configured'));
+            this.log(colors.textMuted('Run "prlt linear auth" to connect your Linear workspace.'));
+            return;
+        }
+        const config = loadLinearConfig(db);
+        // Verify connection
+        let connectionInfo = null;
+        let connectionError = null;
+        try {
+            const client = new LinearClient(config.apiKey);
+            connectionInfo = await client.verify();
+        }
+        catch (error) {
+            connectionError = error instanceof Error ? error.message : String(error);
+        }
+        // Count mapped issues
+        const mapper = new LinearMapper(db);
+        const mappings = mapper.listMappings();
+        if (jsonMode) {
+            outputSuccessAsJson({
+                configured: true,
+                connected: connectionInfo !== null,
+                organization: connectionInfo?.organizationName ?? config.organizationName ?? null,
+                user: connectionInfo?.userName ?? null,
+                email: connectionInfo?.email ?? null,
+                defaultTeam: config.defaultTeamKey ?? null,
+                mappedIssues: mappings.length,
+                error: connectionError,
+            }, createMetadata('linear status', flags));
+            return;
+        }
+        this.log(colors.primary('Linear Integration Status'));
+        this.log('');
+        if (connectionInfo) {
+            this.log(`  ${colors.success('Connected')}`);
+            this.log(colors.textMuted(`  Organization: ${connectionInfo.organizationName}`));
+            this.log(colors.textMuted(`  User: ${connectionInfo.userName} (${connectionInfo.email})`));
+        }
+        else {
+            this.log(`  ${colors.error('Connection failed')}`);
+            if (connectionError) {
+                this.log(colors.textMuted(`  Error: ${connectionError}`));
+            }
+        }
+        if (config.defaultTeamKey) {
+            this.log(colors.textMuted(`  Default team: ${config.defaultTeamKey}`));
+        }
+        this.log('');
+        this.log(colors.textMuted(`  Mapped issues: ${mappings.length}`));
+        if (mappings.length > 0) {
+            const recent = mappings.slice(0, 5);
+            this.log('');
+            this.log(colors.textMuted('  Recent mappings:'));
+            for (const m of recent) {
+                this.log(colors.textMuted(`    ${m.linearIdentifier} → ${m.pmoTicketId}`));
+            }
+            if (mappings.length > 5) {
+                this.log(colors.textMuted(`    ... and ${mappings.length - 5} more`));
+            }
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class LinearSyncCommand extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        ticket: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'pr-url': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'pr-title': 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>;
+}

package/dist/commands/linear/sync.js

@@ -0,0 +1,233 @@
+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 { LinearClient, LinearMapper, LinearSync, isLinearConfigured, loadLinearConfig, } from '../../lib/linear/index.js';
+export default class LinearSyncCommand extends PMOCommand {
+    static description = 'Sync PMO ticket status and PR links back to Linear';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>                    # Sync all mapped tickets',
+        '<%= config.bin %> <%= command.id %> --ticket TKT-001   # Sync a specific ticket',
+        '<%= config.bin %> <%= command.id %> --pr-url https://github.com/... --ticket TKT-001  # Attach PR to Linear issue',
+        '<%= config.bin %> <%= command.id %> --dry-run          # Preview what would be synced',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        ticket: Flags.string({
+            description: 'PMO ticket ID to sync (syncs all if omitted)',
+        }),
+        'pr-url': Flags.string({
+            description: 'PR URL to attach to the Linear issue',
+        }),
+        'pr-title': Flags.string({
+            description: 'PR title for the attachment (defaults to ticket title)',
+        }),
+        'dry-run': Flags.boolean({
+            description: 'Preview what would be synced without making changes',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(LinearSyncCommand);
+        const jsonMode = shouldOutputJson(flags);
+        const db = this.storage.getDatabase();
+        if (!isLinearConfigured(db)) {
+            if (jsonMode) {
+                outputErrorAsJson('LINEAR_NOT_CONFIGURED', 'Linear is not configured. Run "prlt linear auth" first.', createMetadata('linear sync', flags));
+                this.exit(1);
+            }
+            this.error('Linear is not configured. Run "prlt linear auth" first.');
+        }
+        const config = loadLinearConfig(db);
+        const client = new LinearClient(config.apiKey);
+        const mapper = new LinearMapper(db);
+        const sync = new LinearSync(client, mapper);
+        // Handle PR link attachment
+        if (flags['pr-url'] && flags.ticket) {
+            const prTitle = flags['pr-title'] ?? (await this.storage.getTicket(flags.ticket))?.title ?? 'Pull Request';
+            if (flags['dry-run']) {
+                if (jsonMode) {
+                    outputSuccessAsJson({
+                        dryRun: true,
+                        action: 'attach-pr',
+                        ticketId: flags.ticket,
+                        prUrl: flags['pr-url'],
+                        prTitle,
+                    }, createMetadata('linear sync', flags));
+                    return;
+                }
+                this.log(colors.textMuted(`Would attach PR to ${flags.ticket}: ${flags['pr-url']}`));
+                return;
+            }
+            const attached = await sync.syncPRLink(flags.ticket, flags['pr-url'], prTitle);
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    action: 'attach-pr',
+                    ticketId: flags.ticket,
+                    prUrl: flags['pr-url'],
+                    synced: attached,
+                }, createMetadata('linear sync', flags));
+                return;
+            }
+            if (attached) {
+                this.log(colors.success(`PR linked to Linear issue for ${flags.ticket}`));
+            }
+            else {
+                this.log(colors.warning(`No Linear mapping found for ${flags.ticket}`));
+            }
+            return;
+        }
+        // Sync ticket status(es) back to Linear
+        if (flags.ticket) {
+            // Single ticket sync
+            const ticket = await this.storage.getTicket(flags.ticket);
+            if (!ticket) {
+                if (jsonMode) {
+                    outputErrorAsJson('TICKET_NOT_FOUND', `Ticket ${flags.ticket} not found.`, createMetadata('linear sync', flags));
+                    this.exit(1);
+                }
+                this.error(`Ticket ${flags.ticket} not found.`);
+            }
+            const mapping = mapper.getByTicketId(flags.ticket);
+            if (!mapping) {
+                if (jsonMode) {
+                    outputSuccessAsJson({
+                        synced: false,
+                        message: `Ticket ${flags.ticket} has no Linear mapping.`,
+                    }, createMetadata('linear sync', flags));
+                    return;
+                }
+                this.log(colors.warning(`Ticket ${flags.ticket} has no Linear mapping.`));
+                return;
+            }
+            // Get Linear states for the team
+            const team = await client.getTeamByKey(mapping.linearTeamKey);
+            if (!team) {
+                if (jsonMode) {
+                    outputErrorAsJson('TEAM_NOT_FOUND', `Linear team ${mapping.linearTeamKey} not found.`, createMetadata('linear sync', flags));
+                    this.exit(1);
+                }
+                this.error(`Linear team ${mapping.linearTeamKey} not found.`);
+            }
+            const linearStates = await client.listStates(team.id);
+            if (flags['dry-run']) {
+                if (jsonMode) {
+                    outputSuccessAsJson({
+                        dryRun: true,
+                        action: 'sync-status',
+                        ticketId: flags.ticket,
+                        linearIdentifier: mapping.linearIdentifier,
+                        currentStatus: ticket.statusName,
+                        statusCategory: ticket.statusCategory,
+                    }, createMetadata('linear sync', flags));
+                    return;
+                }
+                this.log(colors.textMuted(`Would sync ${flags.ticket} (${mapping.linearIdentifier}): status "${ticket.statusName}" (${ticket.statusCategory})`));
+                return;
+            }
+            const synced = await sync.syncTicketStatus(ticket, linearStates);
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    action: 'sync-status',
+                    ticketId: flags.ticket,
+                    linearIdentifier: mapping.linearIdentifier,
+                    synced,
+                }, createMetadata('linear sync', flags));
+                return;
+            }
+            if (synced) {
+                this.log(colors.success(`Synced ${mapping.linearIdentifier} status to Linear`));
+            }
+            else {
+                this.log(colors.warning(`Could not find matching Linear state for ${ticket.statusCategory}`));
+            }
+            return;
+        }
+        // Bulk sync: sync all mapped tickets
+        const mappings = mapper.listMappings();
+        if (mappings.length === 0) {
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    synced: 0,
+                    message: 'No mapped tickets to sync.',
+                }, createMetadata('linear sync', flags));
+                return;
+            }
+            this.log(colors.textMuted('No mapped tickets to sync.'));
+            return;
+        }
+        if (!jsonMode) {
+            this.log(colors.textMuted(`Syncing ${mappings.length} mapped ticket(s) to Linear...`));
+        }
+        // Group mappings by team to fetch states efficiently
+        const teamKeys = [...new Set(mappings.map((m) => m.linearTeamKey))];
+        const statesByTeam = {};
+        for (const teamKey of teamKeys) {
+            // eslint-disable-next-line no-await-in-loop
+            const team = await client.getTeamByKey(teamKey);
+            if (team) {
+                // eslint-disable-next-line no-await-in-loop
+                statesByTeam[teamKey] = await client.listStates(team.id);
+            }
+        }
+        if (flags['dry-run']) {
+            const preview = [];
+            for (const mapping of mappings) {
+                // eslint-disable-next-line no-await-in-loop
+                const ticket = await this.storage.getTicket(mapping.pmoTicketId);
+                preview.push({
+                    ticketId: mapping.pmoTicketId,
+                    linearIdentifier: mapping.linearIdentifier,
+                    currentStatus: ticket?.statusName,
+                    statusCategory: ticket?.statusCategory,
+                });
+            }
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    dryRun: true,
+                    action: 'sync-all',
+                    tickets: preview,
+                }, createMetadata('linear sync', flags));
+                return;
+            }
+            this.log('');
+            for (const item of preview) {
+                this.log(colors.textMuted(`  ${item.linearIdentifier} → ${item.currentStatus} (${item.statusCategory})`));
+            }
+            return;
+        }
+        // Perform the sync for each team
+        let totalSynced = 0;
+        let totalSkipped = 0;
+        let totalErrors = 0;
+        for (const teamKey of teamKeys) {
+            const teamStates = statesByTeam[teamKey];
+            if (!teamStates) {
+                totalErrors += mappings.filter((m) => m.linearTeamKey === teamKey).length;
+                continue;
+            }
+            const teamMappings = mappings.filter((m) => m.linearTeamKey === teamKey);
+            // eslint-disable-next-line no-await-in-loop
+            const result = await sync.syncAllStatuses(this.storage, teamMappings, teamStates);
+            totalSynced += result.synced;
+            totalSkipped += result.skipped;
+            totalErrors += result.errors;
+        }
+        if (jsonMode) {
+            outputSuccessAsJson({
+                action: 'sync-all',
+                synced: totalSynced,
+                skipped: totalSkipped,
+                errors: totalErrors,
+            }, createMetadata('linear sync', flags));
+            return;
+        }
+        this.log('');
+        if (totalSynced > 0)
+            this.log(colors.success(`Synced: ${totalSynced}`));
+        if (totalSkipped > 0)
+            this.log(colors.textMuted(`Skipped: ${totalSkipped}`));
+        if (totalErrors > 0)
+            this.log(colors.error(`Errors: ${totalErrors}`));
+    }
+}

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

@@ -1,13 +1,22 @@
 import { PromptCommand } from '../../lib/prompt-command.js';
+/**
+ * Detect the terminal emulator from environment variables.
+ * Returns a terminal app name suitable for AppleScript tab creation,
+ * or null if detection fails or we're in a remote/headless environment.
+ */
+export declare function detectTerminalApp(): string | null;
 export default class OrchestratorAttach extends PromptCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'new-tab': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        terminal: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'current-terminal': import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        terminal: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
+    private attachInCurrentTerminal;
     private openInNewTab;
 }

package/dist/commands/orchestrator/attach.js

@@ -3,37 +3,80 @@ import { execSync } from 'node:child_process';
 import * as path from 'node:path';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
+import Database from 'better-sqlite3';
 import { PromptCommand } from '../../lib/prompt-command.js';
 import { machineOutputFlags } from '../../lib/pmo/index.js';
 import { shouldOutputJson, outputErrorAsJson, outputSuccessAsJson, createMetadata, } from '../../lib/prompt-json.js';
 import { styles } from '../../lib/styles.js';
 import { getHostTmuxSessionNames } from '../../lib/execution/session-utils.js';
-import { ORCHESTRATOR_SESSION_NAME } from './start.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { loadExecutionConfig, shouldUseControlMode, buildTmuxAttachCommand } from '../../lib/execution/index.js';
+import { buildOrchestratorSessionName } from './start.js';
+/**
+ * Detect the terminal emulator from environment variables.
+ * Returns a terminal app name suitable for AppleScript tab creation,
+ * or null if detection fails or we're in a remote/headless environment.
+ */
+export function detectTerminalApp() {
+    // Remote sessions should never attempt AppleScript/GUI operations
+    if (process.env.SSH_TTY || process.env.SSH_CONNECTION) {
+        return null;
+    }
+    // Headless / no display — skip GUI attempts
+    if (process.platform !== 'darwin' && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) {
+        return null;
+    }
+    const termProgram = process.env.TERM_PROGRAM;
+    if (!termProgram)
+        return null;
+    switch (termProgram) {
+        case 'iTerm.app':
+            return 'iTerm';
+        case 'ghostty':
+            return 'Ghostty';
+        case 'Apple_Terminal':
+            return 'Terminal';
+        case 'WezTerm':
+            return 'WezTerm';
+        default:
+            return null;
+    }
+}
 export default class OrchestratorAttach extends PromptCommand {
     static description = 'Attach to the running orchestrator tmux session';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
-        '<%= config.bin %> <%= command.id %> --current-terminal',
+        '<%= config.bin %> <%= command.id %> --new-tab',
+        '<%= config.bin %> <%= command.id %> --new-tab --terminal Ghostty',
     ];
     static flags = {
         ...machineOutputFlags,
-        'current-terminal': Flags.boolean({
-            char: 'c',
-            description: 'Attach in current terminal instead of new tab',
+        name: Flags.string({
+            char: 'n',
+            description: 'Name of the orchestrator session to attach to (default: main)',
+        }),
+        'new-tab': Flags.boolean({
+            description: 'Open in a new terminal tab instead of attaching in the current terminal',
             default: false,
         }),
         terminal: Flags.string({
             char: 't',
-            description: 'Terminal app to use (iTerm, Terminal, Ghostty)',
-            default: 'iTerm',
+            description: 'Terminal app to use for new tab (iTerm, Terminal, Ghostty). Auto-detected if not specified.',
+        }),
+        'current-terminal': Flags.boolean({
+            char: 'c',
+            description: '[deprecated] Attach in current terminal (this is now the default behavior)',
+            hidden: true,
+            default: false,
         }),
     };
     async run() {
         const { flags } = await this.parse(OrchestratorAttach);
         const jsonMode = shouldOutputJson(flags);
+        const sessionName = buildOrchestratorSessionName(flags.name || 'main');
         // Check if orchestrator session exists
         const hostSessions = getHostTmuxSessionNames();
-        if (!hostSessions.includes(ORCHESTRATOR_SESSION_NAME)) {
+        if (!hostSessions.includes(sessionName)) {
             if (jsonMode) {
                 outputErrorAsJson('NOT_RUNNING', 'Orchestrator is not running. Start it with: prlt orchestrator start', createMetadata('orchestrator attach', flags));
                 return;
@@ -46,28 +89,69 @@ export default class OrchestratorAttach extends PromptCommand {
         }
         if (jsonMode) {
             outputSuccessAsJson({
-                sessionId: ORCHESTRATOR_SESSION_NAME,
+                sessionId: sessionName,
                 status: 'attaching',
             }, createMetadata('orchestrator attach', flags));
             return;
         }
-        this.log('');
-        this.log(styles.info(`Attaching to orchestrator session: ${ORCHESTRATOR_SESSION_NAME}`));
         if (flags['current-terminal']) {
+            this.log(styles.warning('--current-terminal is deprecated. Direct tmux attach is now the default behavior.'));
+        }
+        if (flags.terminal && !flags['new-tab']) {
+            this.log(styles.warning('--terminal has no effect without --new-tab. Ignoring.'));
+        }
+        this.log('');
+        this.log(styles.info(`Attaching to orchestrator session: ${sessionName}`));
+        // Determine if we should use tmux control mode (-u -CC) for iTerm
+        let useControlMode = false;
+        try {
+            const workspaceInfo = getWorkspaceInfo();
+            const dbPath = path.join(workspaceInfo.path, '.proletariat', 'workspace.db');
+            const db = new Database(dbPath);
             try {
-                execSync(`tmux attach -t "${ORCHESTRATOR_SESSION_NAME}"`, { stdio: 'inherit' });
+                const config = loadExecutionConfig(db);
+                const termApp = detectTerminalApp();
+                if (termApp === 'iTerm') {
+                    useControlMode = shouldUseControlMode('iTerm', config.tmux.controlMode);
+                }
+            }
+            finally {
+                db.close();
             }
-            catch {
-                this.error(`Failed to attach to orchestrator session "${ORCHESTRATOR_SESSION_NAME}"`);
+        }
+        catch {
+            // Not in a workspace or DB not available - fall back to no control mode
+        }
+        if (flags['new-tab']) {
+            // Determine terminal app: explicit flag > auto-detect > error
+            const terminalApp = flags.terminal ?? detectTerminalApp();
+            if (!terminalApp) {
+                this.log(styles.warning('Could not detect terminal emulator for new tab.'));
+                this.log(styles.muted('Falling back to direct tmux attach in current terminal.'));
+                this.log(styles.muted('Tip: Use --terminal <app> to specify your terminal (iTerm, Terminal, Ghostty).'));
+                this.log('');
+                this.attachInCurrentTerminal(useControlMode, sessionName);
+                return;
             }
+            await this.openInNewTab(terminalApp, useControlMode, sessionName);
         }
         else {
-            await this.openInNewTab(flags.terminal);
+            this.attachInCurrentTerminal(useControlMode, sessionName);
+        }
+    }
+    attachInCurrentTerminal(useControlMode, sessionName) {
+        try {
+            const tmuxAttach = buildTmuxAttachCommand(useControlMode);
+            execSync(`${tmuxAttach} -t "${sessionName}"`, { stdio: 'inherit' });
+        }
+        catch {
+            this.error(`Failed to attach to orchestrator session "${sessionName}"`);
         }
     }
-    async openInNewTab(terminalApp) {
+    async openInNewTab(terminalApp, useControlMode, sessionName) {
         const title = 'Orchestrator';
-        const attachCmd = `tmux attach -t "${ORCHESTRATOR_SESSION_NAME}"`;
+        const tmuxAttach = buildTmuxAttachCommand(useControlMode);
+        const attachCmd = `${tmuxAttach} -t "${sessionName}"`;
         const baseDir = path.join(os.homedir(), '.proletariat', 'scripts');
         fs.mkdirSync(baseDir, { recursive: true });
         const scriptPath = path.join(baseDir, `attach-orch-${Date.now()}.sh`);
@@ -76,7 +160,7 @@ export default class OrchestratorAttach extends PromptCommand {
 echo -ne "\\033]0;${title}\\007"
 echo -ne "\\033]1;${title}\\007"
 
-echo "Attaching to: ${ORCHESTRATOR_SESSION_NAME}"
+echo "Attaching to: ${sessionName}"
 ${attachCmd}
 
 # Clean up

package/dist/commands/orchestrator/index.js

@@ -1,5 +1,7 @@
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
 import { shouldOutputJson } from '../../lib/prompt-json.js';
+import { getHostTmuxSessionNames } from '../../lib/execution/session-utils.js';
+import { findRunningOrchestratorSessions } from './start.js';
 export default class Orchestrator extends PMOCommand {
     static description = 'Manage the orchestrator agent (start, attach, status, stop)';
     static examples = [
@@ -18,17 +20,30 @@ export default class Orchestrator extends PMOCommand {
     async execute() {
         const { flags } = await this.parse(Orchestrator);
         const jsonModeConfig = shouldOutputJson(flags) ? { flags, commandName: 'orchestrator' } : null;
+        // Check if orchestrator is currently running to offer contextual options
+        const hostSessions = getHostTmuxSessionNames();
+        const isRunning = findRunningOrchestratorSessions(hostSessions).length > 0;
+        // When running, show "Attach to running session" first since that's the likely intent
+        const choices = isRunning
+            ? [
+                { name: 'Attach to running session', value: 'attach', command: 'prlt orchestrator attach --json' },
+                { name: 'Start orchestrator', value: 'start', command: 'prlt orchestrator start --json' },
+                { name: 'Check orchestrator status', value: 'status', command: 'prlt orchestrator status --json' },
+                { name: 'Stop orchestrator', value: 'stop', command: 'prlt orchestrator stop --json' },
+                { name: 'Cancel', value: 'cancel' },
+            ]
+            : [
+                { name: 'Start orchestrator', value: 'start', command: 'prlt orchestrator start --json' },
+                { name: 'Attach to orchestrator', value: 'attach', command: 'prlt orchestrator attach --json' },
+                { name: 'Check orchestrator status', value: 'status', command: 'prlt orchestrator status --json' },
+                { name: 'Stop orchestrator', value: 'stop', command: 'prlt orchestrator stop --json' },
+                { name: 'Cancel', value: 'cancel' },
+            ];
         const { action } = await this.prompt([{
                 type: 'list',
                 name: 'action',
                 message: 'Orchestrator - What would you like to do?',
-                choices: [
-                    { name: 'Start orchestrator', value: 'start', command: 'prlt orchestrator start --json' },
-                    { name: 'Attach to orchestrator', value: 'attach', command: 'prlt orchestrator attach --json' },
-                    { name: 'Check orchestrator status', value: 'status', command: 'prlt orchestrator status --json' },
-                    { name: 'Stop orchestrator', value: 'stop', command: 'prlt orchestrator stop --json' },
-                    { name: 'Cancel', value: 'cancel' },
-                ],
+                choices,
             }], jsonModeConfig);
         if (action === 'cancel') {
             return;

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

@@ -1,5 +1,15 @@
 import { PromptCommand } from '../../lib/prompt-command.js';
-export declare const ORCHESTRATOR_SESSION_NAME = "prlt-orchestrator-main";
+/**
+ * Build orchestrator tmux session name.
+ * Default: 'prlt-orchestrator-main'
+ * With --name: 'prlt-orchestrator-{name}'
+ */
+export declare function buildOrchestratorSessionName(name?: string): string;
+/**
+ * Find running orchestrator session(s) by prefix match.
+ * Returns all tmux session names that start with 'prlt-orchestrator-'.
+ */
+export declare function findRunningOrchestratorSessions(hostSessions: string[]): string[];
 export default class OrchestratorStart extends PromptCommand {
     static description: string;
     static examples: string[];
@@ -9,7 +19,9 @@ export default class OrchestratorStart extends PromptCommand {
         executor: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'skip-permissions': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         sandboxed: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         background: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        foreground: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };