@proletariat/cli 0.3.46 → 0.3.47

package/bin/validate-better-sqlite3.cjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+const SUPPORTED_NODE_MAJORS = [20, 22, 23, 24, 25]
+
+function parseNodeMajor(version) {
+  const match = /^v?(\d+)/.exec(version)
+  return match ? Number.parseInt(match[1], 10) : null
+}
+
+function runtimeInfo() {
+  return {
+    nodeVersion: process.version,
+    nodeMajor: parseNodeMajor(process.version),
+    abi: process.versions.modules,
+    platform: process.platform,
+    arch: process.arch,
+  }
+}
+
+function buildMessage(error, context) {
+  const info = runtimeInfo()
+  const nodeMajorHint = info.nodeMajor === null || SUPPORTED_NODE_MAJORS.includes(info.nodeMajor)
+    ? ''
+    : `\n- Unsupported Node major for this CLI: ${info.nodeMajor} (supported: ${SUPPORTED_NODE_MAJORS.join(', ')})`
+  const reason = error instanceof Error ? error.message : String(error)
+
+  return [
+    `better-sqlite3 native module validation failed (${context}).`,
+    `Runtime: node ${info.nodeVersion} (ABI ${info.abi}) on ${info.platform}-${info.arch}.${nodeMajorHint}`,
+    `Load error: ${reason}`,
+    '',
+    'Fix steps:',
+    '1. Rebuild native bindings for this runtime: npm rebuild better-sqlite3',
+    '2. Verify runtime architecture: node -p "process.platform + \'-\' + process.arch + \' abi=\' + process.versions.modules"',
+    '3. Reinstall with your active Node version if needed: npm uninstall -g @proletariat/cli && npm install -g @proletariat/cli',
+  ].join('\n')
+}
+
+function validate(context) {
+  try {
+    const Database = require('better-sqlite3')
+    const db = new Database(':memory:')
+    db.pragma('foreign_keys = ON')
+    db.close()
+  } catch (error) {
+    throw new Error(buildMessage(error, context))
+  }
+}
+
+try {
+  validate('postinstall')
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error))
+  process.exit(1)
+}

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

@@ -9,6 +9,7 @@ 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>;

package/dist/commands/orchestrator/attach.js

@@ -3,12 +3,15 @@ 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,
@@ -48,6 +51,10 @@ export default class OrchestratorAttach extends PromptCommand {
     ];
     static flags = {
         ...machineOutputFlags,
+        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,
@@ -66,9 +73,10 @@ 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(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;
@@ -81,7 +89,7 @@ export default class OrchestratorAttach extends PromptCommand {
         }
         if (jsonMode) {
             outputSuccessAsJson({
-                sessionId: ORCHESTRATOR_SESSION_NAME,
+                sessionId: sessionName,
                 status: 'attaching',
             }, createMetadata('orchestrator attach', flags));
             return;
@@ -93,7 +101,27 @@ export default class OrchestratorAttach extends PromptCommand {
             this.log(styles.warning('--terminal has no effect without --new-tab. Ignoring.'));
         }
         this.log('');
-        this.log(styles.info(`Attaching to orchestrator session: ${ORCHESTRATOR_SESSION_NAME}`));
+        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 {
+                const config = loadExecutionConfig(db);
+                const termApp = detectTerminalApp();
+                if (termApp === 'iTerm') {
+                    useControlMode = shouldUseControlMode('iTerm', config.tmux.controlMode);
+                }
+            }
+            finally {
+                db.close();
+            }
+        }
+        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();
@@ -102,26 +130,28 @@ export default class OrchestratorAttach extends PromptCommand {
                 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();
+                this.attachInCurrentTerminal(useControlMode, sessionName);
                 return;
             }
-            await this.openInNewTab(terminalApp);
+            await this.openInNewTab(terminalApp, useControlMode, sessionName);
         }
         else {
-            this.attachInCurrentTerminal();
+            this.attachInCurrentTerminal(useControlMode, sessionName);
         }
     }
