@proletariat/cli 0.3.35 → 0.3.40

package/dist/commands/work/start.js

@@ -13,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';
@@ -71,6 +71,7 @@ export default class WorkStart extends PMOCommand {
     static description = 'Start work on a ticket (launches an agent to implement it)';
     static examples = [
         '<%= config.bin %> <%= command.id %> TKT-001',
+        '<%= config.bin %> <%= command.id %> TKT-001 --create-pr  # Create PR when work is ready',
         '<%= config.bin %> <%= command.id %> TKT-001 --mode foreground',
         '<%= config.bin %> <%= command.id %> TKT-001 --mode tmux',
         '<%= config.bin %> <%= command.id %> TKT-001 --mode terminal',
@@ -137,11 +138,11 @@ export default class WorkStart extends PMOCommand {
             default: false,
         }),
         'create-pr': Flags.boolean({
-            description: 'Create PR when work is ready',
+            description: 'Create PR when work is ready (canonical flag for PR behavior)',
             default: false,
         }),
         'no-pr': Flags.boolean({
-            description: 'Do not create PR when work is ready',
+            description: '[deprecated: use --create-pr instead] Skip PR creation when work is ready',
             default: false,
         }),
         output: Flags.string({
@@ -193,6 +194,10 @@ export default class WorkStart extends PMOCommand {
         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.');
+        }
         // Handle --skip-permissions flag (alias for --permission-mode danger)
         // Check for conflicting flags first
         if (flags['skip-permissions'] && flags['permission-mode']) {
@@ -272,6 +277,7 @@ 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';
                     // Build the confirm command with --yes
                     let confirmCmd = `prlt work start ${ticketId}`;
                     if (flags.action)
@@ -810,11 +816,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
@@ -1008,109 +1023,171 @@ export default class WorkStart extends PMOCommand {
             const outputMode = flags.output || DEFAULT_EXECUTION_CONFIG.outputMode;
             // Track whether user explicitly chose to use API key instead of OAuth
             let useApiKey = flags['use-api-key'] || false;
-            // Check Docker credentials for devcontainer environment
+            // Auth method resolution for devcontainer environment
             if (environment === 'devcontainer' && !useApiKey) {
-                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 {
-                        const hasApiKey = !!process.env.ANTHROPIC_API_KEY;
+                // 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 OAuth credentials found for Docker containers'));
-                        this.log(styles.muted('   Agents need credentials to authenticate with Claude.'));
+                        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('');
-                        // Build choices based on available options
-                        const authChoices = [
-                            { name: `🔐 Run ${this.config.bin} agent auth now (recommended — uses Max subscription)`, value: 'auth' },
-                        ];
-                        if (hasApiKey) {
-                            authChoices.push({ name: '🔑 Use ANTHROPIC_API_KEY (⚠️  uses API credits, not Max subscription)', value: 'apikey' });
-                        }
-                        authChoices.push({ name: '💻 Switch to host environment instead', value: 'host' }, { 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: () => 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('');
+                        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('');
                         }
                     }
                 }
@@ -1161,9 +1238,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
@@ -1206,9 +1287,7 @@ export default class WorkStart extends PMOCommand {
                     this.log(styles.warning(`   Permissions: ⚠️  danger (--dangerously-skip-permissions)`));
                 }
                 this.log(styles.muted(`   Output: ${outputMode === 'interactive' ? 'streaming (watch Claude work)' : 'print (final result only)'}`));
-                if (ghAvailable) {
-                    this.log(styles.muted(`   Create PR: ${createPR ? 'yes (when work is ready)' : 'no'}`));
-                }
+                this.log(styles.muted(`   PR mode: ${createPR ? 'create-pr' : 'no-pr'}${ghAvailable ? '' : ' (gh CLI not available)'}`));
                 this.log(styles.muted(`   Worktree: ${worktreePath}`));
                 this.log(styles.muted(`   Branch: ${branch}`));
                 this.log('');
@@ -1510,7 +1589,9 @@ export default class WorkStart extends PMOCommand {
                 });
                 // Output results
                 if (jsonMode) {
-                    // Output JSON execution result
+                    // Output JSON execution result with resolved PR mode
+                    const metadata = createMetadata('work start', flags);
+                    metadata.resolvedPRMode = createPR ? 'create-pr' : 'no-pr';
                     outputExecutionResultAsJson([{
                             workId: execution.id,
                             ticketId: ticket.id,
@@ -1518,7 +1599,7 @@ export default class WorkStart extends PMOCommand {
                             sessionId: result.sessionId,
                             containerId: result.containerId,
                             status: 'running',
-                        }], 1, 0, createMetadata('work start', flags));
+                        }], 1, 0, metadata);
                 }
                 else {
                     this.log('');
@@ -1533,13 +1614,15 @@ export default class WorkStart extends PMOCommand {
             else {
                 executionStorage.updateStatus(execution.id, 'failed');
                 if (jsonMode) {
-                    // Output JSON failure result
+                    // Output JSON failure result with resolved PR mode
+                    const failMetadata = createMetadata('work start', flags);
+                    failMetadata.resolvedPRMode = createPR ? 'create-pr' : 'no-pr';
                     outputExecutionResultAsJson([{
                             workId: execution.id,
                             ticketId: ticket.id,
                             agent: assignedAgent,
                             status: 'failed',
-                        }], 0, 1, createMetadata('work start', flags));
+                        }], 0, 1, failMetadata);
                 }
                 else {
                     this.error(`Failed to start work: ${result.error}`);

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>;
+}

package/dist/commands/work/status.js

@@ -0,0 +1,60 @@
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles, formatPriority } from '../../lib/styles.js';
+import { shouldOutputJson, outputSuccessAsJson, createMetadata, } from '../../lib/prompt-json.js';
+export default class WorkStatus extends PMOCommand {
+    static description = 'Show current work status (in-progress tickets)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { flags } = await this.parse(WorkStatus);
+        const projectId = flags.project;
+        const jsonMode = shouldOutputJson(flags);
+        // List all tickets, optionally filtered by project
+        const tickets = await this.storage.listTickets(projectId, { allProjects: !projectId });
+        const inProgress = tickets.filter(t => t.statusCategory === 'started' && t.assignee);
+        if (jsonMode) {
+            outputSuccessAsJson({
+                inProgressCount: inProgress.length,
+                tickets: inProgress.map(t => ({
+                    id: t.id,
+                    title: t.title,
+                    assignee: t.assignee,
+                    statusName: t.statusName,
+                    priority: t.priority,
+                    projectId: t.projectId,
+                    branch: t.branch,
+                })),
+            }, createMetadata('work status', flags));
+            return;
+        }
+        // Interactive mode
+        if (inProgress.length === 0) {
+            this.log(styles.info('No in-progress work found.'));
+            return;
+        }
+        this.log(styles.title(`\nWork In Progress (${inProgress.length})`));
+        this.log(styles.muted('─'.repeat(60)));
+        for (const ticket of inProgress) {
+            const priority = formatPriority(ticket.priority);
+            this.log(`  ${styles.code(ticket.id)} ${ticket.title} ${priority}`);
+            const details = [
+                ticket.assignee ? `Assignee: ${ticket.assignee}` : null,
+                ticket.statusName ? `Status: ${ticket.statusName}` : null,
+                ticket.projectId ? `Project: ${ticket.projectId}` : null,
+                ticket.branch ? `Branch: ${ticket.branch}` : null,
+            ].filter(Boolean).join(' | ');
+            if (details) {
+                this.log(styles.muted(`     ${details}`));
+            }
+        }
+        this.log('');
+    }
+}

package/dist/commands/work/watch.js

@@ -60,7 +60,7 @@ export default class WorkWatch extends PMOCommand {
             default: false,
         }),
         'create-pr': Flags.boolean({
-            description: 'Create PR when work is ready',
+            description: 'Create PR when work is ready (canonical flag for PR behavior)',
             default: false,
         }),
     };

