@proletariat/cli 0.3.34 → 0.3.36

package/dist/commands/ticket/template/save.js

@@ -0,0 +1,97 @@
+import { Flags, Args } from '@oclif/core';
+import { 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 TicketTemplateSave extends PMOCommand {
+    static description = 'Create a ticket template from an existing ticket';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> TKT-001 "Bug Report Template"',
+        '<%= config.bin %> <%= command.id %> TKT-042 "Feature Request" -d "Standard feature request"',
+    ];
+    static args = {
+        ticket: Args.string({
+            description: 'Ticket ID to create template from',
+            required: false,
+        }),
+        name: Args.string({
+            description: 'Template name',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        'template-name': Flags.string({
+            char: 'n',
+            description: 'Template name (alternative to positional arg)',
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Template description',
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(TicketTemplateSave);
+        const jsonMode = shouldOutputJson(flags);
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('ticket template save', flags));
+            }
+            this.error(message);
+        };
+        // Get ticket ID
+        let ticketId = args.ticket;
+        if (!ticketId) {
+            const projectId = await this.requireProject();
+            const tickets = await this.storage.listTickets(projectId);
+            if (tickets.length === 0) {
+                return handleError('NO_TICKETS', 'No tickets found. Create a ticket first.');
+            }
+            if (jsonMode) {
+                const choices = tickets.slice(0, 20).map(t => ({ name: `${t.id} - ${t.title}`, value: t.id }));
+                outputPromptAsJson(buildPromptConfig('list', 'ticket', 'Select ticket:', choices), createMetadata('ticket template save', flags));
+                return;
+            }
+            const { selected } = await this.prompt([{
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select ticket:',
+                    choices: tickets.slice(0, 20).map(t => ({ name: `${t.id} - ${t.title}`, value: t.id })),
+                }], null);
+            ticketId = selected;
+        }
+        const ticket = await this.storage.getTicket(ticketId);
+        if (!ticket) {
+            return handleError('TICKET_NOT_FOUND', `Ticket not found: ${ticketId}`);
+        }
+        // Get template name
+        let templateName = flags['template-name'] || args.name;
+        if (!templateName) {
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('input', 'name', 'Template name:', undefined, ticket.category || ticket.title.split(' ')[0]), createMetadata('ticket template save', flags));
+                return;
+            }
+            const { name } = await this.prompt([{
+                    type: 'input',
+                    name: 'name',
+                    message: 'Template name:',
+                    default: ticket.category || ticket.title.split(' ')[0],
+                    validate: (i) => i.length > 0 || 'Required',
+                }], null);
+            templateName = name;
+        }
+        // Get description
+        let description = flags.description;
+        if (description === undefined && !jsonMode) {
+            const { desc } = await this.prompt([{ type: 'input', name: 'desc', message: 'Description (optional):' }], null);
+            description = desc || undefined;
+        }
+        const template = await this.storage.createTicketTemplateFromTicket(ticketId, templateName, description);
+        if (flags.json === true) {
+            outputSuccessAsJson({ template, sourceTicketId: ticketId }, createMetadata('ticket template save', flags));
+            return;
+        }
+        this.log(styles.success(`\nCreated template "${styles.emphasis(template.name)}" from ${ticketId}`));
+        this.log(styles.muted(`  ID: ${template.id}`));
+        this.log(styles.muted(`\nApply with: prlt ticket template apply ${template.id}`));
+    }
+}

package/dist/commands/ticket/view.js

