@proletariat/cli 0.3.19 → 0.3.21

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

@@ -3,12 +3,15 @@ import inquirer from 'inquirer';
 import { PMOCommand, pmoBaseFlags } from '../../../lib/pmo/index.js';
 import { PRIORITIES, PRIORITY_LABELS, TICKET_CATEGORIES } from '../../../lib/pmo/types.js';
 import { styles } from '../../../lib/styles.js';
+import { shouldOutputJson, outputSuccessAsJson, outputPromptAsJson, buildFormPromptConfig, createMetadata, } from '../../../lib/prompt-json.js';
 export default class TicketTemplateCreate extends PMOCommand {
     static description = 'Create a new ticket template from scratch';
     static examples = [
         '<%= config.bin %> <%= command.id %> "Bug Report"',
         '<%= config.bin %> <%= command.id %> "Feature Request" -d "Template for new features"',
         '<%= config.bin %> <%= command.id %> "Task" --title-pattern "[TASK] " --priority P2',
+        '<%= config.bin %> <%= command.id %> "Onboarding" --subtask "Setup environment" --subtask "Read docs"',
+        '<%= config.bin %> <%= command.id %> "Bug" --ac "Bug is fixed" --ac "Tests pass" --category bug',
     ];
     static args = {
         name: Args.string({
@@ -25,6 +28,9 @@ export default class TicketTemplateCreate extends PMOCommand {
         'title-pattern': Flags.string({
             description: 'Default title prefix/pattern (e.g., "[BUG] ")',
         }),
+        'description-template': Flags.string({
+            description: 'Default description template (markdown)',
+        }),
         priority: Flags.string({
             char: 'p',
             description: 'Default priority',
@@ -35,12 +41,141 @@ export default class TicketTemplateCreate extends PMOCommand {
             description: 'Default category',
             options: [...TICKET_CATEGORIES],
         }),
+        subtask: Flags.string({
+            description: 'Add a suggested subtask (can be used multiple times)',
+            multiple: true,
+        }),
+        ac: Flags.string({
+            description: 'Add an acceptance criterion pattern (can be used multiple times)',
+            multiple: true,
+        }),
+        label: Flags.string({
+            char: 'l',
+            description: 'Add a default label (can be used multiple times)',
+            multiple: true,
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
     };
     getPMOOptions() {
         return { promptIfMultiple: false };
     }
     async execute() {
         const { args, flags } = await this.parse(TicketTemplateCreate);
+        const jsonMode = shouldOutputJson(flags);
+        // Check if we have all required data via flags (non-interactive mode)
+        const hasName = Boolean(args.name);
+        const hasAllFlags = hasName; // Name is the only required field
+        // In JSON mode with missing required data, output form prompt
+        if (jsonMode && !hasAllFlags) {
+            const fields = [];
+            if (!hasName) {
+                fields.push({
+                    type: 'input',
+                    name: 'name',
+                    message: 'Template name:',
+                });
+            }
+            // Add optional fields that weren't provided
+            if (flags.description === undefined) {
+                fields.push({
+                    type: 'input',
+                    name: 'description',
+                    message: 'Template description (optional):',
+                });
+            }
+            if (flags['title-pattern'] === undefined) {
+                fields.push({
+                    type: 'input',
+                    name: 'titlePattern',
+                    message: 'Title prefix/pattern (optional, e.g., "[BUG] "):',
+                });
+            }
+            if (flags.priority === undefined) {
+                fields.push({
+                    type: 'list',
+                    name: 'priority',
+                    message: 'Default priority:',
+                    choices: [
+                        { name: 'None', value: '' },
+                        ...PRIORITIES.map(p => ({ name: PRIORITY_LABELS[p], value: p })),
+                    ],
+                });
+            }
+            if (flags.category === undefined) {
+                fields.push({
+                    type: 'list',
+                    name: 'category',
+                    message: 'Default category:',
+                    choices: [
+                        { name: 'None', value: '' },
+                        ...TICKET_CATEGORIES.map(c => ({ name: c, value: c })),
+                    ],
+                });
+            }
+            outputPromptAsJson(buildFormPromptConfig(fields), createMetadata('ticket template create', flags));
+            return; // outputPromptAsJson exits, but TypeScript needs this
+        }
+        // Non-interactive mode: use flag values directly
+        if (hasAllFlags && (jsonMode || this.hasNonDefaultFlags(flags))) {
+            const name = args.name;
+            const description = flags.description;
+            const titlePattern = flags['title-pattern'];
+            const priority = flags.priority;
+            const category = flags.category;
+            const subtasks = flags.subtask || [];
+            const acs = flags.ac || [];
+            const labels = flags.label || [];
+            // Build description template with ACs if provided
+            let descriptionTemplate = flags['description-template'];
+            if (acs.length > 0 && !descriptionTemplate) {
+                // Create a description template with acceptance criteria section
+                descriptionTemplate = '## Description\n\n## Acceptance Criteria\n' +
+                    acs.map(ac => `- [ ] ${ac}`).join('\n') + '\n';
+            }
+            else if (acs.length > 0 && descriptionTemplate) {
+                // Append ACs to existing template if it doesn't have an AC section
+                if (!descriptionTemplate.toLowerCase().includes('acceptance criteria')) {
+                    descriptionTemplate += '\n\n## Acceptance Criteria\n' +
+                        acs.map(ac => `- [ ] ${ac}`).join('\n') + '\n';
+                }
+            }
+            // Create the template
+            const template = await this.storage.createTicketTemplate({
+                name,
+                description,
+                titlePattern,
+                defaultPriority: priority,
+                defaultCategory: category,
+                descriptionTemplate,
+                suggestedSubtasks: subtasks.map(title => ({ title })),
+                defaultLabels: labels,
+            });
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    template: {
+                        id: template.id,
+                        name: template.name,
+                        description: template.description,
+                        titlePattern: template.titlePattern,
+                        defaultPriority: template.defaultPriority,
+                        defaultCategory: template.defaultCategory,
+                        descriptionTemplate: template.descriptionTemplate,
+                        suggestedSubtasks: template.suggestedSubtasks,
+                        defaultLabels: template.defaultLabels,
+                    },
+                }, createMetadata('ticket template create', flags));
+                return;
+            }
+            this.log(styles.success(`\nCreated template "${styles.emphasis(template.name)}"`));
+            this.log(styles.muted(`  ID: ${template.id}`));
+            this.log('');
+            this.log(styles.muted(`Create ticket from template: prlt ticket template apply ${template.id}`));
+            return;
+        }
+        // Interactive mode
         // Get template name
         let name = args.name;
         if (!name) {
@@ -100,61 +235,79 @@ export default class TicketTemplateCreate extends PMOCommand {
                 }]);
             category = selectedCategory || undefined;
         }
-        // Ask about description template
-        const { wantDescriptionTemplate } = await inquirer.prompt([{
-                type: 'list',
-                name: 'wantDescriptionTemplate',
-                message: 'Add a description template?',
-                choices: [
-                    { name: 'No', value: false },
-                    { name: 'Yes', value: true },
-                ],
-            }]);
-        let descriptionTemplate;
-        if (wantDescriptionTemplate) {
-            const { template } = await inquirer.prompt([{
-                    type: 'editor',
-                    name: 'template',
-                    message: 'Description template (opens editor):',
-                    default: `## Summary\n\n## Details\n\n## Acceptance Criteria\n- [ ] \n`,
+        // Handle description template - use flag value or prompt
+        let descriptionTemplate = flags['description-template'];
+        if (descriptionTemplate === undefined) {
+            const { wantDescriptionTemplate } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'wantDescriptionTemplate',
+                    message: 'Add a description template?',
+                    choices: [
+                        { name: 'No', value: false },
+                        { name: 'Yes', value: true },
+                    ],
                 }]);
-            descriptionTemplate = template || undefined;
-        }
-        // Ask about default subtasks
-        const subtasks = [];
-        const { wantSubtasks } = await inquirer.prompt([{
-                type: 'list',
-                name: 'wantSubtasks',
-                message: 'Add default subtasks?',
-                choices: [
-                    { name: 'No', value: false },
-                    { name: 'Yes', value: true },
-                ],
-            }]);
-        if (wantSubtasks) {
-            let addMore = true;
-            while (addMore) {
-                // eslint-disable-next-line no-await-in-loop -- Interactive loop for subtask creation
-                const { subtaskTitle } = await inquirer.prompt([{
-                        type: 'input',
-                        name: 'subtaskTitle',
-                        message: 'Subtask title:',
-                        validate: (input) => input.length > 0 || 'Title is required',
-                    }]);
-                subtasks.push(subtaskTitle);
-                // eslint-disable-next-line no-await-in-loop -- Interactive loop continuation
-                const { another } = await inquirer.prompt([{
-                        type: 'list',
-                        name: 'another',
-                        message: 'Add another subtask?',
-                        choices: [
-                            { name: 'No', value: false },
-                            { name: 'Yes', value: true },
-                        ],
+            if (wantDescriptionTemplate) {
+                const { template } = await inquirer.prompt([{
+                        type: 'editor',
+                        name: 'template',
+                        message: 'Description template (opens editor):',
+                        default: `## Summary\n\n## Details\n\n## Acceptance Criteria\n- [ ] \n`,
                     }]);
-                addMore = another;
+                descriptionTemplate = template || undefined;
             }
         }
+        // Handle subtasks - use flag values or prompt
+        const subtasks = flags.subtask ? [...flags.subtask] : [];
+        if (subtasks.length === 0) {
+            const { wantSubtasks } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'wantSubtasks',
+                    message: 'Add default subtasks?',
+                    choices: [
+                        { name: 'No', value: false },
+                        { name: 'Yes', value: true },
+                    ],
+                }]);
+            if (wantSubtasks) {
+                let addMore = true;
+                while (addMore) {
+                    // eslint-disable-next-line no-await-in-loop -- Interactive loop for subtask creation
+                    const { subtaskTitle } = await inquirer.prompt([{
+                            type: 'input',
+                            name: 'subtaskTitle',
+                            message: 'Subtask title:',
+                            validate: (input) => input.length > 0 || 'Title is required',
+                        }]);
+                    subtasks.push(subtaskTitle);
+                    // eslint-disable-next-line no-await-in-loop -- Interactive loop continuation
+                    const { another } = await inquirer.prompt([{
+                            type: 'list',
+                            name: 'another',
+                            message: 'Add another subtask?',
+                            choices: [
+                                { name: 'No', value: false },
+                                { name: 'Yes', value: true },
+                            ],
+                        }]);
+                    addMore = another;
+                }
+            }
+        }
+        // Handle ACs - add to description template if provided via flag
+        const acs = flags.ac || [];
+        if (acs.length > 0) {
+            if (!descriptionTemplate) {
+                descriptionTemplate = '## Description\n\n## Acceptance Criteria\n' +
+                    acs.map(ac => `- [ ] ${ac}`).join('\n') + '\n';
+            }
+            else if (!descriptionTemplate.toLowerCase().includes('acceptance criteria')) {
+                descriptionTemplate += '\n\n## Acceptance Criteria\n' +
+                    acs.map(ac => `- [ ] ${ac}`).join('\n') + '\n';
+            }
+        }
+        // Handle labels
+        const labels = flags.label ? [...flags.label] : [];
         // Show preview
         this.log(`\n${styles.emphasis('Template Preview:')}`);
         this.log(styles.muted(`  Name: ${name}`));
@@ -179,6 +332,9 @@ export default class TicketTemplateCreate extends PMOCommand {
                 this.log(styles.muted(`    - ${subtask}`));
             }
         }
+        if (labels.length > 0) {
+            this.log(styles.muted(`  Default labels: ${labels.join(', ')}`));
+        }
         // Confirm creation
         const { confirm } = await inquirer.prompt([{
                 type: 'list',
@@ -202,11 +358,27 @@ export default class TicketTemplateCreate extends PMOCommand {
             defaultCategory: category,
             descriptionTemplate,
             suggestedSubtasks: subtasks.map(title => ({ title })),
-            defaultLabels: [],
+            defaultLabels: labels,
         });
         this.log(styles.success(`\nCreated template "${styles.emphasis(template.name)}"`));
         this.log(styles.muted(`  ID: ${template.id}`));
         this.log('');
         this.log(styles.muted(`Create ticket from template: prlt ticket template apply ${template.id}`));
     }
+    /**
+     * Check if any non-default flags were provided (indicating non-interactive intent)
+     */
+    hasNonDefaultFlags(flags) {
+        const nonDefaultFlags = [
+            'description',
+            'title-pattern',
+            'description-template',
+            'priority',
+            'category',
+            'subtask',
+            'ac',
+            'label',
+        ];
+        return nonDefaultFlags.some(flag => flags[flag] !== undefined);
+    }
 }

package/dist/commands/ticket/template/save.d.ts

@@ -7,9 +7,10 @@ export default class TicketTemplateSave extends PMOCommand {
         name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static flags: {
+        'template-name': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        machine: 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>;
     };
     execute(): Promise<void>;

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

@@ -2,6 +2,7 @@ import { Flags, Args } from '@oclif/core';
 import inquirer from 'inquirer';
 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 template from an existing ticket';
     static examples = [
@@ -20,20 +21,45 @@ export default class TicketTemplateSave extends PMOCommand {
     };
     static flags = {
         ...pmoBaseFlags,
+        'template-name': Flags.string({
+            char: 'n',
+            description: 'Template name (alternative to positional arg, required in non-TTY/JSON mode)',
+        }),
         description: Flags.string({
             char: 'd',
             description: 'Template description',
         }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
     };
     async execute() {
         const { args, flags } = await this.parse(TicketTemplateSave);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Helper to handle errors in JSON mode
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('ticket template save', flags));
+            }
+            this.error(message);
+        };
         // Get ticket ID - prompt with picker if not provided
         let ticketId = args.ticket;
         if (!ticketId) {
             const projectId = await this.requireProject();
             const tickets = await this.storage.listTickets(projectId);
             if (tickets.length === 0) {
-                this.error('No tickets found in this project.\nCreate a ticket first: prlt ticket create');
+                return handleError('NO_TICKETS', 'No tickets found in this project.\nCreate a ticket first: prlt ticket create');
+            }
+            // In JSON mode, output prompt config for ticket selection
+            if (jsonMode) {
+                const choices = tickets.slice(0, 20).map(t => ({
+                    name: `${t.id} - ${t.title}`,
+                    value: t.id,
+                }));
+                outputPromptAsJson(buildPromptConfig('list', 'ticket', 'Select a ticket to save as template:', choices), createMetadata('ticket template save', flags));
             }
             const { selectedTicket } = await inquirer.prompt([{
                     type: 'list',
@@ -49,23 +75,28 @@ export default class TicketTemplateSave extends PMOCommand {
         // Verify ticket exists
         const ticket = await this.storage.getTicket(ticketId);
         if (!ticket) {
-            this.error(`Ticket not found: ${ticketId}\nRun 'prlt ticket list' to see available tickets.`);
+            return handleError('TICKET_NOT_FOUND', `Ticket not found: ${ticketId}\nRun 'prlt ticket list' to see available tickets.`);
         }
-        // Get template name - prompt if not provided
-        let templateName = args.name;
+        // Get template name - prefer flag over positional arg
+        let templateName = flags['template-name'] || args.name;
         if (!templateName) {
+            const defaultName = ticket.category || ticket.title.split(' ')[0];
+            // In JSON mode, output prompt config for template name
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('input', 'name', 'Template name:', undefined, defaultName), createMetadata('ticket template save', flags));
+            }
             const { name } = await inquirer.prompt([{
                     type: 'input',
                     name: 'name',
                     message: 'Template name:',
-                    default: ticket.category || ticket.title.split(' ')[0],
+                    default: defaultName,
                     validate: (input) => input.length > 0 || 'Name is required',
                 }]);
             templateName = name;
         }
-        // Get description if not provided
+        // Get description if not provided - only prompt interactively (not in JSON mode)
         let description = flags.description;
-        if (description === undefined) {
+        if (description === undefined && !jsonMode) {
             const { desc } = await inquirer.prompt([{
                     type: 'input',
                     name: 'desc',
@@ -75,6 +106,26 @@ export default class TicketTemplateSave extends PMOCommand {
         }
         // Create template from ticket
         const template = await this.storage.createTicketTemplateFromTicket(ticketId, templateName, description);
+        // In JSON mode, output success as JSON
+        if (jsonMode) {
+            outputSuccessAsJson({
+                template: {
+                    id: template.id,
+                    name: template.name,
+                    description: template.description,
+                    titlePattern: template.titlePattern,
+                    defaultPriority: template.defaultPriority,
+                    defaultCategory: template.defaultCategory,
+                    defaultStatusId: template.defaultStatusId,
+                    defaultAssignee: template.defaultAssignee,
+                    defaultOwner: template.defaultOwner,
+                    defaultLabels: template.defaultLabels,
+                    suggestedSubtasks: template.suggestedSubtasks,
+                },
+                sourceTicketId: ticketId,
+            }, createMetadata('ticket template save', flags));
+            return;
+        }
         this.log(styles.success(`\nCreated template "${styles.emphasis(template.name)}" from ticket ${ticketId}`));
         this.log(styles.muted(`  ID: ${template.id}`));
         if (template.description) {

package/dist/commands/ticket/update.js

@@ -7,10 +7,10 @@ import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/
 export default class TicketUpdate extends PMOCommand {
     static description = 'Update priority/category for ticket(s)';
     static examples = [
-        '<%= config.bin %> <%= command.id %> TKT-001 --priority HIGH',
+        '<%= config.bin %> <%= command.id %> TKT-001 --priority P1',
         '<%= config.bin %> <%= command.id %> TKT-001 --category bug',
         '<%= config.bin %> <%= command.id %> --bulk',
-        '<%= config.bin %> <%= command.id %> --bulk --priority HIGH',
+        '<%= config.bin %> <%= command.id %> --bulk --priority P1',
         '<%= config.bin %> <%= command.id %> --json  # Output choices as JSON',
     ];
     static args = {

package/dist/commands/work/ready.js

@@ -106,18 +106,18 @@ export default class WorkReady extends PMOCommand {
                 this.error(`Ticket "${ticketId}" not found.`);
             }
             // Get configured column name (from pmo_settings or default)
-            // In Linear-style workflow, "ready" moves ticket to Done (review is implicit via PR)
-            const targetColumnName = getWorkColumnSetting(db, 'done');
+            // "ready" moves ticket to Review column (work complete moves to Done)
+            const targetColumnName = getWorkColumnSetting(db, 'review');
             const board = await this.storage.getBoard(ticket.projectId);
             const columnNames = board.columns.map(col => col.name);
-            const doneColumn = findColumnByName(columnNames, targetColumnName);
-            if (!doneColumn) {
+            const reviewColumn = findColumnByName(columnNames, targetColumnName);
+            if (!reviewColumn) {
                 db.close();
-                this.error(`No "${targetColumnName}" column found in board configuration. Configure with: prlt config set column_done <column-name>`);
+                this.error(`No "${targetColumnName}" column found in board configuration. Configure with: prlt config set column_review <column-name>`);
             }
             const previousColumn = ticket.statusName;
-            // Move to Done column (moveTicket also updates status_id)
-            await this.storage.moveTicket(ticket.projectId, ticketId, doneColumn);
+            // Move to Review column (moveTicket also updates status_id)
+            await this.storage.moveTicket(ticket.projectId, ticketId, reviewColumn);
             // Auto-export to board.md if configured
             await autoExportToBoard(this.pmoPath, this.storage);
             // Mark any running executions for this ticket as completed
@@ -172,7 +172,7 @@ export default class WorkReady extends PMOCommand {
             this.log(styles.success(`Work ready: ${ticketId}`));
             this.log(styles.muted(`   Title: ${ticket.title}`));
             this.log(styles.muted(`   From: ${previousColumn}`));
-            this.log(styles.muted(`   To: ${doneColumn}`));
+            this.log(styles.muted(`   To: ${reviewColumn}`));
             if (prUrl) {
                 this.log(styles.muted(`   PR: ${prUrl}`));
             }

package/dist/commands/work/spawn.js

@@ -119,14 +119,6 @@ export default class WorkSpawn extends PMOCommand {
         const { flags, argv } = await this.parse(WorkSpawn);
         // Check if JSON output mode is active
         const jsonMode = shouldOutputJson(flags);
-        // This command requires project context (pass JSON mode config for AI agents)
-        const projectId = await this.requireProject({
-            jsonMode: {
-                flags,
-                commandName: 'work spawn',
-                baseCommand: 'prlt work spawn',
-            },
-        });
         // Helper to handle errors in JSON mode
         const handleError = (code, message) => {
             if (jsonMode) {
@@ -137,6 +129,38 @@ export default class WorkSpawn extends PMOCommand {
         };
         // Parse ticket IDs from args (everything after flags)
         const ticketIdArgs = argv;
+        // Try to infer project from ticket IDs if provided
+        let projectId;
+        if (ticketIdArgs.length > 0) {
+            // Look up tickets to get their project IDs
+            const projectIds = new Set();
+            for (const ticketId of ticketIdArgs) {
+                // eslint-disable-next-line no-await-in-loop
+                const ticket = await this.storage.getTicket(ticketId);
+                if (ticket?.projectId) {
+                    projectIds.add(ticket.projectId);
+                }
+            }
+            if (projectIds.size === 1) {
+                // All tickets from same project - use that project
+                projectId = [...projectIds][0];
+            }
+            else if (projectIds.size > 1) {
+                // Tickets from multiple projects - warn and require prompt
+                this.warn('Tickets are from multiple projects. Please specify --project.');
+            }
+            // If size === 0, tickets not found - will be handled later in validation
+        }
+        // Only call requireProject() if we couldn't infer from tickets
+        if (!projectId) {
+            projectId = await this.requireProject({
+                jsonMode: {
+                    flags,
+                    commandName: 'work spawn',
+                    baseCommand: 'prlt work spawn',
+                },
+            });
+        }
         // Note: Docker check is handled by work:start command when spawning each ticket
         // This allows for the interactive devcontainer/host selection with retry loop
         // Get workspace info (for agent worktree paths)

package/dist/commands/work/watch.js

@@ -42,11 +42,13 @@ export default class WorkWatch extends PMOCommand {
         limit: Flags.integer({
             char: 'l',
             description: 'Maximum concurrent executions',
+            min: 1,
         }),
         interval: Flags.integer({
             char: 'i',
             description: 'Polling interval in seconds',
             default: 5,
+            min: 1,
         }),
         once: Flags.boolean({
             description: 'Check once and exit (no continuous watching)',

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

@@ -1,4 +1,11 @@
 import { Agent, Repository, MountMode as DBMountMode } from '../database/index.js';
+/**
+ * Format a list of agents for display in error messages.
+ * Truncates long lists to avoid overwhelming output.
+ */
+export declare function formatAgentList(agents: {
+    name: string;
+}[], maxShow?: number): string;
 export interface AgentStatus {
     name: string;
     exists: boolean;

package/dist/lib/agents/commands.js

@@ -9,6 +9,17 @@ import { getWorkspaceConfig, getWorkspaceAgents, getWorkspaceRepositories, getAg
 import { isValidAgentName, getSuggestedAgentNames, generateEphemeralAgentName, getThemePersistentDir, getThemeEphemeralDir, extractBaseName, getAgentBaseName, } from '../themes.js';
 import { createDevcontainerConfig } from '../execution/devcontainer.js';
 import { getPMOContext } from '../pmo/index.js';
+/**
+ * Format a list of agents for display in error messages.
+ * Truncates long lists to avoid overwhelming output.
+ */
+export function formatAgentList(agents, maxShow = 10) {
+    const names = agents.map(a => a.name);
+    if (names.length <= maxShow) {
+        return names.join(', ');
+    }
+    return `${names.slice(0, maxShow).join(', ')} ...and ${names.length - maxShow} more. Run 'prlt agent list' to see all.`;
+}
 /**
  * Find workspace root and return workspace information.
  *

package/dist/lib/agents/index.js

@@ -217,14 +217,15 @@ export async function createAgentWorktrees(workspacePath, agents, hqPath, option
                             }
                         }
                     }
-                    // Create devcontainer config for sandboxed execution (only for repos that were created)
+                    // Create devcontainer config for sandboxed execution
                     // Note: Agent metadata is stored in SQLite (agents table), not in config files
-                    if (!options?.skipDevcontainer && createdRepos.length > 0) {
+                    // Always create devcontainer config (even if no repos were created) so agent rebuild works
+                    if (!options?.skipDevcontainer) {
                         console.log(styles.muted(`  Creating devcontainer config...`));
                         createDevcontainerConfig({
                             agentName: agent,
                             agentDir,
-                            repoWorktrees: mountMode === 'worktree' ? createdRepos : undefined, // Only pass repos for worktree mode
+                            repoWorktrees: mountMode === 'worktree' && createdRepos.length > 0 ? createdRepos : undefined,
                             mountMode,
                         });
                     }
@@ -237,10 +238,19 @@ export async function createAgentWorktrees(workspacePath, agents, hqPath, option
         }
         else {
             console.log(chalk.yellow('No repositories found in HQ. Creating placeholder agent directories.'));
-            // Create placeholder directories for now
+            // Create placeholder directories with devcontainer configs
             for (const agent of agents) {
                 const agentDir = path.join(workspacePath, agent);
                 fs.mkdirSync(agentDir, { recursive: true });
+                // Create devcontainer config even without repos so agent rebuild works
+                if (!options?.skipDevcontainer) {
+                    console.log(styles.muted(`  Creating devcontainer config...`));
+                    createDevcontainerConfig({
+                        agentName: agent,
+                        agentDir,
+                        mountMode: mountMode,
+                    });
+                }
                 console.log(chalk.green(`✅ Placeholder agent ${agent} created`));
             }
         }