@proletariat/cli 0.3.47 → 0.3.48

package/dist/commands/caffeinate/index.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class Caffeinate extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/caffeinate/index.js

@@ -0,0 +1,64 @@
+import { Command } from '@oclif/core';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson } from '../../lib/prompt-json.js';
+import { machineOutputFlags } from '../../lib/pmo/index.js';
+import { FlagResolver } from '../../lib/flags/index.js';
+import { isMacOS } from '../../lib/caffeinate.js';
+export default class Caffeinate extends Command {
+    static description = 'Manage caffeinate to keep macOS awake';
+    static examples = [
+        '<%= config.bin %> caffeinate',
+        '<%= config.bin %> caffeinate start',
+        '<%= config.bin %> caffeinate status',
+        '<%= config.bin %> caffeinate stop',
+        '<%= config.bin %> caffeinate start --duration 3600',
+        '<%= config.bin %> caffeinate start --display',
+    ];
+    static flags = {
+        ...machineOutputFlags,
+    };
+    async run() {
+        const { flags } = await this.parse(Caffeinate);
+        const jsonMode = shouldOutputJson(flags);
+        if (!isMacOS()) {
+            if (jsonMode) {
+                this.log(JSON.stringify({
+                    type: 'error',
+                    error: { code: 'UNSUPPORTED_PLATFORM', message: `caffeinate is only supported on macOS (current platform: ${process.platform})` },
+                }, null, 2));
+                this.exit(1);
+            }
+            this.error(`caffeinate is only supported on macOS (current platform: ${process.platform})`);
+        }
+        const menuChoices = [
+            { name: 'Check caffeinate status', value: 'status', command: 'prlt caffeinate status --json' },
+            { name: 'Start caffeinate', value: 'start', command: 'prlt caffeinate start --json' },
+            { name: 'Stop caffeinate', value: 'stop', command: 'prlt caffeinate stop --json' },
+            { name: 'Exit', value: 'exit', command: 'prlt caffeinate --exit' },
+        ];
+        const resolver = new FlagResolver({
+            commandName: 'caffeinate',
+            baseCommand: 'prlt caffeinate',
+            jsonMode,
+            flags,
+        });
+        resolver.addPrompt({
+            flagName: 'action',
+            type: 'list',
+            message: 'What would you like to do?',
+            choices: () => menuChoices,
+            skipAutoCommand: true,
+        });
+        if (!jsonMode) {
+            this.log('');
+            this.log(styles.header('Caffeinate'));
+            this.log('');
+        }
+        const resolved = await resolver.resolve();
+        const action = resolved.action;
+        if (!action || action === 'exit') {
+            return;
+        }
+        await this.config.runCommand(`caffeinate:${action}`, []);
+    }
+}

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

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class CaffeinateStart extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        duration: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        display: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        idle: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        system: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/caffeinate/start.js