@@ -57,6 +57,36 @@ export default class TicketView extends PMOCommand {
         if (!ticket) {
             this.error(`Ticket "${ticketId}" not found.`);
         }
+        // JSON output mode
+        if (jsonMode) {
+            this.log(JSON.stringify({
+                success: true,
+                ticket: {
+                    id: ticket.id,
+                    title: ticket.title,
+                    description: ticket.description,
+                    priority: ticket.priority,
+                    category: ticket.category,
+                    statusName: ticket.statusName,
+                    statusCategory: ticket.statusCategory,
+                    projectId: ticket.projectId,
+                    assignee: ticket.assignee,
+                    owner: ticket.owner,
+                    branch: ticket.branch,
+                    epicId: ticket.epicId,
+                    position: ticket.position,
+                    subtasks: ticket.subtasks,
+                    labels: ticket.labels,
+                    metadata: ticket.metadata,
+                    blockedBy: ticket.blockedBy,
+                    acceptanceCriteria: ticket.acceptanceCriteria,
+                    specId: ticket.specId,
+                    createdAt: ticket.createdAt?.toISOString(),
+                    updatedAt: ticket.updatedAt?.toISOString(),
+                },
+            }, null, 2));
+            return;
+        }
         // Get project board (may be null if project was deleted/orphaned)
         const board = ticket.projectId ? await this.storage.getProjectBoard(ticket.projectId) : null;
         const projectName = board?.name || ticket.projectId || 'Unknown';

package/dist/commands/work/index.js

@@ -22,6 +22,7 @@ export default class Work extends PMOCommand {
         // Execution actions first (most common), then ownership
         // Each choice includes the full command for AI agents to execute
         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: '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` },
@@ -46,6 +47,9 @@ export default class Work extends PMOCommand {
         // Pass --project to avoid re-prompting for project selection
         const projectArgs = ['--project', projectId];
         switch (action) {
+            case 'status':
+                await this.config.runCommand('work:status', projectArgs);
+                break;
             case 'start':
                 await this.config.runCommand('work:start', projectArgs);
                 break;

package/dist/commands/work/ready.js

@@ -254,6 +254,23 @@ export default class WorkReady extends PMOCommand {
         }
         try {
             const baseBranch = getDefaultBaseBranch();
+            // Check if PR already exists for this branch
+            const existingPR = getPRForBranch(currentBranch);
+            if (existingPR) {
+                if (existingPR.state === 'MERGED') {
+                    this.log(styles.muted(`   PR #${existingPR.number} already merged: ${existingPR.url}`));
+                    return existingPR.url;
+                }
+                if (existingPR.state === 'OPEN') {
+                    // Push any unpushed commits so the existing PR is up to date
+                    if (hasUnpushedCommits(currentBranch)) {
+                        this.log(styles.muted(`   Pushing unpushed commits to existing PR...`));
+                        pushBranch(currentBranch);
+                    }
+                    this.log(styles.muted(`   PR #${existingPR.number} already exists: ${existingPR.url}`));
+                    return existingPR.url;
+                }
+            }
             // Push branch if needed
             if (!hasBranchBeenPushed(currentBranch)) {
                 this.log(styles.muted(`   Pushing branch to origin...`));

package/dist/commands/work/resolve.js

@@ -26,7 +26,7 @@ export default class WorkResolve extends PMOCommand {
         }),
     };
     async execute() {
-        const { args, flags, argv } = await this.parse(WorkResolve);
+        const { flags, argv } = await this.parse(WorkResolve);
         const projectId = flags.project;
         const jsonMode = shouldOutputJson(flags);
         const handleError = (code, message) => {

package/dist/commands/work/spawn.js

@@ -491,18 +491,18 @@ export default class WorkSpawn extends PMOCommand {
                 let candidates = [...allTickets];
                 // Apply category filter
                 if (flags.category) {
-                    const categoryList = flags.category.split(',').map(c => c.trim().toLowerCase());
+                    const categoryList = new Set(flags.category.split(',').map(c => c.trim().toLowerCase()));
                     candidates = candidates.filter(t => {
                         const ticketCat = (t.category || '').toLowerCase();
-                        return categoryList.includes(ticketCat);
+                        return categoryList.has(ticketCat);
                     });
                 }
                 // Apply priority filter
                 if (flags.priority) {
-                    const priorityList = flags.priority.split(',').map(p => p.trim().toUpperCase());
+                    const priorityList = new Set(flags.priority.split(',').map(p => p.trim().toUpperCase()));
                     candidates = candidates.filter(t => {
                         const ticketPriority = (t.priority || '').toUpperCase();
-                        return priorityList.includes(ticketPriority);
+                        return priorityList.has(ticketPriority);
                     });
                 }
                 // Apply epic filter

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

@@ -28,6 +28,7 @@ export default class WorkStart extends PMOCommand {
         focus: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         clone: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'use-api-key': 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>;

package/dist/commands/work/start.js

@@ -1,3 +1,4 @@
+/* eslint-disable max-lines -- large command with many execution paths */
 import { Args, Flags } from '@oclif/core';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
@@ -12,7 +13,7 @@ import { getWorkspaceInfo, createEphemeralAgent, getTicketTmuxSession, killTmuxS
 import { generateBranchName, DEFAULT_EXECUTION_CONFIG, } from '../../lib/execution/types.js';
 import { runExecution, isDockerRunning, isGitHubTokenAvailable, isDevcontainerCliInstalled, dockerCredentialsExist, getDockerCredentialInfo } from '../../lib/execution/runners.js';
 import { ExecutionStorage, ContainerStorage } from '../../lib/execution/storage.js';
-import { loadExecutionConfig, getTerminalApp, promptTerminalPreference, getShell, promptShellPreference, hasTerminalPreference, hasShellPreference, getOrPromptCoderName } from '../../lib/execution/config.js';
+import { loadExecutionConfig, getTerminalApp, promptTerminalPreference, getShell, promptShellPreference, hasTerminalPreference, hasShellPreference, getOrPromptCoderName, getAuthMethod, saveAuthMethod } 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';
@@ -179,6 +180,11 @@ export default class WorkStart extends PMOCommand {
             description: 'Skip confirmation prompt (for non-TTY/scripted execution)',
             default: false,
         }),
+        'use-api-key': Flags.boolean({
+            description: 'Use ANTHROPIC_API_KEY for Docker containers instead of OAuth credentials',
+            default: false,
+            hidden: true,
+        }),
     };
     async execute() {
         const { args, flags } = await this.parse(WorkStart);
@@ -804,11 +810,20 @@ export default class WorkStart extends PMOCommand {
                         flags: {},
                     });
                     envResolver.addPrompt({
-                        flagName: 'selectedEnvironment',
+                        flagName: 'environment',
                         type: 'list',
                         message: 'Where should the agent run?',
                         default: 'devcontainer',
                         choices: () => envChoices,
+                        getCommand: (value) => {
+                            const base = `prlt work start ${ticketId}`;
+                            if (value === 'host')
+                                return `${base} --run-on-host --json`;
+                            if (value === 'cancel')
+                                return '';
+                            // devcontainer is the default when available
+                            return `${base} --json`;
+                        },
                     });
                     await envResolver.resolve();
                     // FlagResolver exits in JSON mode, so we never reach here
@@ -1000,104 +1015,181 @@ export default class WorkStart extends PMOCommand {
             // Default to interactive output mode (streaming UI)
             // Can be overridden via --output flag if needed
             const outputMode = flags.output || DEFAULT_EXECUTION_CONFIG.outputMode;
-            // Check Docker credentials for devcontainer environment
-            if (environment === 'devcontainer') {
-                const hasCredentials = dockerCredentialsExist();
-                if (!hasCredentials) {
-                    // In JSON mode with --yes, continue anyway (agent can run /login)
-                    if (jsonMode && flags.yes) {
-                        // Continue without prompting - agent will need to handle auth
-                    }
-                    else {
+            // 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) {
+                // Check for saved auth method preference
+                const savedAuthMethod = getAuthMethod(db);
+                const hasApiKey = !!process.env.ANTHROPIC_API_KEY;
+                if (savedAuthMethod === 'apikey') {
+                    // Saved preference: API key — validate it's still set
+                    if (!hasApiKey) {
                         this.log('');
-                        this.log(styles.warning('⚠️  No Claude Code credentials found for Docker containers'));
-                        this.log(styles.muted('   Agents will fail with 401 authentication errors without credentials.'));
+                        this.log(styles.warning('⚠️  Saved auth method is "apikey" but ANTHROPIC_API_KEY is not set in your environment.'));
+                        this.log(styles.muted('   Set the env var or run "' + this.config.bin + ' agent auth" to switch to OAuth.'));
+                        db.close();
+                        return;
+                    }
+                    useApiKey = true;
+                }
+                else if (savedAuthMethod === 'oauth') {
+                    // Saved preference: OAuth — validate credentials exist
+                    const hasCredentials = dockerCredentialsExist();
+                    if (!hasCredentials) {
                         this.log('');
-                        // Use FlagResolver for auth action
-                        const authResolver = new FlagResolver({
-                            commandName: 'work start',
-                            baseCommand: `prlt work start ${ticketId}`,
-                            jsonMode,
-                            flags: {},
-                        });
-                        authResolver.addPrompt({
-                            flagName: 'authAction',
-                            type: 'list',
-                            message: 'What would you like to do?',
-                            choices: () => [
-                                { name: `🔐 Run ${this.config.bin} agent auth now (one-time setup)`, value: 'auth' },
-                                { name: '💻 Switch to host environment instead', value: 'host' },
-                                { name: '⏩ Continue anyway (must run /login in first agent)', value: 'continue' },
-                                { name: '✗  Cancel', value: 'cancel' },
-                            ],
-                        });
-                        const authResult = await authResolver.resolve();
-                        const authAction = authResult.authAction;
-                        if (authAction === 'cancel') {
-                            db.close();
-                            this.log(styles.muted('Cancelled.'));
-                            return;
-                        }
-                        if (authAction === 'host') {
-                            environment = 'host';
-                            this.log(styles.muted('Switched to host environment.'));
+                        this.log(styles.warning('⚠️  Saved auth method is "oauth" but no OAuth credentials found.'));
+                        this.log(styles.muted('   Run "' + this.config.bin + ' agent auth" to authenticate.'));
+                        db.close();
+                        return;
+                    }
+                    // OAuth credentials valid — continue (useApiKey stays false)
+                }
+                else {
+                    // No saved preference — show auth method menu
+                    const hasCredentials = dockerCredentialsExist();
+                    if (hasCredentials) {
+                        // OAuth credentials exist, use them silently (no menu needed)
+                        // useApiKey stays false
+                    }
+                    else {
+                        // No saved preference and no OAuth credentials — prompt user
+                        // In JSON mode with --yes, continue anyway (agent can run /login)
+                        if (jsonMode && flags.yes) {
+                            // Continue without prompting - agent will need to handle auth
                         }
-                        else if (authAction === 'auth') {
+                        else {
                             this.log('');
-                            this.log(styles.primary(`Opening ${this.config.bin} agent auth in new tab...`));
+                            this.log(styles.warning('⚠️  No Claude Code OAuth credentials found for Docker containers'));
+                            this.log(styles.muted('   Agents need credentials to authenticate with Claude.'));
                             this.log('');
-                            // Open auth in a new terminal tab
-                            const authCmd = `${process.argv[1]} agent auth`;
-                            try {
-                                execSync(`osascript -e '
-                  tell application "iTerm"
-                    tell current window
-                      create tab with default profile
-                      tell current session
-                        write text "${authCmd}"
-                      end tell
-                    end tell
-                  end tell
-                '`);
+                            // Build auth method choices
+                            const authChoices = [
+                                { name: `🔐 OAuth (recommended — uses Max subscription)`, value: 'oauth' },
+                            ];
+                            if (hasApiKey) {
+                                authChoices.push({ name: '🔑 API key (uses API credits, not Max subscription)', value: 'apikey' });
                             }
-                            catch {
-                                // Fallback: try Terminal.app
+                            authChoices.push({ name: '💻 Switch to host environment instead', value: 'host' }, { name: '✗  Cancel', value: 'cancel' });
+                            // Use FlagResolver for auth method selection
+                            const authResolver = new FlagResolver({
+                                commandName: 'work start',
+                                baseCommand: `prlt work start ${ticketId}`,
+                                jsonMode,
+                                flags: {},
+                            });
+                            authResolver.addPrompt({
+                                flagName: 'authAction',
+                                type: 'list',
+                                message: 'How should the agent authenticate with Claude?',
+                                choices: () => authChoices,
+                            });
+                            const authResult = await authResolver.resolve();
+                            const authAction = authResult.authAction;
+                            if (authAction === 'cancel') {
+                                db.close();
+                                this.log(styles.muted('Cancelled.'));
+                                return;
+                            }
+                            if (authAction === 'host') {
+                                environment = 'host';
+                                this.log(styles.muted('Switched to host environment.'));
+                            }
+                            else if (authAction === 'apikey') {
+                                useApiKey = true;
+                                this.log(styles.warning('Using ANTHROPIC_API_KEY — this will consume API credits.'));
+                                this.log(styles.muted(`Run "${this.config.bin} agent auth" to set up OAuth and use your Max subscription instead.`));
+                                this.log('');
+                            }
+                            else if (authAction === 'oauth') {
+                                this.log('');
+                                this.log(styles.primary(`Opening ${this.config.bin} agent auth in new tab...`));
+                                this.log('');
+                                // Open auth in a new terminal tab
+                                const authCmd = `${process.argv[1]} agent auth`;
                                 try {
-                                    execSync(`osascript -e 'tell application "Terminal" to do script "${authCmd}"'`);
+                                    execSync(`osascript -e '
+                    tell application "iTerm"
+                      tell current window
+                        create tab with default profile
+                        tell current session
+                          write text "${authCmd}"
+                        end tell
+                      end tell
+                    end tell
+                  '`);
                                 }
                                 catch {
-                                    this.log(styles.warning('Could not open new terminal tab.'));
-                                    this.log(styles.muted(`Please run manually: ${authCmd}`));
+                                    // Fallback: try Terminal.app
+                                    try {
+                                        execSync(`osascript -e 'tell application "Terminal" to do script "${authCmd}"'`);
+                                    }
+                                    catch {
+                                        this.log(styles.warning('Could not open new terminal tab.'));
+                                        this.log(styles.muted(`Please run manually: ${authCmd}`));
+                                    }
+                                }
+                                this.log(styles.muted('Complete the /login flow in the new tab, then press Enter here...'));
+                                this.log('');
+                                // Wait for user to complete auth
+                                await this.prompt([{
+                                        type: 'input',
+                                        name: 'done',
+                                        message: 'Press Enter when authentication is complete:',
+                                    }]);
+                                // Check if credentials now exist
+                                if (!dockerCredentialsExist()) {
+                                    this.log('');
+                                    this.log(styles.warning('Authentication did not complete. No credentials found.'));
+                                    db.close();
+                                    return;
+                                }
+                                const info = getDockerCredentialInfo();
+                                this.log('');
+                                this.log(styles.success('✓ Credentials configured'));
+                                if (info) {
+                                    this.log(styles.muted(`   Subscription: ${info.subscriptionType || 'unknown'}`));
+                                    this.log(styles.muted(`   Expires: ${info.expiresAt.toLocaleDateString()}`));
                                 }
-                            }
-                            this.log(styles.muted('Complete the /login flow in the new tab, then press Enter here...'));
-                            this.log('');
-                            // Wait for user to complete auth
-                            await this.prompt([{
-                                    type: 'input',
-                                    name: 'done',
-                                    message: 'Press Enter when authentication is complete:',
-                                }]);
-                            // Check if credentials now exist
-                            if (!dockerCredentialsExist()) {
                                 this.log('');
-                                this.log(styles.warning('Authentication did not complete. No credentials found.'));
-                                db.close();
-                                return;
                             }
-                            const info = getDockerCredentialInfo();
-                            this.log('');
-                            this.log(styles.success('✓ Credentials configured'));
-                            if (info) {
-                                this.log(styles.muted(`   Subscription: ${info.subscriptionType || 'unknown'}`));
-                                this.log(styles.muted(`   Expires: ${info.expiresAt.toLocaleDateString()}`));
+                            // Prompt "Save as default?" after a successful auth method choice
+                            // (only if they chose oauth or apikey, not host/cancel)
+                            if (authAction === 'oauth' || authAction === 'apikey') {
+                                const saveChoices = [
+                                    { name: 'Yes — skip this menu next time', value: true },
+                                    { name: 'No — ask me each time', value: false },
+                                ];
+                                const saveMessage = 'Save as default auth method?';
+                                const saveResolver = new FlagResolver({
+                                    commandName: 'work start',
+                                    baseCommand: `prlt work start ${ticketId}`,
+                                    jsonMode,
+                                    flags: {},
+                                });
+                                saveResolver.addPrompt({
+                                    flagName: 'saveDefault',
+                                    type: 'list',
+                                    message: saveMessage,
+                                    default: true,
+                                    choices: () => saveChoices,
+                                });
+                                const saveResult = await saveResolver.resolve();
+                                if (saveResult.saveDefault) {
+                                    const methodToSave = authAction === 'apikey' ? 'apikey' : 'oauth';
+                                    saveAuthMethod(db, methodToSave);
+                                    this.log(styles.muted(`Auth method saved: ${methodToSave}. Will skip this menu next time.`));
+                                    this.log('');
+                                }
                             }
-                            this.log('');
                         }
-                        // authAction === 'continue' falls through
                     }
                 }
             }
+            // Pass API key preference to execution context
+            if (useApiKey) {
+                context.useApiKey = true;
+            }
             // Prompt for permissions mode (all environments)
             // Use FlagResolver to handle both JSON mode and interactive prompts consistently
             if (flags['permission-mode']) {
@@ -1140,9 +1232,13 @@ export default class WorkStart extends PMOCommand {
                 createPR = false;
             }
             else if (ghAvailable) {
-                // In JSON mode with --yes, default to creating PR for code-modifying actions
-                if (jsonMode && flags.yes) {
-                    createPR = context.modifiesCode !== false;
+                if (context.modifiesCode === false) {
+                    // Non-code-modifying actions (groom, review, resolve) default to no PR
+                    createPR = false;
+                }
+                else if (jsonMode && flags.yes) {
+                    // In JSON mode with --yes, default to creating PR for code-modifying actions
+                    createPR = true;
                 }
                 else {
                     // Use FlagResolver for PR choice
@@ -1611,23 +1707,30 @@ export default class WorkStart extends PMOCommand {
             const agentDir = path.join(workspaceInfo.agentsPath, 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) {
             const hasCredentials = dockerCredentialsExist();
             if (!hasCredentials) {
+                const hasApiKey = !!process.env.ANTHROPIC_API_KEY;
                 this.log('');
-                this.log(styles.warning('⚠️  No Claude Code credentials found for Docker containers'));
-                this.log(styles.muted('   Agents will fail with 401 authentication errors without credentials.'));
+                this.log(styles.warning('⚠️  No Claude Code OAuth credentials found for Docker containers'));
+                this.log(styles.muted('   Agents need credentials to authenticate with Claude.'));
                 this.log('');
+                // Build choices based on available options
+                const batchAuthChoices = [
+                    { name: `🔐 Run ${this.config.bin} agent auth now (recommended — uses Max subscription)`, value: 'auth', command: `${this.config.bin} agent auth` },
+                ];
+                if (hasApiKey) {
+                    batchAuthChoices.push({ name: '🔑 Use ANTHROPIC_API_KEY (⚠️  uses API credits, not Max subscription)', value: 'apikey', command: '' });
+                }
+                batchAuthChoices.push({ name: '💻 Run all agents on host instead (--run-on-host)', value: 'host', command: 'prlt work start --all --run-on-host --json' }, { name: '✗  Cancel', value: 'cancel', command: '' });
                 const { authAction } = await this.prompt([
                     {
                         type: 'list',
                         name: 'authAction',
                         message: 'What would you like to do?',
-                        choices: [
-                            { name: `🔐 Run ${this.config.bin} agent auth now (one-time setup)`, value: 'auth', command: `${this.config.bin} agent auth` },
-                            { name: '💻 Run all agents on host instead (--run-on-host)', value: 'host', command: 'prlt work start --all --run-on-host --json' },
-                            { name: '✗  Cancel', value: 'cancel', command: '' },
-                        ],
+                        choices: batchAuthChoices,
                     },
                 ], batchJsonModeConfig);
                 if (authAction === 'cancel') {
@@ -1639,6 +1742,12 @@ export default class WorkStart extends PMOCommand {
                     flags['run-on-host'] = true;
                     this.log(styles.muted('All agents will run on host.'));
                 }
+                else if (authAction === 'apikey') {
+                    batchUseApiKey = true;
+                    this.log(styles.warning('Using ANTHROPIC_API_KEY — this will consume API credits.'));
+                    this.log(styles.muted(`Run "${this.config.bin} agent auth" to set up OAuth and use your Max subscription instead.`));
+                    this.log('');
+                }
                 else if (authAction === 'auth') {
                     this.log('');
                     this.log(styles.primary(`Opening ${this.config.bin} agent auth in new tab...`));
@@ -1715,6 +1824,7 @@ export default class WorkStart extends PMOCommand {
                     '--display', flags.display || 'background',
                     ...(flags.executor ? ['--executor', flags.executor] : []),
                     ...(flags['run-on-host'] ? ['--run-on-host'] : []),
+                    ...(batchUseApiKey ? ['--use-api-key'] : []),
                     ...(flags.force ? ['--force'] : []),
                     '--permission-mode', batchPermissionMode,
                     ...(flags.clone ? ['--clone'] : []),

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

@@ -0,0 +1,14 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class WorkStatus extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    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>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+}