@proletariat/cli 0.3.16 → 0.3.18

package/dist/commands/work/start.js

@@ -5,7 +5,8 @@ import { execSync } from 'node:child_process';
 import inquirer from 'inquirer';
 import Database from 'better-sqlite3';
 import { PMOCommand, pmoBaseFlags, autoExportToBoard } from '../../lib/pmo/index.js';
-import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+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, } from '../../lib/agents/commands.js';
@@ -256,19 +257,25 @@ export default class WorkStart extends PMOCommand {
                     this.log(styles.muted(`   - ${blocker.id}: ${blocker.title} (${blocker.status})`));
                 }
                 this.log('');
-                const { startAnyway } = await inquirer.prompt([
-                    {
-                        type: 'list',
-                        name: 'startAnyway',
-                        message: 'Start anyway?',
-                        choices: [
-                            { name: 'No, cancel', value: false },
-                            { name: 'Yes, start despite blockers', value: true },
-                        ],
-                        default: false,
-                    },
-                ]);
-                if (!startAnyway) {
+                // Use FlagResolver for blocked ticket confirmation
+                const blockedResolver = new FlagResolver({
+                    commandName: 'work start',
+                    baseCommand: `prlt work start ${ticketId}`,
+                    jsonMode,
+                    flags: {},
+                });
+                blockedResolver.addPrompt({
+                    flagName: 'startAnyway',
+                    type: 'list',
+                    message: 'Start anyway?',
+                    default: 'no',
+                    choices: () => [
+                        { name: 'No, cancel', value: 'no' },
+                        { name: 'Yes, start despite blockers', value: 'yes' },
+                    ],
+                });
+                const blockedResult = await blockedResolver.resolve();
+                if (blockedResult.startAnyway !== 'yes') {
                     db.close();
                     this.log(styles.muted('Cancelled.'));
                     return;
@@ -279,19 +286,26 @@ export default class WorkStart extends PMOCommand {
             if (existingSession && !flags.force) {
                 this.log('');
                 this.log(styles.warning(`Ticket ${ticketId} has an active tmux session (${existingSession.agent})`));
-                const { sessionAction } = await inquirer.prompt([
-                    {
-                        type: 'list',
-                        name: 'sessionAction',
-                        message: 'What would you like to do?',
-                        choices: [
-                            { name: 'Attach to existing session', value: 'attach' },
-                            { name: 'Spawn new agent (keeps existing session)', value: 'spawn' },
-                            { name: 'Kill session and respawn', value: 'kill' },
-                            { name: 'Cancel', value: 'cancel' },
-                        ],
-                    },
-                ]);
+                // Use FlagResolver for session action
+                const sessionResolver = new FlagResolver({
+                    commandName: 'work start',
+                    baseCommand: `prlt work start ${ticketId}`,
+                    jsonMode,
+                    flags: {},
+                });
+                sessionResolver.addPrompt({
+                    flagName: 'sessionAction',
+                    type: 'list',
+                    message: 'What would you like to do?',
+                    choices: () => [
+                        { name: 'Attach to existing session', value: 'attach' },
+                        { name: 'Spawn new agent (keeps existing session)', value: 'spawn' },
+                        { name: 'Kill session and respawn', value: 'kill' },
+                        { name: 'Cancel', value: 'cancel' },
+                    ],
+                });
+                const sessionResult = await sessionResolver.resolve();
+                const sessionAction = sessionResult.sessionAction;
                 if (sessionAction === 'cancel') {
                     db.close();
                     this.log(styles.muted('Cancelled.'));
@@ -351,36 +365,36 @@ export default class WorkStart extends PMOCommand {
                             busyAgentNames.add(agent.name);
                         }
                     }
-                    // Prompt to assign an agent
-                    const agentChoices = [];
-                    // Add ephemeral option first
-                    agentChoices.push({ name: 'Create new ephemeral agent (recommended)', value: '__ephemeral__' });
-                    agentChoices.push(new inquirer.Separator());
-                    // Only show staff agents that exist on disk
+                    // Build agent choices
                     const availableAgents = activeStaffAgents.filter(a => !busyAgentNames.has(a.name));
                     const busyAgents = activeStaffAgents.filter(a => busyAgentNames.has(a.name));
-                    if (availableAgents.length > 0) {
-                        agentChoices.push(new inquirer.Separator('── Available Staff Agents ──'));
-                        for (const a of availableAgents) {
-                            agentChoices.push({ name: a.name, value: a.name });
-                        }
+                    const agentChoiceList = [
+                        { name: 'Create new ephemeral agent (recommended)', value: '__ephemeral__' },
+                    ];
+                    for (const a of availableAgents) {
+                        agentChoiceList.push({ name: a.name, value: a.name });
                     }
-                    if (busyAgents.length > 0) {
-                        agentChoices.push(new inquirer.Separator('── Busy (already working) ──'));
-                        for (const a of busyAgents) {
-                            const runningExecs = executionStorage.getAgentRunningExecutions(a.name);
-                            const ticketIds = runningExecs.map(e => e.ticketId).join(', ');
-                            agentChoices.push({ name: `${a.name} (working on ${ticketIds})`, value: a.name, disabled: 'busy' });
-                        }
+                    for (const a of busyAgents) {
+                        const runningExecs = executionStorage.getAgentRunningExecutions(a.name);
+                        const ticketIds = runningExecs.map(e => e.ticketId).join(', ');
+                        agentChoiceList.push({ name: `${a.name} (working on ${ticketIds})`, value: a.name, disabled: true });
                     }
-                    const { selectedAgent } = await inquirer.prompt([
-                        {
-                            type: 'list',
-                            name: 'selectedAgent',
-                            message: `Select agent for ${ticketId}:`,
-                            choices: agentChoices,
-                        },
-                    ]);
+                    // Use FlagResolver for agent selection
+                    const agentResolver = new FlagResolver({
+                        commandName: 'work start',
+                        baseCommand: `prlt work start ${ticketId}`,
+                        jsonMode,
+                        flags: {},
+                    });
+                    agentResolver.addPrompt({
+                        flagName: 'selectedAgent',
+                        type: 'list',
+                        message: `Select agent for ${ticketId}:`,
+                        default: '__ephemeral__',
+                        choices: () => agentChoiceList,
+                    });
+                    const agentResult = await agentResolver.resolve();
+                    const selectedAgent = agentResult.selectedAgent;
                     if (selectedAgent === '__ephemeral__') {
                         // Create ephemeral agent
                         this.log(styles.muted('Creating ephemeral agent...'));
@@ -478,18 +492,25 @@ export default class WorkStart extends PMOCommand {
                         }
                     }
                     this.log('');
-                    const { action } = await inquirer.prompt([
-                        {
-                            type: 'list',
-                            name: 'action',
-                            message: 'How would you like to proceed?',
-                            choices: [
-                                { name: 'Push existing work and continue', value: 'push' },
-                                { name: 'Continue anyway (existing work may conflict)', value: 'continue' },
-                                { name: 'Cancel', value: 'cancel' },
-                            ],
-                        },
-                    ]);
+                    // Use FlagResolver for unsaved work action
+                    const unsavedResolver = new FlagResolver({
+                        commandName: 'work start',
+                        baseCommand: `prlt work start ${ticketId}`,
+                        jsonMode,
+                        flags: {},
+                    });
+                    unsavedResolver.addPrompt({
+                        flagName: 'unsavedAction',
+                        type: 'list',
+                        message: 'How would you like to proceed?',
+                        choices: () => [
+                            { name: 'Push existing work and continue', value: 'push' },
+                            { name: 'Continue anyway (existing work may conflict)', value: 'continue' },
+                            { name: 'Cancel', value: 'cancel' },
+                        ],
+                    });
+                    const unsavedResult = await unsavedResolver.resolve();
+                    const action = unsavedResult.unsavedAction;
                     if (action === 'cancel') {
                         db.close();
                         this.log(styles.muted('Cancelled.'));
@@ -562,43 +583,48 @@ export default class WorkStart extends PMOCommand {
                 // Get all actions for selection
                 const allActions = await this.storage.listActions();
                 // Build choices with suggested action at top
-                const actionChoices = [];
+                const actionChoiceList = [];
                 if (suggestedAction) {
-                    actionChoices.push({
+                    actionChoiceList.push({
                         name: `${suggestedAction.name} - ${suggestedAction.description || 'Suggested for ' + currentCategory} (Recommended)`,
                         value: suggestedAction.id,
                     });
-                    actionChoices.push(new inquirer.Separator('── Other Actions ──'));
                 }
                 for (const action of allActions) {
                     if (suggestedAction && action.id === suggestedAction.id)
                         continue;
-                    actionChoices.push({
+                    actionChoiceList.push({
                         name: `${action.name}${action.description ? ' - ' + action.description : ''}`,
                         value: action.id,
                     });
                 }
-                actionChoices.push(new inquirer.Separator('── Custom ──'));
-                actionChoices.push({ name: 'Custom prompt...', value: '__custom__' });
-                actionChoices.push({ name: 'Ad-hoc session - unstructured exploration/debugging', value: '__adhoc__' });
-                const { selectedActionId } = await inquirer.prompt([
-                    {
-                        type: 'list',
-                        name: 'selectedActionId',
-                        message: `What should the agent do with ${ticket.id}?`,
-                        choices: actionChoices,
-                    },
-                ]);
+                actionChoiceList.push({ name: 'Custom prompt...', value: '__custom__' });
+                actionChoiceList.push({ name: 'Ad-hoc session - unstructured exploration/debugging', value: '__adhoc__' });
+                // Use FlagResolver for action selection
+                const actionResolver = new FlagResolver({
+                    commandName: 'work start',
+                    baseCommand: `prlt work start ${ticketId}`,
+                    jsonMode,
+                    flags: {},
+                });
+                actionResolver.addPrompt({
+                    flagName: 'selectedActionId',
+                    type: 'list',
+                    message: `What should the agent do with ${ticket.id}?`,
+                    default: suggestedAction?.id,
+                    choices: () => actionChoiceList,
+                });
+                actionResolver.addPrompt({
+                    flagName: 'customInput',
+                    type: 'input',
+                    message: 'Enter custom prompt:',
+                    when: (ctx) => ctx.flags.selectedActionId === '__custom__',
+                    validate: (value) => value.trim() ? true : 'Prompt cannot be empty',
+                });
+                const actionResult = await actionResolver.resolve();
+                const selectedActionId = actionResult.selectedActionId;
                 if (selectedActionId === '__custom__') {
-                    const { customInput } = await inquirer.prompt([
-                        {
-                            type: 'input',
-                            name: 'customInput',
-                            message: 'Enter custom prompt:',
-                            validate: (input) => input.trim() ? true : 'Prompt cannot be empty',
-                        },
-                    ]);
-                    customPrompt = customInput.trim();
+                    customPrompt = actionResult.customInput.trim();
                 }
                 else if (selectedActionId === '__adhoc__') {
                     // Ad-hoc session - no specific action, just launch Claude for exploration
@@ -613,7 +639,7 @@ export default class WorkStart extends PMOCommand {
                         createdAt: new Date(),
                     };
                 }
-                else {
+                else if (selectedActionId) {
                     selectedAction = await this.storage.getAction(selectedActionId);
                 }
             }
@@ -670,6 +696,31 @@ export default class WorkStart extends PMOCommand {
                         missing.push('devcontainer CLI');
                     devcontainerLabel = `🐳 devcontainer (requires: ${missing.join(', ')})`;
                 }
+                const envChoices = [
+                    { name: devcontainerLabel, value: 'devcontainer', disabled: !devcontainerReady },
+                    { name: '💻 host (runs directly on your machine)', value: 'host' },
+                    { name: '✗  cancel', value: 'cancel' },
+                ];
+                // In JSON mode, use FlagResolver (outputs prompt and exits)
+                if (jsonMode) {
+                    const envResolver = new FlagResolver({
+                        commandName: 'work start',
+                        baseCommand: `prlt work start ${ticketId}`,
+                        jsonMode,
+                        flags: {},
+                    });
+                    envResolver.addPrompt({
+                        flagName: 'selectedEnvironment',
+                        type: 'list',
+                        message: 'Where should the agent run?',
+                        default: devcontainerReady ? 'devcontainer' : 'host',
+                        choices: () => envChoices,
+                    });
+                    await envResolver.resolve();
+                    // FlagResolver exits in JSON mode, so we never reach here
+                    db.close();
+                    return;
+                }
                 // Loop to allow re-selection if Docker isn't running
                 let environmentSelected = false;
                 while (!environmentSelected) {
@@ -679,11 +730,7 @@ export default class WorkStart extends PMOCommand {
                             type: 'list',
                             name: 'selectedEnvironment',
                             message: 'Where should the agent run?',
-                            choices: [
-                                { name: devcontainerLabel, value: 'devcontainer', disabled: !devcontainerReady },
-                                { name: '💻 host (runs directly on your machine)', value: 'host' },
-                                { name: '✗  cancel', value: 'cancel' },
-                            ],
+                            choices: envChoices,
                             default: devcontainerReady ? 'devcontainer' : 'host',
                         },
                     ]);
@@ -713,32 +760,37 @@ export default class WorkStart extends PMOCommand {
                         }
                         // Check GitHub token is available for git push operations
                         if (!isGitHubTokenAvailable()) {
-                            const tokenChoices = [
-                                { name: 'Yes, continue anyway (git push may fail)', value: 'continue' },
-                                { name: 'No, let me run gh auth login first', value: 'cancel' },
-                                { name: 'Switch to host mode instead', value: 'host' },
-                            ];
                             const tokenMessage = 'GitHub token not found. Git push may fail. Continue without token?';
-                            if (jsonMode) {
-                                outputPromptAsJson(buildPromptConfig('list', 'tokenAction', tokenMessage, tokenChoices), createMetadata('work start', flags));
-                                db.close();
-                                return;
+                            // Use FlagResolver for token action prompt
+                            const tokenResolver = new FlagResolver({
+                                commandName: 'work start',
+                                baseCommand: `prlt work start ${ticketId}`,
+                                jsonMode,
+                                flags: {},
+                            });
+                            tokenResolver.addPrompt({
+                                flagName: 'tokenAction',
+                                type: 'list',
+                                message: tokenMessage,
+                                default: 'continue',
+                                choices: () => [
+                                    { name: 'Yes, continue anyway (git push may fail)', value: 'continue' },
+                                    { name: 'No, let me run gh auth login first', value: 'cancel' },
+                                    { name: 'Switch to host mode instead', value: 'host' },
+                                ],
+                            });
+                            // In JSON mode, this will output prompt and exit
+                            // In interactive mode, show warning first then prompt
+                            if (!jsonMode) {
+                                this.log('');
+                                this.warn('GitHub token not found.\n' +
+                                    'Git push operations may fail inside the container.\n' +
+                                    'Run `gh auth login` to authenticate, or continue without token.');
+                                this.log('');
                             }
-                            this.log('');
-                            this.warn('GitHub token not found.\n' +
-                                'Git push operations may fail inside the container.\n' +
-                                'Run `gh auth login` to authenticate, or continue without token.');
-                            this.log('');
                             // eslint-disable-next-line no-await-in-loop -- Interactive user prompt in loop
-                            const { tokenAction } = await inquirer.prompt([
-                                {
-                                    type: 'list',
-                                    name: 'tokenAction',
-                                    message: tokenMessage,
-                                    choices: tokenChoices,
-                                    default: 'continue',
-                                },
-                            ]);
+                            const resolved = await tokenResolver.resolve();
+                            const tokenAction = resolved.tokenAction;
                             if (tokenAction === 'cancel') {
                                 db.close();
                                 this.log(styles.muted('Run `gh auth login` and try again.'));
@@ -830,20 +882,26 @@ export default class WorkStart extends PMOCommand {
                     const warningMsg = flags['run-on-host']
                         ? 'Select display mode (--run-on-host: bypassing devcontainer):'
                         : 'Select display mode (no devcontainer - running on host):';
-                    const { selectedMode } = await inquirer.prompt([
-                        {
-                            type: 'list',
-                            name: 'selectedMode',
-                            message: warningMsg,
-                            choices: [
-                                { name: '🖥️  New tab      - Opens in new terminal tab (recommended)', value: 'terminal' },
-                                { name: '▶️  Foreground  - Run in current terminal (blocking)', value: 'foreground' },
-                                { name: '📦 Background  - Runs detached, reattach with: prlt session attach', value: 'background' },
-                            ],
-                            default: 'terminal',
-                        },
-                    ]);
-                    displayMode = selectedMode;
+                    // Use FlagResolver for display mode selection
+                    const displayResolver = new FlagResolver({
+                        commandName: 'work start',
+                        baseCommand: `prlt work start ${ticketId}`,
+                        jsonMode,
+                        flags: {},
+                    });
+                    displayResolver.addPrompt({
+                        flagName: 'selectedMode',
+                        type: 'list',
+                        message: warningMsg,
+                        default: 'terminal',
+                        choices: () => [
+                            { name: '🖥️  New tab      - Opens in new terminal tab (recommended)', value: 'terminal' },
+                            { name: '▶️  Foreground  - Run in current terminal (blocking)', value: 'foreground' },
+                            { name: '📦 Background  - Runs detached, reattach with: prlt session attach', value: 'background' },
+                        ],
+                    });
+                    const displayResult = await displayResolver.resolve();
+                    displayMode = displayResult.selectedMode;
                 }
             }
             const executor = flags.executor || DEFAULT_EXECUTION_CONFIG.defaultExecutor;
@@ -858,19 +916,26 @@ export default class WorkStart extends PMOCommand {
                     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('');
-                    const { authAction } = await inquirer.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' },
-                                { name: '💻 Switch to host environment instead', value: 'host' },
-                                { name: '⏩ Continue anyway (must run /login in first agent)', value: 'continue' },
-                                { name: '✗  Cancel', value: 'cancel' },
-                            ],
-                        },
-                    ]);
+                    // 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.'));
@@ -936,7 +1001,7 @@ export default class WorkStart extends PMOCommand {
                 }
             }
             // Prompt for permissions mode (all environments)
-            // Skip prompt if --permission-mode flag is set
+            // Use FlagResolver to handle both JSON mode and interactive prompts consistently
             if (flags['permission-mode']) {
                 sandboxed = flags['permission-mode'] === 'safe';
             }
@@ -944,24 +1009,26 @@ export default class WorkStart extends PMOCommand {
                 const containerNote = environment === 'devcontainer'
                     ? ' (container provides additional isolation)'
                     : '';
-                const permissionChoices = [
-                    { name: '⚠️  danger - Skip permission checks (faster, container provides isolation)', value: 'danger', command: `prlt work start ${ticketId} --skip-permissions` },
-                    { name: '🔒 safe   - Requires approval for dangerous operations', value: 'safe' },
-                ];
-                // Handle JSON mode
-                if (jsonMode) {
-                    outputPromptAsJson(buildPromptConfig('list', 'permissionMode', `Permission mode for Claude Code${containerNote}:`, permissionChoices, 'danger'), createMetadata('work start', flags));
-                }
-                const { permissionMode } = await inquirer.prompt([
-                    {
-                        type: 'list',
-                        name: 'permissionMode',
-                        message: `Permission mode for Claude Code${containerNote}:`,
-                        choices: permissionChoices,
-                        default: 'danger',
-                    },
-                ]);
-                sandboxed = permissionMode === 'safe';
+                // Create resolver for permission-mode flag
+                const permissionResolver = new FlagResolver({
+                    commandName: 'work start',
+                    baseCommand: `prlt work start ${ticketId}`,
+                    jsonMode,
+                    flags: { 'permission-mode': flags['permission-mode'] },
+                });
+                permissionResolver.addPrompt({
+                    flagName: 'permission-mode',
+                    type: 'list',
+                    message: `Permission mode for Claude Code${containerNote}:`,
+                    default: 'danger',
+                    choices: () => [
+                        { name: '⚠️  danger - Skip permission checks (faster, container provides isolation)', value: 'danger' },
+                        { name: '🔒 safe   - Requires approval for dangerous operations', value: 'safe' },
+                    ],
+                    when: (ctx) => !ctx.flags['permission-mode'],
+                });
+                const resolvedPermission = await permissionResolver.resolve();
+                sandboxed = resolvedPermission['permission-mode'] === 'safe';
             }
             // Prompt for PR creation when work is complete
             // Only show if gh CLI is available and authenticated
@@ -975,19 +1042,25 @@ export default class WorkStart extends PMOCommand {
                 createPR = false;
             }
             else if (ghAvailable) {
-                const { prChoice } = await inquirer.prompt([
-                    {
-                        type: 'list',
-                        name: 'prChoice',
-                        message: 'Create a pull request when work is ready?',
-                        choices: [
-                            { name: '✓ Yes - Create PR when running `prlt work ready`', value: 'yes' },
-                            { name: '✗ No  - Just move ticket to review (can create PR later)', value: 'no' },
-                        ],
-                        default: 'yes',
-                    },
-                ]);
-                createPR = prChoice === 'yes';
+                // Use FlagResolver for PR choice
+                const prResolver = new FlagResolver({
+                    commandName: 'work start',
+                    baseCommand: `prlt work start ${ticketId}`,
+                    jsonMode,
+                    flags: {},
+                });
+                prResolver.addPrompt({
+                    flagName: 'prChoice',
+                    type: 'list',
+                    message: 'Create a pull request when work is ready?',
+                    default: 'yes',
+                    choices: () => [
+                        { name: '✓ Yes - Create PR when running `prlt work ready`', value: 'yes' },
+                        { name: '✗ No  - Just move ticket to review (can create PR later)', value: 'no' },
+                    ],
+                });
+                const prResult = await prResolver.resolve();
+                createPR = prResult.prChoice === 'yes';
             }
             // Show execution info
             this.log('');
@@ -1042,18 +1115,26 @@ export default class WorkStart extends PMOCommand {
                 }
                 else {
                     // No branch in DB - ask user if one already exists
-                    const { branchChoice } = await inquirer.prompt([
-                        {
-                            type: 'list',
-                            name: 'branchChoice',
-                            message: `Does a branch already exist for ${ticket.id}?`,
-                            choices: [
-                                { name: 'No, create new branch (Recommended)', value: 'create' },
-                                { name: 'Yes, I\'ll enter the branch name', value: 'enter' },
-                                { name: 'Search for matching branches', value: 'search' },
-                            ],
-                        },
-                    ]);
+                    // Use FlagResolver for branch choice
+                    const branchResolver = new FlagResolver({
+                        commandName: 'work start',
+                        baseCommand: `prlt work start ${ticketId}`,
+                        jsonMode,
+                        flags: {},
+                    });
+                    branchResolver.addPrompt({
+                        flagName: 'branchChoice',
+                        type: 'list',
+                        message: `Does a branch already exist for ${ticket.id}?`,
+                        default: 'create',
+                        choices: () => [
+                            { name: 'No, create new branch (Recommended)', value: 'create' },
+                            { name: 'Yes, I\'ll enter the branch name', value: 'enter' },
+                            { name: 'Search for matching branches', value: 'search' },
+                        ],
+                    });
+                    const branchResult = await branchResolver.resolve();
+                    const branchChoice = branchResult.branchChoice;
                     if (branchChoice === 'enter') {
                         // User enters existing branch name
                         const { enteredBranch } = await inquirer.prompt([

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

@@ -13,6 +13,7 @@ export default class WorkWatch extends PMOCommand {
         mode: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'skip-permissions': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'create-pr': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     private isRunning;