@@ -0,0 +1,86 @@
+import { Command, Flags } from '@oclif/core';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson } from '../../lib/prompt-json.js';
+import { machineOutputFlags } from '../../lib/pmo/index.js';
+import { isMacOS, startCaffeinate, getStatus } from '../../lib/caffeinate.js';
+export default class CaffeinateStart extends Command {
+    static description = 'Start caffeinate to prevent macOS from sleeping';
+    static examples = [
+        '<%= config.bin %> caffeinate start',
+        '<%= config.bin %> caffeinate start --duration 3600',
+        '<%= config.bin %> caffeinate start --display',
+    ];
+    static flags = {
+        ...machineOutputFlags,
+        duration: Flags.integer({
+            char: 't',
+            description: 'Duration in seconds (default: indefinite)',
+        }),
+        display: Flags.boolean({
+            char: 'd',
+            description: 'Prevent display from sleeping (adds -d flag)',
+            default: false,
+        }),
+        idle: Flags.boolean({
+            char: 'i',
+            description: 'Prevent idle sleep (adds -i flag)',
+            default: false,
+        }),
+        system: Flags.boolean({
+            char: 's',
+            description: 'Prevent system sleep (adds -s flag)',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(CaffeinateStart);
+        const jsonMode = shouldOutputJson(flags);
+        if (!isMacOS()) {
+            if (jsonMode) {
+                this.log(JSON.stringify({
+                    type: 'error',
+                    error: { code: 'UNSUPPORTED_PLATFORM', message: `caffeinate is only supported on macOS (current platform: ${process.platform})` },
+                }, null, 2));
+                this.exit(1);
+            }
+            this.error(`caffeinate is only supported on macOS (current platform: ${process.platform})`);
+        }
+        // Build caffeinate flags
+        const caffeinateFlags = [];
+        if (flags.display)
+            caffeinateFlags.push('-d');
+        if (flags.idle)
+            caffeinateFlags.push('-i');
+        if (flags.system)
+            caffeinateFlags.push('-s');
+        // Check if already running (idempotent)
+        const { running, state: existingState } = getStatus();
+        if (running && existingState) {
+            if (jsonMode) {
+                this.log(JSON.stringify({
+                    type: 'success',
+                    result: { ...existingState, status: 'already_running' },
+                }, null, 2));
+                return;
+            }
+            this.log(`\n${styles.warning('caffeinate is already running')} ${styles.muted(`(PID: ${existingState.pid})`)}\n`);
+            return;
+        }
+        const state = startCaffeinate(caffeinateFlags, flags.duration);
+        if (jsonMode) {
+            this.log(JSON.stringify({
+                type: 'success',
+                result: { ...state, status: 'started' },
+            }, null, 2));
+            return;
+        }
+        this.log(`\n${styles.success('caffeinate started')} ${styles.muted(`(PID: ${state.pid})`)}`);
+        if (state.duration) {
+            this.log(styles.muted(`  Duration: ${state.duration}s`));
+        }
+        if (state.flags.length > 0) {
+            this.log(styles.muted(`  Flags: ${state.flags.join(' ')}`));
+        }
+        this.log('');
+    }
+}

package/dist/commands/caffeinate/status.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class CaffeinateStatus extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/caffeinate/status.js

@@ -0,0 +1,55 @@
+import { Command } from '@oclif/core';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson } from '../../lib/prompt-json.js';
+import { machineOutputFlags } from '../../lib/pmo/index.js';
+import { isMacOS, getStatus } from '../../lib/caffeinate.js';
+export default class CaffeinateStatus extends Command {
+    static description = 'Check if caffeinate is running';
+    static examples = [
+        '<%= config.bin %> caffeinate status',
+    ];
+    static flags = {
+        ...machineOutputFlags,
+    };
+    async run() {
+        const { flags } = await this.parse(CaffeinateStatus);
+        const jsonMode = shouldOutputJson(flags);
+        if (!isMacOS()) {
+            if (jsonMode) {
+                this.log(JSON.stringify({
+                    type: 'error',
+                    error: { code: 'UNSUPPORTED_PLATFORM', message: `caffeinate is only supported on macOS (current platform: ${process.platform})` },
+                }, null, 2));
+                this.exit(1);
+            }
+            this.error(`caffeinate is only supported on macOS (current platform: ${process.platform})`);
+        }
+        const { running, state } = getStatus();
+        if (jsonMode) {
+            this.log(JSON.stringify({
+                type: 'success',
+                result: {
+                    running,
+                    ...(state ? { pid: state.pid, startedAt: state.startedAt, flags: state.flags, duration: state.duration ?? null } : {}),
+                },
+            }, null, 2));
+            return;
+        }
+        this.log(`\n${styles.header('Caffeinate Status')}`);
+        this.log('─'.repeat(40));
+        if (running && state) {
+            this.log(`${styles.success('Running')} ${styles.muted(`(PID: ${state.pid})`)}`);
+            this.log(styles.muted(`  Started: ${state.startedAt}`));
+            if (state.flags.length > 0) {
+                this.log(styles.muted(`  Flags:   ${state.flags.join(' ')}`));
+            }
+            if (state.duration) {
+                this.log(styles.muted(`  Duration: ${state.duration}s`));
+            }
+        }
+        else {
+            this.log(styles.muted('Not running'));
+        }
+        this.log('');
+    }
+}

package/dist/commands/caffeinate/stop.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class CaffeinateStop extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/caffeinate/stop.js

@@ -0,0 +1,47 @@
+import { Command } from '@oclif/core';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson } from '../../lib/prompt-json.js';
+import { machineOutputFlags } from '../../lib/pmo/index.js';
+import { isMacOS, stopCaffeinate, getStatus } from '../../lib/caffeinate.js';
+export default class CaffeinateStop extends Command {
+    static description = 'Stop the managed caffeinate process';
+    static examples = [
+        '<%= config.bin %> caffeinate stop',
+    ];
+    static flags = {
+        ...machineOutputFlags,
+    };
+    async run() {
+        const { flags } = await this.parse(CaffeinateStop);
+        const jsonMode = shouldOutputJson(flags);
+        if (!isMacOS()) {
+            if (jsonMode) {
+                this.log(JSON.stringify({
+                    type: 'error',
+                    error: { code: 'UNSUPPORTED_PLATFORM', message: `caffeinate is only supported on macOS (current platform: ${process.platform})` },
+                }, null, 2));
+                this.exit(1);
+            }
+            this.error(`caffeinate is only supported on macOS (current platform: ${process.platform})`);
+        }
+        // Get current state for reporting
+        const { state } = getStatus();
+        const stopped = stopCaffeinate();
+        if (jsonMode) {
+            this.log(JSON.stringify({
+                type: 'success',
+                result: {
+                    stopped,
+                    pid: state?.pid ?? null,
+                },
+            }, null, 2));
+            return;
+        }
+        if (stopped) {
+            this.log(`\n${styles.success('caffeinate stopped')} ${styles.muted(`(PID: ${state?.pid})`)}\n`);
+        }
+        else {
+            this.log(`\n${styles.muted('caffeinate is not running')}\n`);
+        }
+    }
+}