-    attachInCurrentTerminal() {
+    attachInCurrentTerminal(useControlMode, sessionName) {
         try {
-            execSync(`tmux attach -t "${ORCHESTRATOR_SESSION_NAME}"`, { stdio: 'inherit' });
+            const tmuxAttach = buildTmuxAttachCommand(useControlMode);
+            execSync(`${tmuxAttach} -t "${sessionName}"`, { stdio: 'inherit' });
         }
         catch {
-            this.error(`Failed to attach to orchestrator session "${ORCHESTRATOR_SESSION_NAME}"`);
+            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`);
@@ -130,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,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.
+ * 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>;
     };

package/dist/commands/orchestrator/start.js

@@ -11,8 +11,26 @@ 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';
+/**
+ * Build orchestrator tmux session name.
+ * Default: 'prlt-orchestrator-main'
+ * With --name: 'prlt-orchestrator-{name}'
+ */
+export function buildOrchestratorSessionName(name = 'main') {
+    const safeName = name
+        .replace(/[^a-zA-Z0-9._-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+    return `prlt-orchestrator-${safeName || 'main'}`;
+}
+/**
+ * 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,36 +65,50 @@ 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';
+        const sessionName = buildOrchestratorSessionName(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;
         }
@@ -169,12 +201,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 +234,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 +290,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 +316,7 @@ export default class OrchestratorStart extends PromptCommand {
                         environment: 'host',
                         displayMode,
                         sandboxed,
-                        sessionId: result.sessionId || ORCHESTRATOR_SESSION_NAME,
+                        sessionId: result.sessionId || sessionName,
                     });
                 }
                 catch {
@@ -255,17 +325,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,7 @@ 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 { buildOrchestratorSessionName } from './start.js';
 export default class OrchestratorStatus extends PromptCommand {
     static description = 'Check if the orchestrator is running';
     static examples = [
@@ -14,6 +14,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,
@@ -26,16 +30,17 @@ export default class OrchestratorStatus extends PromptCommand {
     async run() {
         const { flags } = await this.parse(OrchestratorStatus);
         const jsonMode = shouldOutputJson(flags);
+        const sessionName = buildOrchestratorSessionName(flags.name || 'main');
         const hostSessions = getHostTmuxSessionNames();
-        const isRunning = hostSessions.includes(ORCHESTRATOR_SESSION_NAME);
+        const isRunning = hostSessions.includes(sessionName);
         let recentOutput = null;
         if (isRunning && flags.peek) {
-            recentOutput = captureTmuxPane(ORCHESTRATOR_SESSION_NAME, flags.lines);
+            recentOutput = captureTmuxPane(sessionName, flags.lines);
         }
         if (jsonMode) {
             outputSuccessAsJson({
                 running: isRunning,
-                sessionId: isRunning ? ORCHESTRATOR_SESSION_NAME : null,
+                sessionId: isRunning ? sessionName : null,
                 ...(recentOutput !== null && { recentOutput }),
             }, createMetadata('orchestrator status', flags));
             return;
@@ -43,7 +48,7 @@ export default class OrchestratorStatus extends PromptCommand {
         this.log('');
         if (isRunning) {
             this.log(styles.success(`Orchestrator is running`));
-            this.log(styles.muted(`   Session: ${ORCHESTRATOR_SESSION_NAME}`));
+            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) {

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,7 @@ 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 } from './start.js';
 export default class OrchestratorStop extends PromptCommand {
     static description = 'Stop the running orchestrator';
     static examples = [
@@ -19,6 +19,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,9 +32,10 @@ export default class OrchestratorStop extends PromptCommand {
     async run() {
         const { flags } = await this.parse(OrchestratorStop);
         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.', createMetadata('orchestrator stop', flags));
                 return;
@@ -58,7 +63,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) {
@@ -92,7 +97,7 @@ export default class OrchestratorStop extends PromptCommand {
         }
         if (jsonMode) {
             outputSuccessAsJson({
-                sessionId: ORCHESTRATOR_SESSION_NAME,
+                sessionId: sessionName,
                 status: 'stopped',
             }, createMetadata('orchestrator stop', flags));
             return;

package/dist/commands/session/attach.js

@@ -6,7 +6,8 @@ import * as os from 'node:os';
 import Database from 'better-sqlite3';
 import { styles } from '../../lib/styles.js';
 import { getWorkspaceInfo } from '../../lib/agents/commands.js';
-import { ExecutionStorage } from '../../lib/execution/index.js';
+import { ExecutionStorage, loadExecutionConfig, shouldUseControlMode, buildTmuxAttachCommand } from '../../lib/execution/index.js';
+import { detectTerminalApp } from '../orchestrator/attach.js';
 import { parseSessionName, getHostTmuxSessionNames, getContainerTmuxSessionMap, flattenContainerSessions, findContainerSessionsByPrefix, findSessionForExecution, } from '../../lib/execution/session-utils.js';
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
 import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
@@ -106,12 +107,32 @@ export default class SessionAttach extends PMOCommand {
         // Attach to the session
         this.log('');
         this.log(styles.info(`Attaching to session: ${selectedSession.sessionId}`));
+        // 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 {
+                const config = loadExecutionConfig(db);
+                const termApp = detectTerminalApp();
+                if (termApp === 'iTerm') {
+                    useControlMode = shouldUseControlMode('iTerm', config.tmux.controlMode);
+                }
+            }
+            finally {
+                db.close();
+            }
+        }
+        catch {
+            // Not in a workspace or DB not available - fall back to no control mode
+        }
         // Default to new tab unless --current-terminal is specified
         if (flags['current-terminal']) {
-            await this.attachInCurrentTerminal(selectedSession);
+            await this.attachInCurrentTerminal(selectedSession, useControlMode);
         }
         else {
-            await this.attachInNewTab(selectedSession, flags.terminal);
+            await this.attachInNewTab(selectedSession, flags.terminal, useControlMode);
         }
     }
     /**
@@ -247,13 +268,14 @@ export default class SessionAttach extends PMOCommand {
     /**
      * Attach to session in current terminal
      */
-    async attachInCurrentTerminal(session) {
+    async attachInCurrentTerminal(session, useControlMode) {
         try {
+            const tmuxAttach = buildTmuxAttachCommand(useControlMode, session.type === 'container');
             if (session.type === 'container' && session.containerId) {
-                execSync(`docker exec -it ${session.containerId} tmux attach -t "${session.sessionId}"`, { stdio: 'inherit' });
+                execSync(`docker exec -it ${session.containerId} ${tmuxAttach} -t "${session.sessionId}"`, { stdio: 'inherit' });
             }
             else {
-                execSync(`tmux attach -t "${session.sessionId}"`, { stdio: 'inherit' });
+                execSync(`${tmuxAttach} -t "${session.sessionId}"`, { stdio: 'inherit' });
             }
         }
         catch {
@@ -263,7 +285,7 @@ export default class SessionAttach extends PMOCommand {
     /**
      * Attach to session in a new terminal tab
      */
-    async attachInNewTab(session, terminalApp) {
+    async attachInNewTab(session, terminalApp, useControlMode) {
         // Build a readable title for the tab
         const title = `${session.ticketId} (${session.agentName})`;
         // Create a script that sets tab title and attaches to tmux
@@ -271,9 +293,10 @@ export default class SessionAttach extends PMOCommand {
         fs.mkdirSync(baseDir, { recursive: true });
         const scriptPath = path.join(baseDir, `attach-${Date.now()}.sh`);
         // Different attach command for container vs host sessions
+        const tmuxAttach = buildTmuxAttachCommand(useControlMode, session.type === 'container');
         const attachCmd = session.type === 'container' && session.containerId
-            ? `docker exec -it ${session.containerId} tmux -u attach -t "${session.sessionId}"`
-            : `tmux attach -t "${session.sessionId}"`;
+            ? `docker exec -it ${session.containerId} ${tmuxAttach} -t "${session.sessionId}"`
+            : `${tmuxAttach} -t "${session.sessionId}"`;
         const script = `#!/bin/bash
 # Set terminal tab title
 echo -ne "\\033]0;${title}\\007"