@proletariat/cli 0.3.47 → 0.3.48

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 { buildOrchestratorSessionName } 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 = [
@@ -30,38 +32,77 @@ 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(sessionName);
-        let recentOutput = null;
-        if (isRunning && flags.peek) {
-            recentOutput = captureTmuxPane(sessionName, 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 ? sessionName : 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: ${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)));
-            }
+        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.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 { buildOrchestratorSessionName } 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 = [
@@ -32,17 +33,49 @@ 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(sessionName)) {
-            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
@@ -50,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 },
@@ -72,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)) {

package/dist/commands/session/attach.js

@@ -270,6 +270,21 @@ export default class SessionAttach extends PMOCommand {
      */
     async attachInCurrentTerminal(session, useControlMode) {
         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 {
+                if (session.type === 'container' && session.containerId) {
+                    execSync(`docker exec ${session.containerId} tmux set-option -t "${session.sessionId}" mouse ${mouseMode}`, { stdio: 'pipe' });
+                }
+                else {
+                    execSync(`tmux set-option -t "${session.sessionId}" mouse ${mouseMode}`, { stdio: 'pipe' });
+                }
+            }
+            catch {
+                // Non-fatal: mouse mode is a convenience, don't block attach
+            }
             const tmuxAttach = buildTmuxAttachCommand(useControlMode, session.type === 'container');
             if (session.type === 'container' && session.containerId) {
                 execSync(`docker exec -it ${session.containerId} ${tmuxAttach} -t "${session.sessionId}"`, { stdio: 'inherit' });
@@ -297,11 +312,19 @@ export default class SessionAttach extends PMOCommand {
         const attachCmd = session.type === 'container' && session.containerId
             ? `docker exec -it ${session.containerId} ${tmuxAttach} -t "${session.sessionId}"`
             : `${tmuxAttach} -t "${session.sessionId}"`;
+        // Set mouse mode based on attach type
+        const mouseMode = useControlMode ? 'off' : 'on';
+        const mouseCmd = session.type === 'container' && session.containerId
+            ? `docker exec ${session.containerId} tmux set-option -t "${session.sessionId}" mouse ${mouseMode} 2>/dev/null || true`
+            : `tmux set-option -t "${session.sessionId}" mouse ${mouseMode} 2>/dev/null || true`;
         const script = `#!/bin/bash
 # Set terminal tab title
 echo -ne "\\033]0;${title}\\007"
 echo -ne "\\033]1;${title}\\007"
 
+# Set mouse mode before attaching
+${mouseCmd}
+
 echo "Attaching to: ${session.sessionId} (${session.type})"
 ${attachCmd}
 

package/dist/commands/session/poke.js

@@ -176,7 +176,7 @@ export default class SessionPoke extends PMOCommand {
      * Resolve the tmux session for a specific execution record.
      */
     resolveSessionForExecution(exec, jsonMode, flags) {
-        const isContainer = exec.environment === 'devcontainer';
+        const isContainer = !!exec.containerId;
         let actualSessionId = exec.sessionId;
         let containerId = isContainer ? exec.containerId : undefined;
         // If sessionId is NULL, try to discover it from tmux

package/dist/commands/work/index.js

@@ -24,6 +24,7 @@ export default class Work extends PMOCommand {
         const menuChoices = [
             { id: 'status', name: 'View work status (in-progress tickets)', command: `prlt work status -P ${projectId} --json` },
             { id: 'start', name: 'Start work (launch single agent)', command: `prlt work start -P ${projectId} --json` },
+            { id: 'linear', name: 'Spawn from Linear issue', command: `prlt work linear -P ${projectId} --json` },
             { id: 'resolve', name: 'Resolve questions (agent-assisted)', command: `prlt work resolve -P ${projectId} --json` },
             { id: 'spawn', name: 'Spawn work (batch by column)', command: `prlt work spawn -P ${projectId} --json` },
             { id: 'watch', name: 'Watch column (auto-spawn)', command: `prlt work watch -P ${projectId} --json` },
@@ -54,6 +55,9 @@ export default class Work extends PMOCommand {
             case 'start':
                 await this.config.runCommand('work:start', projectArgs);
                 break;
+            case 'linear':
+                await this.config.runCommand('work:linear', projectArgs);
+                break;
             case 'resolve':
                 await this.config.runCommand('work:resolve', projectArgs);
                 break;

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

@@ -0,0 +1,24 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class WorkLinear extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        team: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        issue: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        executor: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        display: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        action: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        message: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'run-on-host': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'skip-permissions': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'create-pr': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    private findLinkedTicket;
+    private createOrUpdateLinkedTicket;
+    execute(): Promise<void>;
+}

package/dist/commands/work/linear.js

@@ -0,0 +1,195 @@
+import { Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags, autoExportToBoard, } from '../../lib/pmo/index.js';
+import { shouldOutputJson, } from '../../lib/prompt-json.js';
+import { ExternalIssueAdapterError, } from '../../lib/external-issues/types.js';
+import { listLinearIssues, buildLinearIssueChoiceCommand, buildLinearTicketDescription, buildLinearMetadata, buildLinearSpawnContextMessage, } from '../../lib/external-issues/linear.js';
+function buildWorkStartArgs(options) {
+    const args = [options.ticketId, '--project', options.projectId, '--ephemeral'];
+    if (options.executor)
+        args.push('--executor', options.executor);
+    if (options.display)
+        args.push('--display', options.display);
+    if (options.runOnHost)
+        args.push('--run-on-host');
+    if (options.skipPermissions)
+        args.push('--skip-permissions');
+    if (options.createPr)
+        args.push('--create-pr');
+    if (options.action)
+        args.push('--action', options.action);
+    if (options.message)
+        args.push('--message', options.message);
+    if (options.json)
+        args.push('--json');
+    if (options.machine)
+        args.push('--machine');
+    if (options.yes)
+        args.push('--yes');
+    return args;
+}
+export default class WorkLinear extends PMOCommand {
+    static description = 'List/select Linear issues and spawn work using the existing work-start flow';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --team ENG',
+        '<%= config.bin %> <%= command.id %> --team ENG --issue ENG-123',
+        '<%= config.bin %> <%= command.id %> --team ENG --issue ENG-123 --yes --skip-permissions --display terminal',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        team: Flags.string({
+            description: 'Linear team key (fallback: PRLT_LINEAR_TEAM)',
+        }),
+        issue: Flags.string({
+            description: 'Linear issue identifier (for example: ENG-123)',
+        }),
+        limit: Flags.integer({
+            char: 'l',
+            description: 'Maximum number of Linear issues to fetch',
+            default: 20,
+            min: 1,
+            max: 100,
+        }),
+        executor: Flags.string({
+            char: 'e',
+            description: 'Override executor',
+            options: ['claude-code', 'codex', 'aider', 'custom'],
+        }),
+        display: Flags.string({
+            char: 'd',
+            description: 'Display mode',
+            options: ['terminal', 'background', 'foreground'],
+        }),
+        action: Flags.string({
+            char: 'A',
+            description: 'Action to run in work start (default: implement)',
+            default: 'implement',
+        }),
+        message: Flags.string({
+            description: 'Additional instructions appended to spawn context',
+        }),
+        'run-on-host': Flags.boolean({
+            description: 'Run on host even if devcontainer exists',
+            default: false,
+        }),
+        'skip-permissions': Flags.boolean({
+            description: 'Skip permission prompts (danger mode)',
+            default: false,
+        }),
+        'create-pr': Flags.boolean({
+            description: 'Create PR when work is ready',
+            default: false,
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Skip confirmation prompts in downstream work start',
+            default: false,
+        }),
+    };
+    async findLinkedTicket(projectId, envelope) {
+        const tickets = await this.storage.listTickets(projectId);
+        return tickets.find((ticket) => {
+            const source = ticket.metadata?.external_source;
+            const key = ticket.metadata?.external_key;
+            const id = ticket.metadata?.external_id;
+            return source === 'linear'
+                && (key === envelope.source.externalKey || id === envelope.source.externalId);
+        });
+    }
+    async createOrUpdateLinkedTicket(projectId, envelope) {
+        const existing = await this.findLinkedTicket(projectId, envelope);
+        const description = buildLinearTicketDescription(envelope);
+        const metadata = buildLinearMetadata(envelope);
+        if (existing) {
+            const updated = await this.storage.updateTicket(existing.id, {
+                title: envelope.title,
+                description,
+                priority: envelope.priority ?? undefined,
+                category: envelope.category ?? undefined,
+                labels: envelope.labels,
+                metadata: {
+                    ...existing.metadata,
+                    ...metadata,
+                },
+            });
+            return updated;
+        }
+        return this.storage.createTicket(projectId, {
+            title: envelope.title,
+            description,
+            priority: envelope.priority ?? undefined,
+            category: envelope.category ?? undefined,
+            labels: envelope.labels,
+            metadata,
+        });
+    }
+    async execute() {
+        const { flags } = await this.parse(WorkLinear);
+        const jsonMode = shouldOutputJson(flags);
+        const projectId = await this.requireProject({
+            jsonMode: {
+                flags,
+                commandName: 'work linear',
+                baseCommand: 'prlt work linear',
+            },
+        });
+        const team = flags.team || process.env.PRLT_LINEAR_TEAM;
+        let issues;
+        try {
+            issues = await listLinearIssues({
+                team,
+            }, { limit: flags.limit });
+        }
+        catch (error) {
+            if (error instanceof ExternalIssueAdapterError) {
+                return this.handleError(error.code, error.message, { jsonMode, commandName: 'work linear', flags });
+            }
+            const msg = error instanceof Error ? error.message : 'Failed to fetch Linear issues.';
+            return this.handleError('LINEAR_REQUEST_FAILED', msg, { jsonMode, commandName: 'work linear', flags });
+        }
+        if (issues.length === 0) {
+            return this.handleError('NO_LINEAR_ISSUES', 'No active Linear issues found for the configured team.', { jsonMode, commandName: 'work linear', flags });
+        }
+        let selectedIssue = issues.find(issue => issue.source.externalKey === flags.issue);
+        if (!selectedIssue) {
+            if (flags.issue) {
+                return this.handleError('LINEAR_ISSUE_NOT_FOUND', `Linear issue "${flags.issue}" was not found.`, { jsonMode, commandName: 'work linear', flags });
+            }
+            const selectedKey = await this.selectFromList({
+                message: 'Select Linear issue to spawn:',
+                items: issues,
+                getName: (issue) => {
+                    const priority = issue.priority || 'None';
+                    return `[${priority}] ${issue.source.externalKey} - ${issue.title}`;
+                },
+                getValue: issue => issue.source.externalKey,
+                getCommand: issue => buildLinearIssueChoiceCommand(issue.source.externalKey, projectId),
+                jsonMode: jsonMode ? { flags, commandName: 'work linear' } : null,
+            });
+            if (!selectedKey) {
+                return;
+            }
+            selectedIssue = issues.find(issue => issue.source.externalKey === selectedKey);
+            if (!selectedIssue) {
+                return this.handleError('LINEAR_ISSUE_NOT_FOUND', `Linear issue "${selectedKey}" was not found.`, { jsonMode, commandName: 'work linear', flags });
+            }
+        }
+        const ticket = await this.createOrUpdateLinkedTicket(projectId, selectedIssue);
+        await autoExportToBoard(this.pmoPath, this.storage);
+        const contextMessage = buildLinearSpawnContextMessage(selectedIssue, flags.message);
+        const args = buildWorkStartArgs({
+            ticketId: ticket.id,
+            projectId,
+            executor: flags.executor,
+            display: flags.display,
+            runOnHost: flags['run-on-host'],
+            skipPermissions: flags['skip-permissions'],
+            createPr: flags['create-pr'],
+            action: flags.action,
+            message: contextMessage,
+            json: flags.json,
+            machine: flags.machine,
+            yes: flags.yes,
+        });
+        await this.config.runCommand('work:start', args);
+    }
+}

package/dist/commands/work/spawn.js

@@ -1357,26 +1357,35 @@ export default class WorkSpawn extends PMOCommand {
                     batchOutput = 'interactive';
                 }
                 // Prompt for permissions mode if not explicitly set via --skip-permissions flag
+                // Non-code-modifying actions (review, review-comment, groom) default to safe mode
+                // to prevent agents from performing destructive operations like merging PRs
+                const spawnActionModifiesCode = selectedActionDetails?.modifiesCode ?? true;
                 if (!flags['skip-permissions']) {
-                    // Use FlagResolver for permission mode
-                    const permissionResolver = new FlagResolver({
-                        commandName: 'work spawn',
-                        baseCommand: 'prlt work spawn',
-                        jsonMode,
-                        flags: {},
-                    });
-                    permissionResolver.addPrompt({
-                        flagName: 'permissionMode',
-                        type: 'list',
-                        message: `Permission mode for ${executorName}:`,
-                        default: 'danger',
-                        choices: () => [
-                            { name: '⚠️  danger - Skip permission checks (faster, container provides isolation)', value: 'danger' },
-                            { name: '🔒 safe   - Requires approval for dangerous operations', value: 'safe' },
-                        ],
-                    });
-                    const permissionResult = await permissionResolver.resolve();
-                    batchPermissionMode = permissionResult.permissionMode;
+                    if (!spawnActionModifiesCode) {
+                        // Non-code-modifying actions automatically use safe mode
+                        batchPermissionMode = 'safe';
+                    }
+                    else {
+                        // Use FlagResolver for permission mode
+                        const permissionResolver = new FlagResolver({
+                            commandName: 'work spawn',
+                            baseCommand: 'prlt work spawn',
+                            jsonMode,
+                            flags: {},
+                        });
+                        permissionResolver.addPrompt({
+                            flagName: 'permissionMode',
+                            type: 'list',
+                            message: `Permission mode for ${executorName}:`,
+                            default: 'danger',
+                            choices: () => [
+                                { name: '⚠️  danger - Skip permission checks (faster, container provides isolation)', value: 'danger' },
+                                { name: '🔒 safe   - Requires approval for dangerous operations', value: 'safe' },
+                            ],
+                        });
+                        const permissionResult = await permissionResolver.resolve();
+                        batchPermissionMode = permissionResult.permissionMode;
+                    }
                 }
                 // Prompt for PR creation if not provided AND action modifies code
                 // Resolution order: explicit flags > workspace config default > interactive prompt

package/dist/commands/work/start.js

@@ -1206,9 +1206,17 @@ export default class WorkStart extends PMOCommand {
             }
             // Prompt for permissions mode (all environments)
             // Use FlagResolver to handle both JSON mode and interactive prompts consistently
+            // Non-code-modifying actions (review, review-comment, groom) default to safe mode
+            // to prevent agents from performing destructive operations like merging PRs
+            const actionModifiesCode = context.modifiesCode !== false;
+            const defaultPermissionMode = actionModifiesCode ? 'danger' : 'safe';
             if (flags['permission-mode']) {
                 sandboxed = flags['permission-mode'] === 'safe';
             }
+            else if (!actionModifiesCode) {
+                // Non-code-modifying actions automatically use safe mode
+                sandboxed = true;
+            }
             else {
                 const containerNote = environment === 'devcontainer'
                     ? ' (container provides additional isolation)'
@@ -1225,7 +1233,7 @@ export default class WorkStart extends PMOCommand {
                     flagName: 'permission-mode',
                     type: 'list',
                     message: `Permission mode for ${executorName}${containerNote}:`,
-                    default: 'danger',
+                    default: defaultPermissionMode,
                     choices: () => [
                         { name: '⚠️  danger - Skip permission checks (faster, container provides isolation)', value: 'danger' },
                         { name: '🔒 safe   - Requires approval for dangerous operations', value: 'safe' },
@@ -1980,9 +1988,11 @@ export default class WorkStart extends PMOCommand {
         const hasDevcontainer = hasDevcontainerConfig(agentDir);
         const useDevcontainer = hasDevcontainer && !flags['run-on-host'];
         // Non-interactive defaults
+        // Non-code-modifying actions default to safe mode to prevent destructive operations
         const environment = useDevcontainer ? 'devcontainer' : 'host';
         const displayMode = 'terminal';
-        const sandboxed = flags['permission-mode'] === 'safe';
+        const actionModifiesCode = context.modifiesCode !== false;
+        const sandboxed = flags['permission-mode'] === 'safe' || (!flags['permission-mode'] && !actionModifiesCode);
         const executor = flags.executor || DEFAULT_EXECUTION_CONFIG.defaultExecutor;
         const outputMode = 'interactive';
         // Handle git branch - only if action modifies code

package/dist/hooks/init.js

@@ -18,6 +18,14 @@ const hook = async function ({ id, argv, config }) {
     if (process.env.OCLIF_COMPILATION || process.argv[1]?.includes('oclif')) {
         return;
     }
+    // Skip when in test environments that provide their own HQ
+    if (process.env.PRLT_HQ_PATH && process.env.PRLT_TEST_ENV) {
+        return;
+    }
+    // Skip init redirect when explicitly disabled (e.g., e2e test isolation)
+    if (process.env.PRLT_SKIP_INIT_REDIRECT === '1') {
+        return;
+    }
     // Skip when --help or --version flags are present - these should always be available
     // Check both process.argv (production CLI) and the oclif-provided argv
     // (programmatic invocation via @oclif/test runCommand)