package/dist/commands/workflow/index.js

@@ -1,5 +1,6 @@
 import { Flags } from '@oclif/core';
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson } from '../../lib/prompt-json.js';
 import { styles } from '../../lib/styles.js';
 export default class Workflow extends PMOCommand {
     static description = 'List all available workflows (alias for workflow list)';
@@ -31,7 +32,7 @@ export default class Workflow extends PMOCommand {
         if (flags.custom)
             filter.isBuiltin = false;
         const workflows = await this.storage.listWorkflows(Object.keys(filter).length > 0 ? filter : undefined);
-        if (flags.json || flags.machine) {
+        if (shouldOutputJson(flags)) {
             this.log(JSON.stringify(workflows, null, 2));
             return;
         }

package/dist/commands/workflow/show.d.ts

@@ -0,0 +1,13 @@
+import WorkflowView from './view.js';
+export default class WorkflowShow extends WorkflowView {
+    static description: string;
+    static hidden: boolean;
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+}

package/dist/commands/workflow/show.js

@@ -0,0 +1,16 @@
+import { Args } from '@oclif/core';
+import { pmoBaseFlags } from '../../lib/pmo/index.js';
+import WorkflowView from './view.js';
+export default class WorkflowShow extends WorkflowView {
+    static description = 'View details of a workflow (alias for workflow view)';
+    static hidden = true;
+    static args = {
+        id: Args.string({
+            description: 'Workflow ID - prompts with dropdown if not provided',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+    };
+}

package/dist/commands/workspace/add.js

@@ -4,6 +4,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { registerWorkspace, normalizePath, isWorkspaceRegistered, getWorkspaceNameFromPath, } from '../../lib/machine-config.js';
 import { machineOutputFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson } from '../../lib/prompt-json.js';
 export default class WorkspaceAdd extends Command {
     static description = 'Register an existing workspace in the machine config';
     static examples = [
@@ -26,6 +27,7 @@ export default class WorkspaceAdd extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(WorkspaceAdd);
+        const jsonMode = shouldOutputJson(flags);
         // Normalize the path
         const workspacePath = normalizePath(args.path);
         // Check if path exists
@@ -56,6 +58,10 @@ export default class WorkspaceAdd extends Command {
         }
         // Check if already registered
         if (isWorkspaceRegistered(workspacePath)) {
+            if (jsonMode) {
+                this.log(JSON.stringify({ type: 'success', result: { path: workspacePath, status: 'already_registered' } }));
+                return;
+            }
             this.log(chalk.yellow(`Workspace is already registered: ${workspacePath}`));
             this.log(chalk.gray('Use "prlt workspace use" to set it as active.'));
             return;
@@ -65,11 +71,20 @@ export default class WorkspaceAdd extends Command {
         // Register the workspace
         try {
             const entry = registerWorkspace(workspacePath, workspaceName, true);
+            if (jsonMode) {
+                this.log(JSON.stringify({ type: 'success', result: { name: entry.name, path: entry.path, registeredAt: entry.registeredAt, status: 'registered' } }));
+                return;
+            }
             this.log(chalk.green(`Registered workspace: ${entry.name}`));
             this.log(chalk.gray(`  Path: ${entry.path}`));
             this.log(chalk.gray(`  Registered at: ${entry.registeredAt}`));
         }
         catch (error) {
+            if (jsonMode) {
+                this.log(JSON.stringify({ type: 'error', error: { code: 'REGISTER_FAILED', message: error.message } }));
+                this.exit(1);
+                return;
+            }
             this.error(`Failed to register workspace: ${error.message}`);
         }
     }

package/dist/commands/workspace/list.js

@@ -5,6 +5,7 @@ import { machineOutputFlags } from '../../lib/pmo/index.js';
 import { getRegisteredWorkspaces, getActiveWorkspace, } from '../../lib/machine-config.js';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import { shouldOutputJson } from '../../lib/prompt-json.js';
 export default class WorkspaceList extends Command {
     static description = 'List all registered and discovered HQ workspaces';
     static examples = [
@@ -78,7 +79,7 @@ export default class WorkspaceList extends Command {
             });
         }
         // JSON output
-        if (flags.json || flags.machine) {
+        if (shouldOutputJson(flags)) {
             const output = {
                 workspaces: workspaces.map((w) => ({
                     name: w.name,

package/dist/commands/workspace/prune.js

@@ -5,7 +5,7 @@ import { PromptCommand } from '../../lib/prompt-command.js';
 import { styles } from '../../lib/styles.js';
 import { getRegisteredHeadquarters, unregisterHeadquarters, } from '../../lib/machine-config.js';
 import { getWorkspaceAgents, removeAgentsFromDatabase, getDatabasePath, } from '../../lib/database/index.js';
-import { outputConfirmationNeededAsJson, createMetadata, } from '../../lib/prompt-json.js';
+import { outputConfirmationNeededAsJson, createMetadata, shouldOutputJson, isNonTTY, } from '../../lib/prompt-json.js';
 import { machineOutputFlags } from '../../lib/pmo/index.js';
 export default class WorkspacePrune extends PromptCommand {
     static description = 'Remove stale workspace entries and agents with deleted worktrees';
@@ -29,16 +29,16 @@ export default class WorkspacePrune extends PromptCommand {
     };
     async run() {
         const { flags } = await this.parse(WorkspacePrune);
-        // In non-TTY mode without --json (CI, scripts, piped), default to dry-run unless --force is set.
-        // In --json mode, we use confirmation_needed output instead of auto-dry-run so agents can review and confirm.
-        const isNonTTY = !process.stdout.isTTY;
-        const effectiveDryRun = flags['dry-run'] || (!(flags.json || flags.machine) && isNonTTY && !flags.force);
+        // In non-TTY mode (CI, scripts, piped), default to dry-run unless --force is set.
+        // This applies regardless of output format (text or JSON).
+        const nonTTY = isNonTTY();
+        const effectiveDryRun = flags['dry-run'] || (nonTTY && !flags.force);
         // Find stale entries
         const staleWorkspaces = this.findStaleWorkspaces();
         const staleAgents = this.findStaleAgents();
         const totalStale = staleWorkspaces.length + staleAgents.length;
         // JSON output
-        if (flags.json || flags.machine) {
+        if (shouldOutputJson(flags)) {
             const output = {
                 dryRun: effectiveDryRun,
                 staleWorkspaces: staleWorkspaces.map(w => ({
@@ -112,7 +112,7 @@ export default class WorkspacePrune extends PromptCommand {
                 this.log(styles.muted(`  • ${staleAgents.length} agent record(s)`));
             }
             this.log('');
-            if (isNonTTY) {
+            if (nonTTY) {
                 this.log(styles.muted('Non-TTY environment detected. Run with --force to remove these entries.'));
             }
             else {