@proletariat/cli 0.3.45 → 0.3.46

package/dist/commands/ticket/link/relates.d.ts

@@ -0,0 +1,15 @@
+import { PMOCommand } from '../../../lib/pmo/index.js';
+export default class TicketLinkRelates extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        ticket: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        related: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        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>;
+}

package/dist/commands/ticket/link/relates.js

@@ -0,0 +1,95 @@
+import { Args } from '@oclif/core';
+import { autoExportToBoard, PMOCommand, pmoBaseFlags } from '../../../lib/pmo/index.js';
+import { styles } from '../../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, outputSuccessAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../../lib/prompt-json.js';
+export default class TicketLinkRelates extends PMOCommand {
+    static description = 'Add a relates-to dependency between two tickets';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> TKT-001 TKT-002',
+        '<%= config.bin %> <%= command.id %> TKT-001',
+        '<%= config.bin %> <%= command.id %> TKT-001 --json',
+    ];
+    static args = {
+        ticket: Args.string({
+            description: 'First ticket',
+            required: true,
+        }),
+        related: Args.string({
+            description: 'Second ticket (related)',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+    };
+    async execute() {
+        const { args, flags } = await this.parse(TicketLinkRelates);
+        const jsonMode = shouldOutputJson(flags);
+        const projectId = await this.requireProject();
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('ticket link relates', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Verify the source ticket exists
+        const ticket = await this.storage.getTicket(args.ticket);
+        if (!ticket) {
+            return handleError('TICKET_NOT_FOUND', `Ticket not found: ${args.ticket}`);
+        }
+        // If related ticket not provided, prompt for selection
+        if (!args.related) {
+            const tickets = await this.storage.listTickets(projectId);
+            const otherTickets = tickets.filter(t => t.id !== args.ticket);
+            if (otherTickets.length === 0) {
+                return handleError('NO_TICKETS', 'No other tickets to select as related.');
+            }
+            const projectFlag = flags.project ? ` -P ${flags.project}` : '';
+            const choices = otherTickets.map(t => ({
+                name: `${t.id} - ${t.title}`,
+                value: t.id,
+                command: `prlt ticket link relates ${args.ticket} ${t.id}${projectFlag} --json`,
+            }));
+            const message = `Select ticket to relate to ${args.ticket}:`;
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('list', 'related', message, choices), createMetadata('ticket link relates', flags));
+                return;
+            }
+            const { selected } = await this.prompt([{
+                    type: 'list',
+                    name: 'selected',
+                    message,
+                    choices,
+                }], null);
+            args.related = selected;
+        }
+        // Verify related ticket exists
+        const relatedTicket = await this.storage.getTicket(args.related);
+        if (!relatedTicket) {
+            return handleError('RELATED_NOT_FOUND', `Related ticket not found: ${args.related}`);
+        }
+        // Create the relates_to dependency
+        try {
+            await this.storage.createTicketDependency(args.ticket, args.related, 'relates_to');
+            await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    ticketId: args.ticket,
+                    relatedTicketId: args.related,
+                    type: 'relates_to',
+                }, createMetadata('ticket link relates', flags));
+                return;
+            }
+            this.log(styles.success(`\n${args.ticket} now relates to ${args.related}`));
+            this.log(styles.muted(`  ${ticket.title}`));
+            this.log(styles.muted(`  relates to: ${relatedTicket.title}`));
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('already exists')) {
+                return handleError('ALREADY_EXISTS', 'Relates-to dependency already exists.');
+            }
+            throw error;
+        }
+    }
+}

package/dist/commands/work/revise.js

@@ -8,7 +8,7 @@ import { getWorkColumnSetting, findColumnByName } from '../../lib/pmo/utils.js';
 import { styles } from '../../lib/styles.js';
 import { getWorkspaceInfo, resolveAgentDir } from '../../lib/agents/commands.js';
 import { DEFAULT_EXECUTION_CONFIG, } from '../../lib/execution/types.js';
-import { runExecution, isDockerRunning, isDevcontainerCliInstalled } from '../../lib/execution/runners.js';
+import { runExecution, isDockerRunning, isDevcontainerCliInstalled, getExecutorDisplayName } from '../../lib/execution/runners.js';
 import { ExecutionStorage } from '../../lib/execution/storage.js';
 import { loadExecutionConfig, getTerminalApp, getShell, hasTerminalPreference, hasShellPreference } from '../../lib/execution/config.js';
 import { hasDevcontainerConfig } from '../../lib/execution/devcontainer.js';
