@proletariat/cli 0.3.46 → 0.3.48

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/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.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,17 @@ 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 { findHQRoot } from '../../lib/workspace.js';
+import { getHeadquartersNameFromPath } from '../../lib/machine-config.js';
+import { loadExecutionConfig, shouldUseControlMode, buildTmuxAttachCommand } from '../../lib/execution/index.js';
+import { buildOrchestratorSessionName, findRunningOrchestratorSessions } from './start.js';
 /**
  * Detect the terminal emulator from environment variables.
  * Returns a terminal app name suitable for AppleScript tab creation,
@@ -24,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';
@@ -35,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';
@@ -48,6 +55,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,22 +77,55 @@ export default class OrchestratorAttach extends PromptCommand {
     async run() {
         const { flags } = await this.parse(OrchestratorAttach);
         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. 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) {
             outputSuccessAsJson({
-                sessionId: ORCHESTRATOR_SESSION_NAME,
+                sessionId: sessionName,
                 status: 'attaching',
             }, createMetadata('orchestrator attach', flags));
             return;
@@ -93,7 +137,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 +166,39 @@ 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' });
+            // 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' });
         }
         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 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`);
@@ -130,7 +207,10 @@ export default class OrchestratorAttach extends PromptCommand {
 echo -ne "\\033]0;${title}\\007"
 echo -ne "\\033]1;${title}\\007"
 
-echo "Attaching to: ${ORCHESTRATOR_SESSION_NAME}"
+# Set mouse mode before attaching
+tmux set-option -t "${sessionName}" mouse ${mouseMode} 2>/dev/null || true
+
+echo "Attaching to: ${sessionName}"
 ${attachCmd}
 
 # Clean up