@proletariat/cli 0.3.46 → 0.3.48

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,29 @@ export default class SessionAttach extends PMOCommand {
     /**
      * Attach to session in current terminal
      */
-    async attachInCurrentTerminal(session) {
+    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} 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 +300,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,14 +308,23 @@ 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}"`;
+        // 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,9 +24,11 @@ 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` },
+            { id: 'review', name: 'Review pipeline (review → fix → re-review)', command: `prlt work review -P ${projectId} --json` },
             { id: 'ready', name: 'Mark work ready for review', command: `prlt work ready -P ${projectId} --json` },
             { id: 'complete', name: 'Mark work complete', command: `prlt work complete -P ${projectId} --json` },
             { id: 'cancel', name: 'Cancel', command: '' },
@@ -53,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;
@@ -62,6 +67,9 @@ export default class Work extends PMOCommand {
             case 'watch':
                 await this.config.runCommand('work:watch', projectArgs);
                 break;
+            case 'review':
+                await this.config.runCommand('work:review', projectArgs);
+                break;
             case 'ready':
                 await this.config.runCommand('work:ready', 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/review.d.ts

@@ -0,0 +1,45 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class WorkReview extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        ticketId: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        'max-cycles': import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        auto: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        executor: 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>;
+        display: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        session: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'poll-interval': import("@oclif/core/interfaces").OptionFlag<number, 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>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    execute(): Promise<void>;
+    /**
+     * Build args for `work:start` command.
+     */
+    private buildStartArgs;
+    /**
+     * Run the fix phase: spawn review-fix agent and wait for completion.
+     */
+    private runFixPhase;
+    /**
+     * Wait for the most recent execution on a ticket to complete.
+     * Polls the execution storage and checks tmux session existence.
+     */
+    private waitForAgentCompletion;
+    /**
+     * Check if a tmux session exists.
+     */
+    private checkTmuxSession;
+    /**
+     * Get the review verdict from PR feedback.
+     */
+    private getReviewVerdict;
+    private sleep;
+}