@proletariat/cli 0.3.46 → 0.3.48

package/dist/commands/orchestrator/index.js

@@ -1,7 +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 { ORCHESTRATOR_SESSION_NAME } from './start.js';
+import { findRunningOrchestratorSessions } from './start.js';
 export default class Orchestrator extends PMOCommand {
     static description = 'Manage the orchestrator agent (start, attach, status, stop)';
     static examples = [
@@ -22,7 +22,7 @@ export default class Orchestrator extends PMOCommand {
         const jsonModeConfig = shouldOutputJson(flags) ? { flags, commandName: 'orchestrator' } : null;
         // Check if orchestrator is currently running to offer contextual options
         const hostSessions = getHostTmuxSessionNames();
-        const isRunning = hostSessions.includes(ORCHESTRATOR_SESSION_NAME);
+        const isRunning = findRunningOrchestratorSessions(hostSessions).length > 0;
         // When running, show "Attach to running session" first since that's the likely intent
         const choices = isRunning
             ? [

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 scoped to the HQ workspace.
+ * Format: 'prlt-orchestrator-{hqName}-{name}'
+ * Example: 'prlt-orchestrator-proletariat-main'
+ */
+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-'.
+ */
+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>;
     };

package/dist/commands/orchestrator/start.js

@@ -5,14 +5,40 @@ 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';
 import { runExecution } from '../../lib/execution/runners.js';
 import { getHostTmuxSessionNames } from '../../lib/execution/session-utils.js';
 import { ExecutionStorage } from '../../lib/execution/storage.js';
-import { loadExecutionConfig, getTerminalApp, promptTerminalPreference, getShell, promptShellPreference, hasTerminalPreference, hasShellPreference, } from '../../lib/execution/config.js';
-export const ORCHESTRATOR_SESSION_NAME = 'prlt-orchestrator-main';
+import { loadExecutionConfig, getTerminalApp, getShell, detectShell, detectTerminalApp, } from '../../lib/execution/config.js';
+/**
+ * Sanitize a name segment for use in tmux session names.
+ */
+function sanitizeName(name) {
+    return name
+        .replace(/[^a-zA-Z0-9._-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+/**
+ * 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.
+ * Returns all tmux session names that start with 'prlt-orchestrator-'.
+ */
+export function findRunningOrchestratorSessions(hostSessions) {
+    return hostSessions.filter(s => s.startsWith('prlt-orchestrator-'));
+}
 export default class OrchestratorStart extends PromptCommand {
     static description = 'Start the orchestrator agent in a tmux session';
     static examples = [
@@ -47,48 +73,64 @@ export default class OrchestratorStart extends PromptCommand {
             default: false,
             exclusive: ['skip-permissions'],
         }),
+        name: Flags.string({
+            char: 'n',
+            description: 'Name for the orchestrator session (default: main)',
+        }),
         background: Flags.boolean({
             char: 'b',
             description: 'Start detached (don\'t open terminal tab)',
             default: false,
+            exclusive: ['foreground'],
+        }),
+        foreground: Flags.boolean({
+            char: 'f',
+            description: 'Attach to the tmux session in the current terminal (blocking)',
+            default: false,
+            exclusive: ['background'],
         }),
     };
     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) {
+            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(ORCHESTRATOR_SESSION_NAME)) {
+        if (hostSessions.includes(sessionName)) {
             if (jsonMode) {
-                outputErrorAsJson('ALREADY_RUNNING', `Orchestrator is already running (session: ${ORCHESTRATOR_SESSION_NAME}). Use "prlt orchestrator attach" to reattach.`, createMetadata('orchestrator start', flags));
+                outputErrorAsJson('ALREADY_RUNNING', `Orchestrator is already running (session: ${sessionName}). Use "prlt orchestrator attach${flags.name ? ` --name ${flags.name}` : ''}" to reattach.`, createMetadata('orchestrator start', flags));
                 return;
             }
             this.log('');
-            this.log(styles.warning(`Orchestrator is already running (session: ${ORCHESTRATOR_SESSION_NAME})`));
+            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 --json' },
+                        { name: 'Attach to running orchestrator', value: 'attach', command: `prlt orchestrator attach${flags.name ? ` --name ${flags.name}` : ''} --json` },
                         { name: 'Cancel', value: 'cancel' },
                     ],
                 }], jsonMode ? { flags, commandName: 'orchestrator start' } : null);
             if (choice === 'attach') {
-                await this.config.runCommand('orchestrator:attach', []);
+                await this.config.runCommand('orchestrator:attach', attachArgs);
             }
             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) {
@@ -169,12 +211,12 @@ export default class OrchestratorStart extends PromptCommand {
             }
         }
         // Build execution context
-        // Use ticketId='prlt', actionName='orchestrator', agentName='main'
-        // so buildSessionName produces 'prlt-orchestrator-main'
+        // Use ticketId='prlt', actionName='orchestrator', agentName=orchestratorName
+        // so buildSessionName produces 'prlt-orchestrator-{name}'
         const context = {
             ticketId: 'prlt',
             ticketTitle: 'Orchestrator',
-            agentName: 'main',
+            agentName: orchestratorName,
             agentDir: hqPath,
             worktreePath: hqPath,
             branch: 'main',
@@ -202,19 +244,54 @@ export default class OrchestratorStart extends PromptCommand {
         catch {
             // Ignore config loading errors, use defaults
         }
-        // If no terminal preference saved, prompt for it (first run only)
-        if (!jsonMode && db) {
-            if (!hasTerminalPreference(db)) {
-                executionConfig.terminal.app = await promptTerminalPreference(db);
+        // Auto-detect shell (never prompt for orchestrator)
+        if (db) {
+            executionConfig.shell = await getShell(db);
+        }
+        else {
+            executionConfig.shell = detectShell() || 'zsh';
+        }
+        // Determine display mode
+        let displayMode;
+        if (flags.background) {
+            displayMode = 'background';
+        }
+        else if (flags.foreground) {
+            displayMode = 'foreground';
+        }
+        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` },
+            ];
+            const displayMessage = 'How do you want to view the orchestrator?';
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('list', 'displayMode', displayMessage, displayChoices), createMetadata('orchestrator start', flags));
+                return;
             }
-            else {
+            const { displayMode: selectedMode } = await this.prompt([{
+                    type: 'list',
+                    name: 'displayMode',
+                    message: displayMessage,
+                    choices: displayChoices,
+                }], jsonMode ? { flags, commandName: 'orchestrator start' } : null);
+            displayMode = selectedMode;
+        }
+        // For 'terminal' display mode, auto-detect terminal app
+        if (displayMode === 'terminal') {
+            if (db) {
                 executionConfig.terminal.app = await getTerminalApp(db);
             }
-            if (!hasShellPreference(db)) {
-                executionConfig.shell = await promptShellPreference(db);
-            }
             else {
-                executionConfig.shell = await getShell(db);
+                const detected = detectTerminalApp();
+                if (detected) {
+                    executionConfig.terminal.app = detected;
+                }
+                else {
+                    // Can't detect terminal and no db to prompt — fall back to foreground
+                    displayMode = 'foreground';
+                }
             }
         }
         // Show what we're doing
@@ -223,14 +300,17 @@ export default class OrchestratorStart extends PromptCommand {
             this.log(styles.muted(`   Starting orchestrator...`));
             this.log(styles.muted(`   Executor: ${selectedExecutor}`));
             this.log(styles.muted(`   Permission mode: ${sandboxed ? 'sandboxed' : 'skip-permissions'}`));
+            this.log(styles.muted(`   Display mode: ${displayMode}`));
             this.log(styles.muted(`   Directory: ${hqPath}`));
+            if (orchestratorName !== 'main') {
+                this.log(styles.muted(`   Name: ${orchestratorName}`));
+            }
             if (actionPrompt) {
                 this.log(styles.muted(`   Prompt: "${actionPrompt.substring(0, 60)}${actionPrompt.length > 60 ? '...' : ''}"`));
             }
             this.log('');
         }
         // Launch orchestrator
-        const displayMode = flags.background ? 'background' : 'terminal';
         const result = await runExecution('host', context, selectedExecutor, executionConfig, {
             displayMode,
         });
@@ -246,7 +326,7 @@ export default class OrchestratorStart extends PromptCommand {
                         environment: 'host',
                         displayMode,
                         sandboxed,
-                        sessionId: result.sessionId || ORCHESTRATOR_SESSION_NAME,
+                        sessionId: result.sessionId || sessionName,
                     });
                 }
                 catch {
@@ -255,17 +335,18 @@ export default class OrchestratorStart extends PromptCommand {
             }
             if (jsonMode) {
                 outputSuccessAsJson({
-                    sessionId: result.sessionId || ORCHESTRATOR_SESSION_NAME,
+                    sessionId: result.sessionId || sessionName,
                     executor: selectedExecutor,
                     sandboxed,
                     displayMode,
                     directory: hqPath,
+                    name: orchestratorName,
                 }, createMetadata('orchestrator start', flags));
             }
-            if (flags.background) {
+            if (displayMode === 'background') {
                 this.log(styles.success(`Orchestrator started in background`));
-                this.log(styles.muted(`   Session: ${result.sessionId || ORCHESTRATOR_SESSION_NAME}`));
-                this.log(styles.muted(`   Attach with: prlt orchestrator attach`));
+                this.log(styles.muted(`   Session: ${result.sessionId || sessionName}`));
+                this.log(styles.muted(`   Attach with: prlt orchestrator attach${flags.name ? ` --name ${flags.name}` : ''}`));
             }
             else {
                 this.log(styles.success(`Orchestrator started`));

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

@@ -3,6 +3,7 @@ export default class OrchestratorStatus extends PromptCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         peek: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         lines: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;

package/dist/commands/orchestrator/status.js

@@ -4,7 +4,9 @@ import { machineOutputFlags } from '../../lib/pmo/index.js';
 import { shouldOutputJson, outputSuccessAsJson, createMetadata, } from '../../lib/prompt-json.js';
 import { styles } from '../../lib/styles.js';
 import { getHostTmuxSessionNames, captureTmuxPane } from '../../lib/execution/session-utils.js';
-import { ORCHESTRATOR_SESSION_NAME } from './start.js';
+import { findHQRoot } from '../../lib/workspace.js';
+import { getHeadquartersNameFromPath } from '../../lib/machine-config.js';
+import { buildOrchestratorSessionName, findRunningOrchestratorSessions } from './start.js';
 export default class OrchestratorStatus extends PromptCommand {
     static description = 'Check if the orchestrator is running';
     static examples = [
@@ -14,6 +16,10 @@ export default class OrchestratorStatus extends PromptCommand {
     ];
     static flags = {
         ...machineOutputFlags,
+        name: Flags.string({
+            char: 'n',
+            description: 'Name of the orchestrator session to check (default: main)',
+        }),
         peek: Flags.boolean({
             description: 'Show recent output from the orchestrator',
             default: false,
@@ -27,36 +33,76 @@ export default class OrchestratorStatus extends PromptCommand {
         const { flags } = await this.parse(OrchestratorStatus);
         const jsonMode = shouldOutputJson(flags);
         const hostSessions = getHostTmuxSessionNames();
-        const isRunning = hostSessions.includes(ORCHESTRATOR_SESSION_NAME);
-        let recentOutput = null;
-        if (isRunning && flags.peek) {
-            recentOutput = captureTmuxPane(ORCHESTRATOR_SESSION_NAME, flags.lines);
+        // 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 in HQ, check specifically for this HQ's session
+        if (sessionName) {
+            const isRunning = hostSessions.includes(sessionName);
+            let recentOutput = null;
+            if (isRunning && flags.peek) {
+                recentOutput = captureTmuxPane(sessionName, flags.lines);
+            }
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    running: isRunning,
+                    sessionId: isRunning ? sessionName : null,
+                    ...(recentOutput !== null && { recentOutput }),
+                }, createMetadata('orchestrator status', flags));
+                return;
+            }
+            this.log('');
+            if (isRunning) {
+                this.log(styles.success(`Orchestrator is running`));
+                this.log(styles.muted(`   Session: ${sessionName}`));
+                this.log(styles.muted(`   Attach: prlt orchestrator attach`));
+                this.log(styles.muted(`   Poke:   prlt session poke orchestrator "message"`));
+                if (recentOutput) {
+                    this.log('');
+                    this.log(styles.header('Recent output:'));
+                    this.log(styles.muted('─'.repeat(60)));
+                    this.log(recentOutput);
+                    this.log(styles.muted('─'.repeat(60)));
+                }
+            }
+            else {
+                this.log(styles.muted('Orchestrator is not running.'));
+                this.log(styles.muted('Start it with: prlt orchestrator start'));
+            }
+            this.log('');
+            return;
+        }
+        // Not in HQ — discover all running orchestrator sessions
+        const runningSessions = findRunningOrchestratorSessions(hostSessions);
         if (jsonMode) {
             outputSuccessAsJson({
-                running: isRunning,
-                sessionId: isRunning ? ORCHESTRATOR_SESSION_NAME : null,
-                ...(recentOutput !== null && { recentOutput }),
+                running: runningSessions.length > 0,
+                sessions: runningSessions,
             }, createMetadata('orchestrator status', flags));
             return;
         }
         this.log('');
-        if (isRunning) {
-            this.log(styles.success(`Orchestrator is running`));
-            this.log(styles.muted(`   Session: ${ORCHESTRATOR_SESSION_NAME}`));
-            this.log(styles.muted(`   Attach: prlt orchestrator attach`));
-            this.log(styles.muted(`   Poke:   prlt session poke orchestrator "message"`));
-            if (recentOutput) {
-                this.log('');
-                this.log(styles.header('Recent output:'));
-                this.log(styles.muted('─'.repeat(60)));
-                this.log(recentOutput);
-                this.log(styles.muted('─'.repeat(60)));
-            }
+        if (runningSessions.length === 0) {
+            this.log(styles.muted('No orchestrator sessions running.'));
+            this.log(styles.muted('Start one with: prlt orchestrator start'));
         }
         else {
-            this.log(styles.muted('Orchestrator is not running.'));
-            this.log(styles.muted('Start it with: prlt orchestrator start'));
+            this.log(styles.success(`${runningSessions.length} orchestrator session(s) running:`));
+            for (const s of runningSessions) {
+                this.log(styles.muted(`   ${s}`));
+                if (flags.peek) {
+                    const output = captureTmuxPane(s, flags.lines);
+                    if (output) {
+                        this.log(styles.muted('─'.repeat(60)));
+                        this.log(output);
+                        this.log(styles.muted('─'.repeat(60)));
+                    }
+                }
+            }
         }
         this.log('');
     }

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

@@ -3,6 +3,7 @@ export default class OrchestratorStop extends PromptCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;

package/dist/commands/orchestrator/stop.js

@@ -10,7 +10,8 @@ import { shouldOutputJson, outputErrorAsJson, outputSuccessAsJson, createMetadat
 import { styles } from '../../lib/styles.js';
 import { getHostTmuxSessionNames } from '../../lib/execution/session-utils.js';
 import { ExecutionStorage } from '../../lib/execution/storage.js';
-import { ORCHESTRATOR_SESSION_NAME } from './start.js';
+import { buildOrchestratorSessionName, findRunningOrchestratorSessions } from './start.js';
+import { getHeadquartersNameFromPath } from '../../lib/machine-config.js';
 export default class OrchestratorStop extends PromptCommand {
     static description = 'Stop the running orchestrator';
     static examples = [
@@ -19,6 +20,10 @@ export default class OrchestratorStop extends PromptCommand {
     ];
     static flags = {
         ...machineOutputFlags,
+        name: Flags.string({
+            char: 'n',
+            description: 'Name of the orchestrator session to stop (default: main)',
+        }),
         force: Flags.boolean({
             char: 'f',
             description: 'Skip confirmation',
@@ -28,16 +33,49 @@ export default class OrchestratorStop extends PromptCommand {
     async run() {
         const { flags } = await this.parse(OrchestratorStop);
         const jsonMode = shouldOutputJson(flags);
-        // Check if orchestrator session exists
         const hostSessions = getHostTmuxSessionNames();
-        if (!hostSessions.includes(ORCHESTRATOR_SESSION_NAME)) {
-            if (jsonMode) {
-                outputErrorAsJson('NOT_RUNNING', 'Orchestrator is not running.', createMetadata('orchestrator stop', 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;
+            }
+        }
+        // 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.', createMetadata('orchestrator stop', flags));
+                    return;
+                }
+                this.log('');
+                this.log(styles.muted('Orchestrator is not running.'));
+                this.log('');
                 return;
             }
-            this.log('');
-            this.log(styles.muted('Orchestrator is not running.'));
-            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 stop:',
+                        choices: runningSessions.map(s => ({
+                            name: s,
+                            value: s,
+                            command: `prlt orchestrator stop --name "${s}" --force --json`,
+                        })),
+                    }], jsonMode ? { flags, commandName: 'orchestrator stop' } : null);
+                sessionName = session;
+            }
+        }
+        if (!sessionName) {
             return;
         }
         // Confirm unless --force
@@ -45,7 +83,7 @@ export default class OrchestratorStop extends PromptCommand {
             const { confirmed } = await this.prompt([{
                     type: 'list',
                     name: 'confirmed',
-                    message: 'Stop the orchestrator?',
+                    message: `Stop the orchestrator (${sessionName})?`,
                     choices: [
                         { name: 'Yes', value: true },
                         { name: 'No', value: false },
@@ -58,7 +96,7 @@ export default class OrchestratorStop extends PromptCommand {
         }
         // Kill the tmux session
         try {
-            execSync(`tmux kill-session -t "${ORCHESTRATOR_SESSION_NAME}"`, { stdio: 'pipe' });
+            execSync(`tmux kill-session -t "${sessionName}"`, { stdio: 'pipe' });
         }
         catch (error) {
             if (jsonMode) {
@@ -67,8 +105,7 @@ export default class OrchestratorStop extends PromptCommand {
             }
             this.error(`Failed to stop orchestrator: ${error instanceof Error ? error.message : error}`);
         }
-        // Update execution record to stopped
-        const hqPath = findHQRoot(process.cwd());
+        // Update execution record to stopped (only if in HQ)
         if (hqPath) {
             const dbPath = path.join(hqPath, '.proletariat', 'workspace.db');
             if (fs.existsSync(dbPath)) {
@@ -92,7 +129,7 @@ export default class OrchestratorStop extends PromptCommand {
         }
         if (jsonMode) {
             outputSuccessAsJson({
-                sessionId: ORCHESTRATOR_SESSION_NAME,
+                sessionId: sessionName,
                 status: 'stopped',
             }, createMetadata('orchestrator stop', flags));
             return;