@@ -242,12 +242,14 @@ export default class WorkRevise extends PMOCommand {
                 // Host environment: terminal/background are display modes
                 displayMode = flags.mode;
             }
+            const executor = flags.executor || DEFAULT_EXECUTION_CONFIG.defaultExecutor;
+            const executorName = getExecutorDisplayName(executor);
             // Permission mode
             const { permissionMode } = await this.prompt([
                 {
                     type: 'list',
                     name: 'permissionMode',
-                    message: 'Permission mode for Claude Code:',
+                    message: `Permission mode for ${executorName}:`,
                     choices: [
                         { name: 'danger - Skip permission checks (faster for revisions)', value: 'danger', command: `prlt work revise ${ticketId} --json` },
                         { name: 'safe   - Requires approval for dangerous operations', value: 'safe', command: `prlt work revise ${ticketId} --json` },
@@ -256,7 +258,6 @@ export default class WorkRevise extends PMOCommand {
                 },
             ], reviseJsonModeConfig);
             sandboxed = permissionMode === 'safe';
-            const executor = flags.executor || DEFAULT_EXECUTION_CONFIG.defaultExecutor;
             // Show execution info
             this.log('');
             this.log(styles.header(`Revising: ${ticket.id}: ${ticket.title}`));

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

@@ -31,6 +31,11 @@ export default class WorkSpawn extends PMOCommand {
         priority: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         epic: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         status: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'from-linear': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'linear-team': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'linear-state': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'linear-label': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'linear-limit': import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
         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>;

package/dist/commands/work/spawn.js

@@ -4,10 +4,12 @@ import Database from 'better-sqlite3';
 import { PMOCommand, pmoBaseFlags, autoExportToBoard } from '../../lib/pmo/index.js';
 import { styles } from '../../lib/styles.js';
 import { getWorkspaceInfo, getTicketTmuxSession, killTmuxSession } from '../../lib/agents/commands.js';
-import { isDockerRunning, isGitHubTokenAvailable, isDevcontainerCliInstalled } from '../../lib/execution/runners.js';
+import { isDockerRunning, isGitHubTokenAvailable, isDevcontainerCliInstalled, getExecutorDisplayName } from '../../lib/execution/runners.js';
+import { getCreatePrDefault, loadExecutionConfig } from '../../lib/execution/config.js';
 import { shouldOutputJson, outputSuccessAsJson, outputErrorAsJson, createMetadata, outputConfirmationNeededAsJson, outputExecutionResultAsJson, } from '../../lib/prompt-json.js';
 import { FlagResolver } from '../../lib/flags/index.js';
 import { loadDietConfig, formatDietConfig, } from '../../lib/pmo/diet.js';
+import { LinearClient, LinearMapper, isLinearConfigured, loadLinearConfig, } from '../../lib/linear/index.js';
 export default class WorkSpawn extends PMOCommand {
     static description = 'Spawn work for multiple tickets by column (batch mode)';
     static strict = false; // Allow multiple ticket ID args without defining them
@@ -24,6 +26,10 @@ export default class WorkSpawn extends PMOCommand {
         '<%= config.bin %> <%= command.id %> --count 10 --diet --action groom  # Diet-balanced',
         '<%= config.bin %> <%= command.id %> --count 5 --category ship --action implement  # Filtered by category',
         '<%= config.bin %> <%= command.id %> --count 5 --priority P0 --action implement  # Filtered by priority',
+        '<%= config.bin %> <%= command.id %> --from-linear                      # Pull Linear issues → PMO → spawn',
+        '<%= config.bin %> <%= command.id %> --from-linear ENG-123 ENG-124      # Pull specific Linear issues → spawn',
+        '<%= config.bin %> <%= command.id %> --from-linear --linear-team ENG    # Pull from specific team',
+        '<%= config.bin %> <%= command.id %> --from-linear --linear-state "In Progress"  # Filter by state',
         '<%= config.bin %> <%= command.id %> --count 10 --diet --category ship,grow --action groom  # Combined',
         '<%= config.bin %> <%= command.id %> TKT-001 TKT-002 --create-pr  # Create PR when work is ready',
     ];
@@ -141,6 +147,28 @@ export default class WorkSpawn extends PMOCommand {
         status: Flags.string({
             description: 'Filter tickets by status name (e.g., Backlog, Ready)',
         }),
+        // Linear integration flags
+        'from-linear': Flags.boolean({
+            description: 'Pull issues from Linear, mirror into PMO, then spawn agents',
+            default: false,
+        }),
+        'linear-team': Flags.string({
+            description: 'Linear team key to pull issues from (e.g., ENG)',
+            dependsOn: ['from-linear'],
+        }),
+        'linear-state': Flags.string({
+            description: 'Filter Linear issues by state name (e.g., "In Progress")',
+            dependsOn: ['from-linear'],
+        }),
+        'linear-label': Flags.string({
+            description: 'Filter Linear issues by label name',
+            dependsOn: ['from-linear'],
+        }),
+        'linear-limit': Flags.integer({
+            description: 'Maximum number of Linear issues to pull',
+            default: 20,
+            dependsOn: ['from-linear'],
+        }),
     };
     async execute() {
         const { flags, argv } = await this.parse(WorkSpawn);
@@ -154,12 +182,121 @@ export default class WorkSpawn extends PMOCommand {
             }
             this.error(message);
         };
+        // Check for conflicting PR flags (before deprecation warning to fail fast)
+        if (flags['create-pr'] && flags['no-pr']) {
+            this.error('--create-pr and --no-pr are mutually exclusive');
+        }
         // Deprecation guidance for --no-pr
         if (flags['no-pr']) {
             this.warn('--no-pr is deprecated. Omit --create-pr instead (PR creation is off by default). --no-pr will continue to work.');
         }
         // Parse ticket IDs from args (everything after flags)
-        const ticketIdArgs = argv;
+        let ticketIdArgs = argv;
+        // =========================================================================
+        // --from-linear: Pull Linear issues → mirror into PMO → spawn from PMO
+        // =========================================================================
+        if (flags['from-linear']) {
+            const db = this.storage.getDatabase();
+            if (!isLinearConfigured(db)) {
+                return handleError('LINEAR_NOT_CONFIGURED', 'Linear is not configured. Run "prlt linear auth" first.');
+            }
+            const linearConfig = loadLinearConfig(db);
+            const linearClient = new LinearClient(linearConfig.apiKey);
+            const mapper = new LinearMapper(db);
+            // Determine project first (needed for ticket creation)
+            const linearProjectId = await this.requireProject({
+                jsonMode: jsonMode ? {
+                    flags,
+                    commandName: 'work spawn',
+                    baseCommand: 'prlt work spawn --from-linear',
+                } : undefined,
+            });
+            // Get project workflow statuses for mapping
+            const workflow = await this.storage.getProjectWorkflow(linearProjectId);
+            if (!workflow) {
+                return handleError('NO_WORKFLOW', 'Project has no workflow configured.');
+            }
+            const statuses = await this.storage.listStatuses(workflow.id);
+            // Check if args are Linear identifiers (e.g., ENG-123)
+            const linearIdentifiers = ticketIdArgs.filter((id) => /^[A-Z]+-\d+$/i.test(id));
+            const pmoTicketIds = [];
+            if (linearIdentifiers.length > 0) {
+                // Fetch and import specific Linear issues
+                if (!jsonMode) {
+                    this.log(styles.muted(`Pulling ${linearIdentifiers.length} issue(s) from Linear...`));
+                }
+                for (const identifier of linearIdentifiers) {
+                    // eslint-disable-next-line no-await-in-loop
+                    const issue = await linearClient.getIssueByIdentifier(identifier);
+                    if (!issue) {
+                        if (!jsonMode)
+                            this.warn(`Linear issue not found: ${identifier}`);
+                        continue;
+                    }
+                    // eslint-disable-next-line no-await-in-loop
+                    const { ticketId, created } = await mapper.importIssue(issue, linearProjectId, this.storage, statuses);
+                    pmoTicketIds.push(ticketId);
+                    if (!jsonMode) {
+                        const action = created ? 'Imported' : 'Already imported';
+                        this.log(styles.muted(`  ${action}: ${identifier} → ${ticketId}`));
+                    }
+                }
+            }
+            else {
+                // Fetch issues using filters
+                const filter = {
+                    teamKey: flags['linear-team'] ?? linearConfig.defaultTeamKey,
+                    stateName: flags['linear-state'],
+                    labelName: flags['linear-label'],
+                    limit: flags['linear-limit'],
+                };
+                if (!jsonMode) {
+                    this.log(styles.muted(`Pulling issues from Linear (team: ${filter.teamKey ?? 'all'})...`));
+                }
+                const issues = await linearClient.listIssues(filter);
+                if (issues.length === 0) {
+                    if (jsonMode) {
+                        outputSuccessAsJson({
+                            imported: 0,
+                            spawned: 0,
+                            message: 'No matching Linear issues found.',
+                        }, createMetadata('work spawn', flags));
+                        return;
+                    }
+                    this.log(styles.muted('No matching Linear issues found.'));
+                    return;
+                }
+                if (!jsonMode) {
+                    this.log(styles.muted(`Found ${issues.length} issue(s). Importing into PMO...`));
+                }
+                const result = await mapper.importIssues(issues, linearProjectId, this.storage, statuses);
+                if (!jsonMode) {
+                    if (result.imported > 0)
+                        this.log(styles.success(`  Imported: ${result.imported}`));
+                    if (result.skipped > 0)
+                        this.log(styles.muted(`  Already imported: ${result.skipped}`));
+                    if (result.errors.length > 0)
+                        this.log(styles.error(`  Errors: ${result.errors.length}`));
+                }
+                // Collect all PMO ticket IDs (both new and existing)
+                for (const issue of issues) {
+                    const existing = mapper.getByLinearId(issue.id);
+                    if (existing) {
+                        pmoTicketIds.push(existing.pmoTicketId);
+                    }
+                }
+            }
+            if (pmoTicketIds.length === 0) {
+                return handleError('NO_LINEAR_ISSUES', 'No Linear issues were imported. Nothing to spawn.');
+            }
+            if (!jsonMode) {
+                this.log('');
+                this.log(styles.header(`Spawning agents for ${pmoTicketIds.length} imported ticket(s)...`));
+                this.log('');
+            }
+            // Replace ticket args with the imported PMO ticket IDs
+            ticketIdArgs = pmoTicketIds;
+        }
         // Try to infer project from ticket IDs if provided
         let projectId;
         if (ticketIdArgs.length > 0) {
@@ -889,12 +1026,16 @@ export default class WorkSpawn extends PMOCommand {
                 return;
             }
             // Batch mode settings - prompt once for all tickets
+            const executionConfig = loadExecutionConfig(db);
+            const effectiveExecutor = flags.executor || executionConfig.defaultExecutor;
+            const executorName = getExecutorDisplayName(effectiveExecutor);
             let batchDisplay = flags.display;
             let batchOutput = flags.output;
             // Track permission mode - default to 'safe', check flag to determine if prompting needed
             let batchPermissionMode = flags['skip-permissions'] ? 'danger' : 'safe';
             let batchCreatePr = flags['create-pr'];
             let batchNoPr = flags['no-pr'];
+            let batchPrModeSource = flags['create-pr'] ? 'flag --create-pr' : flags['no-pr'] ? 'flag --no-pr' : 'default';
             let batchRunOnHost = flags['run-on-host'];
             let batchAction = flags.action;
             // Track custom message for custom action (needs to be outside the if block)
@@ -1045,10 +1186,12 @@ export default class WorkSpawn extends PMOCommand {
                         if (modifiesCode) {
                             batchCreatePr = true;
                             batchNoPr = false;
+                            batchPrModeSource = 'batch defaults';
                         }
                         else {
                             batchCreatePr = false;
                             batchNoPr = true;
+                            batchPrModeSource = 'action (non-code-modifying)';
                         }
                         this.log('');
                     }
@@ -1225,7 +1368,7 @@ export default class WorkSpawn extends PMOCommand {
                     permissionResolver.addPrompt({
                         flagName: 'permissionMode',
                         type: 'list',
-                        message: 'Permission mode for Claude Code:',
+                        message: `Permission mode for ${executorName}:`,
                         default: 'danger',
                         choices: () => [
                             { name: '⚠️  danger - Skip permission checks (faster, container provides isolation)', value: 'danger' },
@@ -1236,14 +1379,28 @@ export default class WorkSpawn extends PMOCommand {
                     batchPermissionMode = permissionResult.permissionMode;
                 }
                 // Prompt for PR creation if not provided AND action modifies code
-                // Skip this prompt entirely for non-code-modifying actions (like groom)
+                // Resolution order: explicit flags > workspace config default > interactive prompt
                 const actionModifiesCode = selectedActionDetails?.modifiesCode ?? true;
                 if (!batchCreatePr && !batchNoPr) {
-                    if (actionModifiesCode) {
-                        // In JSON mode with --yes, default to creating PRs for code-modifying actions
-                        if (jsonMode && flags.yes) {
+                    if (!actionModifiesCode) {
+                        // Non-code-modifying action - no PR needed
+                        batchCreatePr = false;
+                        batchNoPr = true;
+                        batchPrModeSource = 'action (non-code-modifying)';
+                    }
+                    else {
+                        // Check workspace config default
+                        const configPrDefault = getCreatePrDefault(db);
+                        if (configPrDefault !== null) {
+                            batchCreatePr = configPrDefault;
+                            batchNoPr = !configPrDefault;
+                            batchPrModeSource = 'workspace config (execution.create_pr_default)';
+                        }
+                        else if (jsonMode && flags.yes) {
+                            // In JSON mode with --yes, default to creating PRs for code-modifying actions
                             batchCreatePr = true;
                             batchNoPr = false;
+                            batchPrModeSource = 'default (--json --yes)';
                         }
                         else {
                             // Use FlagResolver for PR choice
@@ -1266,12 +1423,24 @@ export default class WorkSpawn extends PMOCommand {
                             const prResult = await prResolver.resolve();
                             batchCreatePr = prResult.prChoice === 'yes';
                             batchNoPr = prResult.prChoice === 'no';
+                            batchPrModeSource = 'interactive prompt';
                         }
                     }
+                }
+                // Show effective PR mode in batch summary
+                if (!jsonMode) {
+                    const prModeLabel = batchCreatePr ? 'create-pr' : 'no-pr';
+                    if (batchCreatePr) {
+                        this.log(styles.success(`   PR mode: ${prModeLabel} (${batchPrModeSource})`));
+                    }
                     else {
-                        // Non-code-modifying action - no PR needed
-                        batchCreatePr = false;
-                        batchNoPr = true;
+                        this.log(styles.warning(`   PR mode: ${prModeLabel} (${batchPrModeSource})`));
+                    }
+                    // Strong warning when no-pr is active for code-modifying actions
+                    if (!batchCreatePr && actionModifiesCode) {
+                        this.log('');
+                        this.log(styles.warning(`   ⚠️  WARNING: PR creation is DISABLED. Branches will be pushed but NO pull requests will be created.`));
+                        this.log(styles.warning(`   To create PRs later: prlt pr create <ticket-id>`));
                     }
                 }
                 this.log('');
@@ -1400,17 +1569,29 @@ export default class WorkSpawn extends PMOCommand {
             });
             db.close();
             // Output results
+            const resolvedPRMode = batchCreatePr ? 'create-pr' : 'no-pr';
             if (jsonMode) {
-                // Output JSON execution results with resolved PR mode
+                // Output JSON execution results with resolved PR mode and source
                 const spawnMetadata = createMetadata('work spawn', flags);
-                spawnMetadata.resolvedPRMode = flags['create-pr'] ? 'create-pr' : 'no-pr';
+                spawnMetadata.resolvedPRMode = resolvedPRMode;
+                spawnMetadata.prModeSource = batchPrModeSource;
+                if (!batchCreatePr && (selectedActionDetails?.modifiesCode ?? true)) {
+                    spawnMetadata.prWarning = `PR creation is DISABLED (${batchPrModeSource}). Branches will be pushed without PRs. To create later: prlt pr create <ticket-id>`;
+                }
                 outputExecutionResultAsJson(executionResults, successCount, failCount, spawnMetadata);
             }
             else {
-                const resolvedPRMode = flags['create-pr'] ? 'create-pr' : 'no-pr';
                 this.log('');
                 this.log(styles.success(`✓ Spawn results: ${successCount} started, ${failCount} failed`));
-                this.log(styles.muted(`   PR mode: ${resolvedPRMode}`));
+                this.log(styles.muted(`   PR mode: ${resolvedPRMode} (${batchPrModeSource})`));
+                // Post-run reminder when branches pushed without PRs
+                if (!batchCreatePr && (selectedActionDetails?.modifiesCode ?? true)) {
+                    this.log('');
+                    this.log(styles.warning(`Note: No PRs will be auto-created. To create PRs later:`));
+                    for (const result of executionResults.filter(r => r.status === 'running')) {
+                        this.log(styles.warning(`  prlt pr create ${result.ticketId}`));
+                    }
+                }
             }
         }
         catch (error) {