package/dist/commands/commit.js

@@ -438,23 +438,25 @@ export default class Commit extends PromptCommand {
             }
         }
         // Check if there are staged changes
+        let hasStagedChanges = true;
         try {
             const staged = execSync('git diff --cached --name-only', {
                 encoding: 'utf-8',
                 stdio: ['pipe', 'pipe', 'pipe'],
             }).trim();
-            if (!staged) {
-                this.error('No staged changes to commit.\n\n' +
-                    'Stage your changes first:\n' +
-                    '  git add <files>\n' +
-                    '  git add -A\n\n' +
-                    'Or use --all flag:\n' +
-                    '  prlt commit --all "your message"');
-            }
+            hasStagedChanges = staged.length > 0;
         }
         catch {
             // Ignore errors checking staged changes
         }
+        if (!hasStagedChanges) {
+            this.error('No staged changes to commit.\n\n' +
+                'Stage your changes first:\n' +
+                '  git add <files>\n' +
+                '  git add -A\n\n' +
+                'Or use --all flag:\n' +
+                '  prlt commit --all "your message"');
+        }
         // Create commit
         try {
             execSync(`git commit -m "${commitMessage.replace(/"/g, '\\"')}"`, {

package/dist/commands/config/index.js

@@ -77,10 +77,9 @@ export default class Config extends PromptCommand {
             }
             // Handle --list or --json flag without --setting (just show config)
             // Also handle non-TTY mode without explicit flags - output config as readable list
-            const isExplicitJsonMode = (flags.json === true || flags.machine === true);
-            const shouldShowConfigList = flags.list || (isExplicitJsonMode && !flags.setting) || (isNonTTY() && !flags.setting && !flags.set?.length);
+            const shouldShowConfigList = flags.list || (jsonMode && !flags.setting) || (isNonTTY() && !flags.setting && !flags.set?.length);
             if (shouldShowConfigList) {
-                if (isExplicitJsonMode) {
+                if (jsonMode) {
                     outputSuccessAsJson({
                         terminal: {
                             app: config.terminal.app,

package/dist/commands/init.js

@@ -2,7 +2,7 @@ import { Command, Flags } from '@oclif/core';
 import chalk from 'chalk';
 import * as path from 'node:path';
 import * as fs from 'node:fs';
-import { promptForHQName, promptForHQLocation, initializeHQ, showNextSteps, validateHQLocation } from '../lib/init/index.js';
+import { promptForHQName, promptForHQLocation, initializeHQ, showNextSteps, validateHQLocation, isHQNameTaken, } from '../lib/init/index.js';
 import { promptForAgentsWithTheme } from '../lib/agents/index.js';
 import { promptForRepositories } from '../lib/repos/index.js';
 import { promptForPMOSetup, machineOutputFlags } from '../lib/pmo/index.js';
@@ -90,6 +90,14 @@ export default class Init extends Command {
             outputPromptAsJson(buildPromptConfig('input', 'name', 'Enter a name for your headquarters:', undefined, undefined), createMetadata('init', flags));
         }
         const hqName = flags.name;
+        // Check if HQ name is already in use
+        if (hqName && isHQNameTaken(hqName)) {
+            this.outputJson({
+                success: false,
+                error: `HQ name "${hqName}" is already in use on this machine. Pick another name.`,
+            });
+            this.exit(1);
+        }
         const hqPath = flags.path || path.resolve(`./${hqName}-hq`);
         // Validate HQ path is not inside a git repo
         if (!validateHQLocation(hqPath)) {

package/dist/commands/orchestrator/attach.js

@@ -10,8 +10,10 @@ import { shouldOutputJson, outputErrorAsJson, outputSuccessAsJson, createMetadat
 import { styles } from '../../lib/styles.js';
 import { getHostTmuxSessionNames } from '../../lib/execution/session-utils.js';
 import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { findHQRoot } from '../../lib/workspace.js';
+import { getHeadquartersNameFromPath } from '../../lib/machine-config.js';
 import { loadExecutionConfig, shouldUseControlMode, buildTmuxAttachCommand } from '../../lib/execution/index.js';
-import { buildOrchestratorSessionName } from './start.js';
+import { buildOrchestratorSessionName, findRunningOrchestratorSessions } from './start.js';
 /**
  * Detect the terminal emulator from environment variables.
  * Returns a terminal app name suitable for AppleScript tab creation,
@@ -27,8 +29,6 @@ export function detectTerminalApp() {
         return null;
     }
     const termProgram = process.env.TERM_PROGRAM;
-    if (!termProgram)
-        return null;
     switch (termProgram) {
         case 'iTerm.app':
             return 'iTerm';
@@ -38,9 +38,13 @@ export function detectTerminalApp() {
             return 'Terminal';
         case 'WezTerm':
             return 'WezTerm';
-        default:
-            return null;
     }
+    // TERM_PROGRAM is overwritten to 'tmux' inside tmux sessions.
+    // Fall back to vars that persist through tmux to detect the outer terminal.
+    if (process.env.LC_TERMINAL === 'iTerm2' || process.env.ITERM_SESSION_ID) {
+        return 'iTerm';
+    }
+    return null;
 }
 export default class OrchestratorAttach extends PromptCommand {
     static description = 'Attach to the running orchestrator tmux session';
@@ -73,18 +77,50 @@ export default class OrchestratorAttach extends PromptCommand {
     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(sessionName)) {
-            if (jsonMode) {
-                outputErrorAsJson('NOT_RUNNING', 'Orchestrator is not running. Start it with: prlt orchestrator start', createMetadata('orchestrator attach', flags));
+        // Resolve session name: try HQ-scoped first, fall back to discovery
+        let sessionName;
+        const hqPath = findHQRoot(process.cwd());
+        if (hqPath) {
+            const hqName = getHeadquartersNameFromPath(hqPath);
+            sessionName = buildOrchestratorSessionName(hqName, flags.name || 'main');
+            if (!hostSessions.includes(sessionName)) {
+                sessionName = undefined; // Not running for this HQ
+            }
+        }
+        // If not in HQ or session not found, discover running orchestrator sessions
+        if (!sessionName) {
+            const runningSessions = findRunningOrchestratorSessions(hostSessions);
+            if (runningSessions.length === 0) {
+                if (jsonMode) {
+                    outputErrorAsJson('NOT_RUNNING', 'Orchestrator is not running. Start it with: prlt orchestrator start', createMetadata('orchestrator attach', flags));
+                    return;
+                }
+                this.log('');
+                this.log(styles.warning('Orchestrator is not running.'));
+                this.log(styles.muted('Start it with: prlt orchestrator start'));
+                this.log('');
                 return;
             }
-            this.log('');
-            this.log(styles.warning('Orchestrator is not running.'));
-            this.log(styles.muted('Start it with: prlt orchestrator start'));
-            this.log('');
+            else if (runningSessions.length === 1) {
+                sessionName = runningSessions[0];
+            }
+            else {
+                // Multiple sessions — let user pick
+                const { session } = await this.prompt([{
+                        type: 'list',
+                        name: 'session',
+                        message: 'Multiple orchestrator sessions found. Select one to attach:',
+                        choices: runningSessions.map(s => ({
+                            name: s,
+                            value: s,
+                            command: `prlt orchestrator attach --name "${s}" --json`,
+                        })),
+                    }], jsonMode ? { flags, commandName: 'orchestrator attach' } : null);
+                sessionName = session;
+            }
+        }
+        if (!sessionName) {
             return;
         }
         if (jsonMode) {
@@ -141,6 +177,16 @@ export default class OrchestratorAttach extends PromptCommand {
     }
     attachInCurrentTerminal(useControlMode, sessionName) {
         try {
+            // Set mouse mode based on attach type:
+            // - Plain terminal: mouse on (enables scroll in tmux; hold Shift/Option to bypass)
+            // - iTerm -CC: mouse off (iTerm handles scrolling natively)
+            const mouseMode = useControlMode ? 'off' : 'on';
+            try {
+                execSync(`tmux set-option -t "${sessionName}" mouse ${mouseMode}`, { stdio: 'pipe' });
+            }
+            catch {
+                // Non-fatal: mouse mode is a convenience, don't block attach
+            }
             const tmuxAttach = buildTmuxAttachCommand(useControlMode);
             execSync(`${tmuxAttach} -t "${sessionName}"`, { stdio: 'inherit' });
         }
@@ -152,6 +198,7 @@ export default class OrchestratorAttach extends PromptCommand {
         const title = 'Orchestrator';
         const tmuxAttach = buildTmuxAttachCommand(useControlMode);
         const attachCmd = `${tmuxAttach} -t "${sessionName}"`;
+        const mouseMode = useControlMode ? 'off' : 'on';
         const baseDir = path.join(os.homedir(), '.proletariat', 'scripts');
         fs.mkdirSync(baseDir, { recursive: true });
         const scriptPath = path.join(baseDir, `attach-orch-${Date.now()}.sh`);
@@ -160,6 +207,9 @@ export default class OrchestratorAttach extends PromptCommand {
 echo -ne "\\033]0;${title}\\007"
 echo -ne "\\033]1;${title}\\007"
 
+# Set mouse mode before attaching
+tmux set-option -t "${sessionName}" mouse ${mouseMode} 2>/dev/null || true
+
 echo "Attaching to: ${sessionName}"
 ${attachCmd}
 

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

@@ -1,10 +1,10 @@
 import { PromptCommand } from '../../lib/prompt-command.js';
 /**
- * Build orchestrator tmux session name.
- * Default: 'prlt-orchestrator-main'
- * With --name: 'prlt-orchestrator-{name}'
+ * Build orchestrator tmux session name scoped to the HQ workspace.
+ * Format: 'prlt-orchestrator-{hqName}-{name}'
+ * Example: 'prlt-orchestrator-proletariat-main'
  */
-export declare function buildOrchestratorSessionName(name?: string): string;
+export declare function buildOrchestratorSessionName(hqName: string, name?: string): string;
 /**
  * Find running orchestrator session(s) by prefix match.
  * Returns all tmux session names that start with 'prlt-orchestrator-'.

package/dist/commands/orchestrator/start.js

@@ -5,6 +5,7 @@ import Database from 'better-sqlite3';
 import { PromptCommand } from '../../lib/prompt-command.js';
 import { machineOutputFlags } from '../../lib/pmo/index.js';
 import { findHQRoot } from '../../lib/workspace.js';
+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';
@@ -13,16 +14,23 @@ import { getHostTmuxSessionNames } from '../../lib/execution/session-utils.js';
 import { ExecutionStorage } from '../../lib/execution/storage.js';
 import { loadExecutionConfig, getTerminalApp, getShell, detectShell, detectTerminalApp, } from '../../lib/execution/config.js';
 /**
- * Build orchestrator tmux session name.
- * Default: 'prlt-orchestrator-main'
- * With --name: 'prlt-orchestrator-{name}'
+ * Sanitize a name segment for use in tmux session names.
  */
-export function buildOrchestratorSessionName(name = 'main') {
-    const safeName = name
+function sanitizeName(name) {
+    return name
         .replace(/[^a-zA-Z0-9._-]/g, '-')
         .replace(/-+/g, '-')
         .replace(/^-|-$/g, '');
-    return `prlt-orchestrator-${safeName || 'main'}`;
+}
+/**
+ * Build orchestrator tmux session name scoped to the HQ workspace.
+ * Format: 'prlt-orchestrator-{hqName}-{name}'
+ * Example: 'prlt-orchestrator-proletariat-main'
+ */
+export function buildOrchestratorSessionName(hqName, name = 'main') {
+    const safeHqName = sanitizeName(hqName) || 'default';
+    const safeName = sanitizeName(name) || 'main';
+    return `prlt-orchestrator-${safeHqName}-${safeName}`;
 }
 /**
  * Find running orchestrator session(s) by prefix match.
@@ -86,7 +94,18 @@ export default class OrchestratorStart extends PromptCommand {
         const { flags } = await this.parse(OrchestratorStart);
         const jsonMode = shouldOutputJson(flags);
         const orchestratorName = flags.name || 'main';
-        const sessionName = buildOrchestratorSessionName(orchestratorName);
+        // Resolve HQ path first (needed for scoped session name)
+        const hqPath = findHQRoot(process.cwd());
+        if (!hqPath) {
+            if (jsonMode) {
+                outputErrorAsJson('NO_HQ', 'Not in an HQ workspace. Run "prlt init" first.', createMetadata('orchestrator start', flags));
+                return;
+            }
+            this.error('Not in an HQ workspace. Run "prlt init" first.');
+        }
+        // Build session name scoped to this HQ
+        const hqName = getHeadquartersNameFromPath(hqPath);
+        const sessionName = buildOrchestratorSessionName(hqName, orchestratorName);
         // Check if orchestrator is already running
         const hostSessions = getHostTmuxSessionNames();
         if (hostSessions.includes(sessionName)) {
@@ -112,15 +131,6 @@ export default class OrchestratorStart extends PromptCommand {
             }
             return;
         }
-        // Resolve HQ path
-        const hqPath = findHQRoot(process.cwd());
-        if (!hqPath) {
-            if (jsonMode) {
-                outputErrorAsJson('NO_HQ', 'Not in an HQ workspace. Run "prlt init" first.', createMetadata('orchestrator start', flags));
-                return;
-            }
-            this.error('Not in an HQ workspace. Run "prlt init" first.');
-        }
         // Executor selection
         let selectedExecutor;
         if (flags.executor) {