@proletariat/cli 0.3.44 → 0.3.46

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) {

package/dist/commands/work/start.js

@@ -9,11 +9,11 @@ import { shouldOutputJson, outputErrorAsJson, createMetadata, outputConfirmation
 import { FlagResolver } from '../../lib/flags/index.js';
 import { getWorkColumnSetting, findColumnByName } from '../../lib/pmo/utils.js';
 import { styles } from '../../lib/styles.js';
-import { getWorkspaceInfo, createEphemeralAgent, getTicketTmuxSession, killTmuxSession, findWorktreeForBranch, } from '../../lib/agents/commands.js';
+import { getWorkspaceInfo, createEphemeralAgent, getTicketTmuxSession, killTmuxSession, findWorktreeForBranch, resolveAgentDir, } from '../../lib/agents/commands.js';
 import { generateBranchName, DEFAULT_EXECUTION_CONFIG, } from '../../lib/execution/types.js';
-import { runExecution, isDockerRunning, isGitHubTokenAvailable, isDevcontainerCliInstalled, dockerCredentialsExist, getDockerCredentialInfo } from '../../lib/execution/runners.js';
+import { runExecution, isDockerRunning, isGitHubTokenAvailable, isDevcontainerCliInstalled, dockerCredentialsExist, getDockerCredentialInfo, isClaudeExecutor, getExecutorDisplayName } from '../../lib/execution/runners.js';
 import { ExecutionStorage, ContainerStorage } from '../../lib/execution/storage.js';
-import { loadExecutionConfig, getTerminalApp, promptTerminalPreference, getShell, promptShellPreference, hasTerminalPreference, hasShellPreference, getOrPromptCoderName, getAuthMethod, saveAuthMethod } from '../../lib/execution/config.js';
+import { loadExecutionConfig, getTerminalApp, promptTerminalPreference, getShell, promptShellPreference, hasTerminalPreference, hasShellPreference, getOrPromptCoderName, getAuthMethod, saveAuthMethod, getCreatePrDefault } from '../../lib/execution/config.js';
 import { hasDevcontainerConfig } from '../../lib/execution/devcontainer.js';
 import { detectRepoWorktrees, resolveWorktreePath } from '../../lib/execution/context.js';
 import { isGHInstalled, isGHAuthenticated } from '../../lib/pr/index.js';
@@ -130,7 +130,7 @@ export default class WorkStart extends PMOCommand {
             default: false,
         }),
         'permission-mode': Flags.string({
-            description: 'Permission mode for Claude Code (danger=skip checks, safe=require approval)',
+            description: 'Permission mode for selected executor (danger=skip checks, safe=require approval)',
             options: ['danger', 'safe'],
         }),
         'skip-permissions': Flags.boolean({
@@ -277,7 +277,14 @@ export default class WorkStart extends PMOCommand {
                 if (allFlagsProvided && !flags.yes) {
                     // All flags provided but no --yes: return confirmation_needed with plan
                     const metadata = createMetadata('work start', flags);
-                    metadata.resolvedPRMode = flags['create-pr'] ? 'create-pr' : 'no-pr';
+                    // Resolve PR mode using same priority as execution: flags > workspace config > default
+                    const earlyConfigPrDefault = getCreatePrDefault(db);
+                    const earlyResolvedPr = flags['create-pr'] ? 'create-pr'
+                        : flags['no-pr'] ? 'no-pr'
+                            : earlyConfigPrDefault === true ? 'create-pr'
+                                : earlyConfigPrDefault === false ? 'no-pr'
+                                    : 'no-pr';
+                    metadata.resolvedPRMode = earlyResolvedPr;
                     // Build the confirm command with --yes
                     let confirmCmd = `prlt work start ${ticketId}`;
                     if (flags.action)
@@ -1024,7 +1031,8 @@ export default class WorkStart extends PMOCommand {
             // Track whether user explicitly chose to use API key instead of OAuth
             let useApiKey = flags['use-api-key'] || false;
             // Auth method resolution for devcontainer environment
-            if (environment === 'devcontainer' && !useApiKey) {
+            // Only needed for Claude Code executor - other executors handle auth differently
+            if (environment === 'devcontainer' && !useApiKey && isClaudeExecutor(executor)) {
                 // Check for saved auth method preference
                 const savedAuthMethod = getAuthMethod(db);
                 const hasApiKey = !!process.env.ANTHROPIC_API_KEY;
@@ -1212,10 +1220,11 @@ export default class WorkStart extends PMOCommand {
                     jsonMode,
                     flags: { 'permission-mode': flags['permission-mode'] },
                 });
+                const executorName = getExecutorDisplayName(executor);
                 permissionResolver.addPrompt({
                     flagName: 'permission-mode',
                     type: 'list',
-                    message: `Permission mode for Claude Code${containerNote}:`,
+                    message: `Permission mode for ${executorName}${containerNote}:`,
                     default: 'danger',
                     choices: () => [
                         { name: '⚠️  danger - Skip permission checks (faster, container provides isolation)', value: 'danger' },
@@ -1227,24 +1236,34 @@ export default class WorkStart extends PMOCommand {
                 sandboxed = resolvedPermission['permission-mode'] === 'safe';
             }
             // Prompt for PR creation when work is complete
-            // Only show if gh CLI is available and authenticated
+            // Resolution order: explicit flags > workspace config default > interactive prompt
             let createPR = false;
+            let prModeSource = 'default'; // Track where PR mode was resolved from for display
             const ghAvailable = isGHInstalled() && isGHAuthenticated();
-            // Use flags if provided, otherwise prompt
+            const configPrDefault = getCreatePrDefault(db);
             if (flags['create-pr']) {
                 createPR = true;
+                prModeSource = 'flag --create-pr';
             }
             else if (flags['no-pr']) {
                 createPR = false;
+                prModeSource = 'flag --no-pr';
+            }
+            else if (context.modifiesCode === false) {
+                // Non-code-modifying actions (groom, review, resolve) default to no PR
+                createPR = false;
+                prModeSource = 'action (non-code-modifying)';
+            }
+            else if (configPrDefault !== null) {
+                // Workspace config default is set - use it deterministically
+                createPR = configPrDefault;
+                prModeSource = 'workspace config (execution.create_pr_default)';
             }
             else if (ghAvailable) {
-                if (context.modifiesCode === false) {
-                    // Non-code-modifying actions (groom, review, resolve) default to no PR
-                    createPR = false;
-                }
-                else if (jsonMode && flags.yes) {
+                if (jsonMode && flags.yes) {
                     // In JSON mode with --yes, default to creating PR for code-modifying actions
                     createPR = true;
+                    prModeSource = 'default (--json --yes)';
                 }
                 else {
                     // Use FlagResolver for PR choice
@@ -1266,9 +1285,14 @@ export default class WorkStart extends PMOCommand {
                     });
                     const prResult = await prResolver.resolve();
                     createPR = prResult.prChoice === 'yes';
+                    prModeSource = 'interactive prompt';
                 }
             }
-            // Show execution info (skip in JSON mode)
+            else {
+                prModeSource = 'default (gh CLI not available)';
+            }
+            // R1: Show clear PR mode in preflight summary
+            // R2: Show strong warning when --no-pr is active
             if (!jsonMode) {
                 this.log('');
                 this.log(styles.header(`🚀 Starting work: ${ticket.id}: ${ticket.title}`));
@@ -1286,12 +1310,30 @@ export default class WorkStart extends PMOCommand {
                 else {
                     this.log(styles.warning(`   Permissions: ⚠️  danger (--dangerously-skip-permissions)`));
                 }
-                this.log(styles.muted(`   Output: ${outputMode === 'interactive' ? 'streaming (watch Claude work)' : 'print (final result only)'}`));
-                this.log(styles.muted(`   PR mode: ${createPR ? 'create-pr' : 'no-pr'}${ghAvailable ? '' : ' (gh CLI not available)'}`));
+                this.log(styles.muted(`   Output: ${outputMode === 'interactive' ? `streaming (watch ${getExecutorDisplayName(executor)} work)` : 'print (final result only)'}`));
+                // PR mode with clear source indication
+                if (createPR) {
+                    this.log(styles.success(`   PR mode: create-pr (${prModeSource})`));
+                }
+                else {
+                    this.log(styles.warning(`   PR mode: no-pr (${prModeSource})`));
+                }
+                // Strong warning when no-pr is active
+                if (!createPR && context.modifiesCode !== false) {
+                    this.log('');
+                    this.log(styles.warning(`   ⚠️  WARNING: PR creation is DISABLED. Branch will be pushed but NO pull request will be created.`));
+                    this.log(styles.warning(`   To create a PR later: prlt pr create ${ticketId}`));
+                }
                 this.log(styles.muted(`   Worktree: ${worktreePath}`));
                 this.log(styles.muted(`   Branch: ${branch}`));
                 this.log('');
             }
+            // R2: Include PR mode warning in JSON metadata
+            if (jsonMode && !createPR && context.modifiesCode !== false) {
+                // This will be included in the metadata of the JSON output at the end
+                // We log a warning here for non-JSON consumers that may be watching stderr
+                this.warn(`PR creation is DISABLED (${prModeSource}). Branch will be pushed without a PR. To create later: prlt pr create ${ticketId}`);
+            }
             // Add createPR to context
             context.createPR = createPR;
             // Handle git operations
@@ -1589,9 +1631,13 @@ export default class WorkStart extends PMOCommand {
                 });
                 // Output results
                 if (jsonMode) {
-                    // Output JSON execution result with resolved PR mode
+                    // Output JSON execution result with resolved PR mode and source
                     const metadata = createMetadata('work start', flags);
                     metadata.resolvedPRMode = createPR ? 'create-pr' : 'no-pr';
+                    metadata.prModeSource = prModeSource;
+                    if (!createPR && context.modifiesCode !== false) {
+                        metadata.prWarning = `PR creation is DISABLED (${prModeSource}). Branch will be pushed without a PR. To create later: prlt pr create ${ticketId}`;
+                    }
                     outputExecutionResultAsJson([{
                             workId: execution.id,
                             ticketId: ticket.id,
@@ -1609,6 +1655,12 @@ export default class WorkStart extends PMOCommand {
                     this.log(styles.muted(`  prlt work status              View work status`));
                     this.log(styles.muted(`  prlt work ready ${ticketId}     Mark ready for review`));
                     this.log(styles.muted(`  prlt work stop ${execution.id}    Stop work`));
+                    // R5: Post-run reminder when branch is pushed without PR
+                    if (!createPR && context.modifiesCode !== false) {
+                        this.log('');
+                        this.log(styles.warning(`Note: No PR will be auto-created. To create one later:`));
+                        this.log(styles.warning(`  prlt pr create ${ticketId}`));
+                    }
                 }
             }
             else {
@@ -1617,6 +1669,7 @@ export default class WorkStart extends PMOCommand {
                     // Output JSON failure result with resolved PR mode
                     const failMetadata = createMetadata('work start', flags);
                     failMetadata.resolvedPRMode = createPR ? 'create-pr' : 'no-pr';
+                    failMetadata.prModeSource = prModeSource;
                     outputExecutionResultAsJson([{
                             workId: execution.id,
                             ticketId: ticket.id,
@@ -1694,13 +1747,15 @@ export default class WorkStart extends PMOCommand {
             return;
         }
         // Prompt for permissions mode once for all tickets (TKT-513)
+        const batchExecutor = flags.executor || DEFAULT_EXECUTION_CONFIG.defaultExecutor;
+        const batchExecutorName = getExecutorDisplayName(batchExecutor);
         let batchPermissionMode = flags['permission-mode'];
         if (!batchPermissionMode) {
             const { permissionMode } = await this.prompt([
                 {
                     type: 'list',
                     name: 'permissionMode',
-                    message: 'Permission mode for Claude Code:',
+                    message: `Permission mode for ${batchExecutorName}:`,
                     choices: [
                         { name: '⚠️  danger - Skip permission checks (faster, container provides isolation)', value: 'danger', command: 'prlt work start --all --permission-mode danger --json' },
                         { name: '🔒 safe   - Requires approval for dangerous operations', value: 'safe', command: 'prlt work start --all --permission-mode safe --json' },
@@ -1712,12 +1767,13 @@ export default class WorkStart extends PMOCommand {
         }
         // Check Docker credentials if any agents use devcontainers
         const anyUseDevcontainer = availableAgents.some(agent => {
-            const agentDir = path.join(workspaceInfo.agentsPath, agent.name);
+            const agentDir = resolveAgentDir(workspaceInfo, agent.name);
             return hasDevcontainerConfig(agentDir) && !flags['run-on-host'];
         });
         // Track whether user explicitly chose to use API key instead of OAuth
         let batchUseApiKey = false;
-        if (anyUseDevcontainer) {
+        // Credential check only applies to Claude Code executor
+        if (anyUseDevcontainer && isClaudeExecutor(batchExecutor)) {
             const hasCredentials = dockerCredentialsExist();
             if (!hasCredentials) {
                 const hasApiKey = !!process.env.ANTHROPIC_API_KEY;
@@ -1858,8 +1914,8 @@ export default class WorkStart extends PMOCommand {
     async spawnSingleTicket(ticket, agent, workspaceInfo, executionStorage, db, flags) {
         const agentName = agent.name;
         // Note: Ticket assignee update moved to after successful spawn
-        // Find agent directory and worktree
-        const agentDir = path.join(workspaceInfo.agentsPath, agentName);
+        // Find agent directory and worktree (handles staff and temp agents)
+        const agentDir = resolveAgentDir(workspaceInfo, agentName);
         if (!fs.existsSync(agentDir)) {
             throw new Error(`Agent directory not found: ${agentDir}`);
         }

package/dist/commands/work/watch.js

@@ -3,7 +3,7 @@ import * as path from 'node:path';
 import Database from 'better-sqlite3';
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
 import { styles } from '../../lib/styles.js';
-import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { getWorkspaceInfo, resolveAgentDir } from '../../lib/agents/commands.js';
 import { ExecutionStorage } from '../../lib/execution/storage.js';
 import { hasDevcontainerConfig } from '../../lib/execution/devcontainer.js';
 import { spawnForColumn, getAvailableAgents, isDockerRunning, isDevcontainerCliInstalled, } from '../../lib/execution/spawner.js';
@@ -152,7 +152,7 @@ export default class WorkWatch extends PMOCommand {
             }
             // Check if any agent has devcontainer
             const hasDevcontainer = workspaceInfo.agents.some(agent => {
-                const agentDir = path.join(workspaceInfo.agentsPath, agent.name);
+                const agentDir = resolveAgentDir(workspaceInfo, agent.name);
                 return hasDevcontainerConfig(agentDir);
             });
             // Prompt for environment and display mode if not provided

package/dist/lib/agents/commands.d.ts

@@ -1,4 +1,15 @@
 import { Agent, Repository, MountMode as DBMountMode } from '../database/index.js';
+/**
+ * Resolve the directory for an agent, cascading through resolution strategies.
+ * Handles both staff (persistent) and temp (ephemeral) agents.
+ *
+ * Resolution order:
+ * 1. Check agent's worktree_path from DB (most reliable)
+ * 2. Check ephemeral directory if agent type is ephemeral
+ * 3. Check both directories on disk as fallback
+ * 4. Fall back to staff path (caller handles missing dir error)
+ */
+export declare function resolveAgentDir(workspaceInfo: WorkspaceInfo, agentName: string): string;
 /**
  * Format a list of agents for display in error messages.
  * Truncates long lists to avoid overwhelming output.

package/dist/lib/agents/commands.js

@@ -10,6 +10,43 @@ import { isValidAgentName, getSuggestedAgentNames, generateEphemeralAgentName, g
 import { createDevcontainerConfig } from '../execution/devcontainer.js';
 import { getGitIdentity } from '../pr/index.js';
 import { getPMOContext } from '../pmo/index.js';
+/**
+ * Resolve the directory for an agent, cascading through resolution strategies.
+ * Handles both staff (persistent) and temp (ephemeral) agents.
+ *
+ * Resolution order:
+ * 1. Check agent's worktree_path from DB (most reliable)
+ * 2. Check ephemeral directory if agent type is ephemeral
+ * 3. Check both directories on disk as fallback
+ * 4. Fall back to staff path (caller handles missing dir error)
+ */
+export function resolveAgentDir(workspaceInfo, agentName) {
+    const agent = workspaceInfo.agents.find(a => a.name === agentName);
+    // 1. Check DB worktree_path (most reliable - set during agent creation)
+    if (agent?.worktree_path) {
+        const fullWorktreePath = path.join(workspaceInfo.path, agent.worktree_path);
+        // worktree_path may point to repo subdir (e.g. agents/staff/altman/proletariat)
+        // Go up to the agent dir level
+        const agentDir = path.dirname(fullWorktreePath);
+        if (fs.existsSync(agentDir))
+            return agentDir;
+    }
+    // 2. Check ephemeral directory if agent type is ephemeral
+    if (agent?.type === 'ephemeral') {
+        const ephemeralDir = path.join(workspaceInfo.path, 'agents', workspaceInfo.ephemeralAgentsDir, agentName);
+        if (fs.existsSync(ephemeralDir))
+            return ephemeralDir;
+    }
+    // 3. Check both directories on disk (handles DB inconsistencies)
+    const tempDir = path.join(workspaceInfo.path, 'agents', workspaceInfo.ephemeralAgentsDir, agentName);
+    if (fs.existsSync(tempDir))
+        return tempDir;
+    const staffDir = path.join(workspaceInfo.agentsPath, agentName);
+    if (fs.existsSync(staffDir))
+        return staffDir;
+    // 4. Fall back to staff path - caller will handle the missing dir error
+    return staffDir;
+}
 /**
  * Format a list of agents for display in error messages.
  * Truncates long lists to avoid overwhelming output.
@@ -169,15 +206,8 @@ export function getAgentStatus(workspaceInfo, agentName) {
     const exists = !!agentRecord;
     // Get worktrees from database to find actual agent location
     const worktrees = getAgentWorktrees(workspaceInfo.path, agentName);
-    // Derive agent directory from worktree path, or fall back to default
-    let agentDir = path.join(workspaceInfo.agentsPath, agentName);
-    if (worktrees.length > 0) {
-        // worktree_path is like "agents/staff/altman/proletariat-altman"
-        // Agent dir is the parent: "agents/staff/altman"
-        const worktreePath = worktrees[0].worktree_path;
-        const agentDirRelative = path.dirname(worktreePath);
-        agentDir = path.join(workspaceInfo.path, agentDirRelative);
-    }
+    // Resolve agent directory (handles both staff and temp agents)
+    const agentDir = resolveAgentDir(workspaceInfo, agentName);
     const dirExists = fs.existsSync(agentDir);
     const status = {
         name: agentName,
@@ -314,7 +344,7 @@ export async function removeAgentsFromWorkspace(workspaceInfo, agentNames) {
     const failed = [];
     for (const agentName of agentNames) {
         try {
-            const agentDir = path.join(workspaceInfo.agentsPath, agentName);
+            const agentDir = resolveAgentDir(workspaceInfo, agentName);
             // Stop and remove Docker container if it exists
             try {
                 const containerId = execSync(`docker ps -aq --filter "label=devcontainer.local_folder=${agentDir}"`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();