@proletariat/cli 0.3.30 → 0.3.32

package/dist/commands/pull.js

@@ -0,0 +1,219 @@
+import { Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../lib/pmo/base-command.js';
+import { styles, divider } from '../lib/styles.js';
+import { loadDietConfig, formatDietConfig, } from '../lib/pmo/diet.js';
+export default class Pull extends PMOCommand {
+    static description = 'Pull tickets from Backlog to Ready using diet ratio enforcement';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --count 20',
+        '<%= config.bin %> <%= command.id %> --dry-run',
+        '<%= config.bin %> <%= command.id %> --count 50 --dry-run',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        count: Flags.integer({
+            char: 'n',
+            description: 'Number of tickets to pull to Ready',
+            default: 50,
+            min: 1,
+        }),
+        'dry-run': Flags.boolean({
+            char: 'd',
+            description: 'Show what would be pulled without moving tickets',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(Pull);
+        const projectId = await this.requireProject();
+        const count = flags.count;
+        const dryRun = flags['dry-run'];
+        // Load diet config
+        const db = this.storage.getDatabase();
+        const dietConfig = loadDietConfig(db);
+        // Get project workflow statuses to find the target "Ready" status
+        const project = await this.storage.getProject(projectId);
+        if (!project) {
+            this.error(`Project not found: ${projectId}`);
+        }
+        const workflowId = project.workflowId || 'default';
+        const statuses = await this.storage.listStatuses(workflowId);
+        const hasBacklog = statuses.some(s => s.category === 'backlog');
+        const readyStatuses = statuses.filter(s => s.category === 'unstarted');
+        if (!hasBacklog) {
+            this.error('No backlog statuses found in workflow. Cannot pull tickets.');
+        }
+        if (readyStatuses.length === 0) {
+            this.error('No ready/unstarted statuses found in workflow. Cannot pull tickets.');
+        }
+        // Target status is the first unstarted status (Ready/To Do)
+        const targetStatus = readyStatuses.sort((a, b) => a.position - b.position)[0];
+        // Get all backlog tickets ordered by position (using statusCategory filter)
+        const allBacklogTickets = await this.storage.listTickets(projectId, { statusCategory: 'backlog' });
+        allBacklogTickets.sort((a, b) => (a.position || 0) - (b.position || 0));
+        if (allBacklogTickets.length === 0) {
+            this.log(styles.warning('No tickets in backlog to pull.'));
+            return;
+        }
+        // Get existing ready tickets for diet calculation
+        const existingReadyTickets = await this.storage.listTickets(projectId, { statusCategory: 'unstarted' });
+        // Run the pull algorithm
+        const result = await this.runPullAlgorithm(allBacklogTickets, existingReadyTickets, dietConfig, count);
+        // Display results
+        this.displayPullResults(result, dietConfig, targetStatus, dryRun);
+        // Move tickets if not dry-run
+        if (!dryRun && result.pulled.length > 0) {
+            for (const ticket of result.pulled) {
+                // eslint-disable-next-line no-await-in-loop -- Sequential moves to maintain ordering
+                await this.storage.moveTicket(projectId, ticket.id, targetStatus.name);
+            }
+            this.log(styles.success(`\nMoved ${result.pulled.length} ticket${result.pulled.length === 1 ? '' : 's'} to ${targetStatus.name}.`));
+        }
+        else if (dryRun && result.pulled.length > 0) {
+            this.log(styles.warning(`\nDry run: ${result.pulled.length} ticket${result.pulled.length === 1 ? '' : 's'} would be moved to ${targetStatus.name}.`));
+        }
+    }
+    /**
+     * Core pull algorithm with diet enforcement.
+     *
+     * Pass 1: Walk backlog top-down, pull if category not over ceiling
+     * Pass 2: Force-pull from underrepresented categories
+     */
+    async runPullAlgorithm(backlogTickets, existingReadyTickets, dietConfig, targetCount) {
+        const pulled = [];
+        let skippedBlocked = 0;
+        let skippedCeiling = 0;
+        // Build category count map from existing ready tickets
+        const categoryCounts = new Map();
+        for (const ratio of dietConfig.ratios) {
+            categoryCounts.set(ratio.category, 0);
+        }
+        for (const ticket of existingReadyTickets) {
+            const cat = (ticket.category || '').toLowerCase();
+            if (cat) {
+                categoryCounts.set(cat, (categoryCounts.get(cat) || 0) + 1);
+            }
+        }
+        // Track which tickets are pulled (to avoid duplicates in second pass)
+        const pulledIds = new Set();
+        // Calculate ceiling per category (total = existing ready + new pulls)
+        const totalTarget = existingReadyTickets.length + targetCount;
+        const getCeiling = (category) => {
+            const ratio = dietConfig.ratios.find(r => r.category === category);
+            if (!ratio)
+                return targetCount; // No ceiling for uncategorized
+            return Math.ceil(totalTarget * ratio.target);
+        };
+        // Pass 1: Walk backlog top-down, pull if under ceiling
+        const remainingBacklog = [];
+        for (const ticket of backlogTickets) {
+            if (pulled.length >= targetCount)
+                break;
+            // Check if blocked (all blocking dependencies must be completed/canceled)
+            // eslint-disable-next-line no-await-in-loop -- Need sequential dependency check
+            const blocked = await this.storage.isTicketBlocked(ticket.id);
+            if (blocked) {
+                skippedBlocked++;
+                continue;
+            }
+            const cat = (ticket.category || '').toLowerCase();
+            const currentCount = categoryCounts.get(cat) || 0;
+            const ceiling = getCeiling(cat);
+            if (currentCount < ceiling) {
+                pulled.push({
+                    id: ticket.id,
+                    title: ticket.title,
+                    category: ticket.category || undefined,
+                    position: ticket.position || 0,
+                    pass: 'first',
+                });
+                pulledIds.add(ticket.id);
+                categoryCounts.set(cat, currentCount + 1);
+            }
+            else {
+                skippedCeiling++;
+                remainingBacklog.push(ticket);
+            }
+        }
+        // Pass 2: Force-pull from underrepresented categories
+        if (pulled.length < targetCount) {
+            for (const ratio of dietConfig.ratios) {
+                if (pulled.length >= targetCount)
+                    break;
+                const currentCount = categoryCounts.get(ratio.category) || 0;
+                const targetForCat = Math.ceil(totalTarget * ratio.target);
+                if (currentCount < targetForCat) {
+                    const catTickets = remainingBacklog.filter(t => (t.category || '').toLowerCase() === ratio.category && !pulledIds.has(t.id));
+                    for (const ticket of catTickets) {
+                        if (pulled.length >= targetCount)
+                            break;
+                        if ((categoryCounts.get(ratio.category) || 0) >= targetForCat)
+                            break;
+                        // eslint-disable-next-line no-await-in-loop -- Sequential dependency check
+                        const blocked = await this.storage.isTicketBlocked(ticket.id);
+                        if (blocked)
+                            continue;
+                        pulled.push({
+                            id: ticket.id,
+                            title: ticket.title,
+                            category: ticket.category || undefined,
+                            position: ticket.position || 0,
+                            pass: 'second',
+                        });
+                        pulledIds.add(ticket.id);
+                        categoryCounts.set(ratio.category, (categoryCounts.get(ratio.category) || 0) + 1);
+                    }
+                }
+            }
+        }
+        return {
+            pulled,
+            skippedBlocked,
+            skippedCeiling,
+            totalCandidates: backlogTickets.length,
+        };
+    }
+    /**
+     * Display pull results.
+     */
+    displayPullResults(result, dietConfig, targetStatus, dryRun) {
+        const prefix = dryRun ? '[DRY RUN] ' : '';
+        this.log(styles.title(`\n${prefix}Pull Results`));
+        this.log(divider(60));
+        // Summary stats
+        this.log(`  Backlog candidates: ${result.totalCandidates}`);
+        this.log(`  Skipped (blocked):  ${result.skippedBlocked}`);
+        this.log(`  Skipped (ceiling):  ${result.skippedCeiling}`);
+        this.log(`  ${dryRun ? 'Would pull' : 'Pulling'}:       ${styles.emphasis(String(result.pulled.length))}`);
+        this.log(`  Target status:      ${targetStatus.name}`);
+        this.log(`  Diet:               ${formatDietConfig(dietConfig)}`);
+        this.log(divider(60));
+        if (result.pulled.length === 0) {
+            this.log(styles.warning('\nNo tickets to pull.'));
+            return;
+        }
+        // Group by category for display
+        const byCategory = new Map();
+        for (const ticket of result.pulled) {
+            const cat = ticket.category || 'uncategorized';
+            if (!byCategory.has(cat)) {
+                byCategory.set(cat, []);
+            }
+            byCategory.get(cat).push(ticket);
+        }
+        // Display by category
+        for (const [category, tickets] of byCategory) {
+            const ratio = dietConfig.ratios.find(r => r.category === category);
+            const targetPct = ratio ? `${Math.round(ratio.target * 100)}%` : 'n/a';
+            const actualPct = result.pulled.length > 0
+                ? `${Math.round((tickets.length / result.pulled.length) * 100)}%`
+                : '0%';
+            this.log(`\n  ${styles.emphasis(category)} (${tickets.length} tickets, target: ${targetPct}, actual: ${actualPct})`);
+            for (const ticket of tickets) {
+                const passLabel = ticket.pass === 'second' ? styles.warning(' [force-pull]') : '';
+                this.log(`    ${styles.code(ticket.id)} ${ticket.title}${passLabel}`);
+            }
+        }
+    }
+}

package/dist/commands/roadmap/generate.js

@@ -4,7 +4,8 @@ import * as path from 'node:path';
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
 import { styles } from '../../lib/styles.js';
 import { slugify } from '../../lib/pmo/utils.js';
-import { normalizePriority, PRIORITIES } from '../../lib/pmo/types.js';
+import { normalizePriority } from '../../lib/pmo/types.js';
+import { getWorkspacePriorities } from '../../lib/pmo/utils.js';
 import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
 export default class RoadmapGenerate extends PMOCommand {
     static description = 'Generate roadmap markdown file';
@@ -125,9 +126,11 @@ export default class RoadmapGenerate extends PMOCommand {
             const filteredTickets = excludeDone
                 ? tickets.filter(t => t.statusCategory !== 'completed')
                 : tickets;
-            // Group tickets by priority
+            // Group tickets by priority (using workspace priority scale)
+            const db = this.storage.getDatabase();
+            const workspacePriorities = getWorkspacePriorities(db);
             const ticketsByPriority = new Map();
-            for (const priority of PRIORITIES) {
+            for (const priority of workspacePriorities) {
                 ticketsByPriority.set(priority, []);
             }
             ticketsByPriority.set('unset', []);
@@ -181,13 +184,15 @@ export default class RoadmapGenerate extends PMOCommand {
         this.log(styles.success(`Generated ${filePath}`));
     }
     getPriorityLabel(priority) {
-        const labels = {
+        // For well-known P0-P3 priorities, provide descriptive labels
+        const defaultLabels = {
             'P0': 'Critical',
             'P1': 'High',
             'P2': 'Medium',
             'P3': 'Low',
         };
-        return labels[priority] || priority;
+        // For user-defined priorities, the value IS the label
+        return defaultLabels[priority] || priority;
     }
     cleanForTable(text) {
         return (text || '').replace(/\|/g, '-').replace(/\n/g, ' ').replace(/\r/g, '').trim();

package/dist/commands/template/apply.js

@@ -1,6 +1,6 @@
 import { Flags, Args } from '@oclif/core';
 import { PMOCommand, pmoBaseFlags, autoExportToBoard } from '../../lib/pmo/index.js';
-import { PRIORITIES, PRIORITY_LABELS } from '../../lib/pmo/types.js';
+import { getWorkspacePriorities } from '../../lib/pmo/utils.js';
 import { styles } from '../../lib/styles.js';
 import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildFormPromptConfig, buildPromptConfig, } from '../../lib/prompt-json.js';
 export default class TemplateApply extends PMOCommand {
@@ -34,8 +34,7 @@ export default class TemplateApply extends PMOCommand {
         }),
         priority: Flags.string({
             char: 'p',
-            description: 'Priority override (ticket only)',
-            options: [...PRIORITIES],
+            description: 'Priority override (ticket only, uses workspace priority scale)',
         }),
         category: Flags.string({
             description: 'Category override (ticket only)',
@@ -149,10 +148,12 @@ export default class TemplateApply extends PMOCommand {
         const labels = template.defaultLabels;
         // Interactive mode
         if (flags.interactive || !title) {
+            const db = this.storage.getDatabase();
+            const workspacePriorities = getWorkspacePriorities(db);
             const fields = [
                 { type: 'input', name: 'title', message: 'Title:', default: title || undefined },
                 { type: 'list', name: 'column', message: 'Column:', choices: columns.map(c => ({ name: c, value: c })), default: column },
-                { type: 'list', name: 'priority', message: 'Priority:', choices: [{ name: 'None', value: '' }, ...PRIORITIES.map(p => ({ name: PRIORITY_LABELS[p], value: p }))], default: priority },
+                { type: 'list', name: 'priority', message: 'Priority:', choices: [{ name: 'None', value: '' }, ...workspacePriorities.map(p => ({ name: p, value: p }))], default: priority },
             ];
             if (jsonMode) {
                 outputPromptAsJson(buildFormPromptConfig(fields), createMetadata('template apply', flags));

package/dist/commands/template/create.js

@@ -1,6 +1,7 @@
 import { Args, Flags } from '@oclif/core';
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
-import { PRIORITIES, PRIORITY_LABELS, TICKET_CATEGORIES } from '../../lib/pmo/types.js';
+import { TICKET_CATEGORIES } from '../../lib/pmo/types.js';
+import { getWorkspacePriorities } from '../../lib/pmo/utils.js';
 import { styles } from '../../lib/styles.js';
 import { shouldOutputJson, outputSuccessAsJson, outputPromptAsJson, outputErrorAsJson, buildFormPromptConfig, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
 export default class TemplateCreate extends PMOCommand {
@@ -37,8 +38,7 @@ export default class TemplateCreate extends PMOCommand {
         }),
         priority: Flags.string({
             char: 'p',
-            description: 'Default priority (ticket only)',
-            options: [...PRIORITIES],
+            description: 'Default priority (ticket only, uses workspace priority scale)',
         }),
         category: Flags.string({
             char: 'c',
@@ -103,6 +103,8 @@ export default class TemplateCreate extends PMOCommand {
         // Check if we have required data
         if (!name) {
             if (jsonMode) {
+                const db = this.storage.getDatabase();
+                const workspacePriorities = getWorkspacePriorities(db);
                 const fields = [
                     { type: 'input', name: 'name', message: 'Template name:' },
                     { type: 'input', name: 'description', message: 'Description (optional):' },
@@ -112,7 +114,7 @@ export default class TemplateCreate extends PMOCommand {
                         message: 'Default priority:',
                         choices: [
                             { name: 'None', value: '' },
-                            ...PRIORITIES.map(p => ({ name: PRIORITY_LABELS[p], value: p })),
+                            ...workspacePriorities.map(p => ({ name: p, value: p })),
                         ],
                     },
                     {
@@ -154,13 +156,15 @@ export default class TemplateCreate extends PMOCommand {
             description = desc || undefined;
         }
         if (!jsonMode && priority === undefined) {
+            const db = this.storage.getDatabase();
+            const workspacePriorities = getWorkspacePriorities(db);
             const { p } = await this.prompt([{
                     type: 'list',
                     name: 'p',
                     message: 'Default priority:',
                     choices: [
                         { name: 'None', value: '' },
-                        ...PRIORITIES.map(pr => ({ name: PRIORITY_LABELS[pr], value: pr })),
+                        ...workspacePriorities.map(pr => ({ name: pr, value: pr })),
                     ],
                 }], null);
             priority = p || undefined;

package/dist/commands/ticket/create.js

@@ -5,7 +5,7 @@ import { autoExportToBoard, PMOCommand, pmoBaseFlags } from '../../lib/pmo/index
 // Note: inquirer import kept for inquirer.Separator usage in interactive mode
 import { styles } from '../../lib/styles.js';
 import { updateEpicTicketsSection } from '../../lib/pmo/epic-files.js';
-import { PRIORITIES, PRIORITY_LABELS } from '../../lib/pmo/types.js';
+import { getWorkspacePriorities } from '../../lib/pmo/utils.js';
 import { shouldOutputJson, outputErrorAsJson, outputDryRunSuccessAsJson, outputDryRunErrorsAsJson, createMetadata, } from '../../lib/prompt-json.js';
 import { FlagResolver } from '../../lib/flags/index.js';
 import { multiLineInput } from '../../lib/multiline-input.js';
@@ -40,8 +40,7 @@ export default class TicketCreate extends PMOCommand {
         }),
         priority: Flags.string({
             char: 'p',
-            description: 'Ticket priority',
-            options: [...PRIORITIES],
+            description: 'Ticket priority (uses workspace priority scale)',
         }),
         category: Flags.string({
             description: 'Ticket category (e.g., bug, feature, refactor)',
@@ -361,7 +360,9 @@ export default class TicketCreate extends PMOCommand {
                 default: flags.column || columns[0],
             },
         ], null);
-        // Prompt for priority
+        // Prompt for priority (using workspace priority scale)
+        const db = this.storage.getDatabase();
+        const workspacePriorities = getWorkspacePriorities(db);
         const { priority: answerPriority } = await this.prompt([
             {
                 type: 'list',
@@ -369,7 +370,7 @@ export default class TicketCreate extends PMOCommand {
                 message: 'Priority:',
                 choices: [
                     { name: 'None', value: undefined },
-                    ...PRIORITIES.map(p => ({ name: PRIORITY_LABELS[p], value: p })),
+                    ...workspacePriorities.map(p => ({ name: p, value: p })),
                 ],
                 default: flags.priority || template?.defaultPriority,
             },

package/dist/commands/ticket/edit.js

@@ -1,7 +1,7 @@
 import { Args, Flags } from '@oclif/core';
 import inquirer from 'inquirer';
 import { autoExportToBoard, PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
-import { PRIORITIES, PRIORITY_LABELS } from '../../lib/pmo/types.js';
+import { getWorkspacePriorities } from '../../lib/pmo/utils.js';
 import { styles } from '../../lib/styles.js';
 import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
 import { multiLineInput } from '../../lib/multiline-input.js';
@@ -33,8 +33,7 @@ export default class TicketEdit extends PMOCommand {
         }),
         priority: Flags.string({
             char: 'p',
-            description: 'New ticket priority',
-            options: [...PRIORITIES, 'none'],
+            description: 'New ticket priority (uses workspace priority scale, "none" to clear)',
         }),
         category: Flags.string({
             description: 'New ticket category',
@@ -132,15 +131,14 @@ export default class TicketEdit extends PMOCommand {
             // In JSON mode without flags, output a form prompt instead of interactive prompts
             if (jsonMode) {
                 const { outputPromptAsJson, buildFormPromptConfig } = await import('../../lib/prompt-json.js');
+                const db = this.storage.getDatabase();
+                const workspacePriorities = getWorkspacePriorities(db);
                 const formConfig = buildFormPromptConfig([
                     { type: 'input', name: 'title', message: 'Title:', default: ticket.title },
                     { type: 'multiline', name: 'description', message: 'Description:', default: ticket.description || '' },
                     { type: 'list', name: 'priority', message: 'Priority:', choices: [
                             { name: 'None', value: '' },
-                            { name: 'P0 - Critical', value: 'P0' },
-                            { name: 'P1 - High', value: 'P1' },
-                            { name: 'P2 - Medium', value: 'P2' },
-                            { name: 'P3 - Low', value: 'P3' },
+                            ...workspacePriorities.map(p => ({ name: p, value: p })),
                         ], default: ticket.priority || '' },
                     { type: 'input', name: 'category', message: 'Category:', default: ticket.category || '' },
                 ]);
@@ -287,7 +285,9 @@ export default class TicketEdit extends PMOCommand {
         if (descResult.cancelled) {
             throw new Error('Edit cancelled');
         }
-        // Continue with remaining prompts - priority first
+        // Continue with remaining prompts - priority first (using workspace scale)
+        const db = this.storage.getDatabase();
+        const workspacePriorities = getWorkspacePriorities(db);
         const { priority } = await this.prompt([
             {
                 type: 'list',
@@ -295,7 +295,7 @@ export default class TicketEdit extends PMOCommand {
                 message: 'Priority:',
                 choices: [
                     { name: 'None', value: '' },
-                    ...PRIORITIES.map(p => ({ name: PRIORITY_LABELS[p], value: p })),
+                    ...workspacePriorities.map(p => ({ name: p, value: p })),
                 ],
                 default: ticket.priority || '',
             },

package/dist/commands/ticket/list.d.ts

@@ -1,6 +1,8 @@
 import { Command } from '@oclif/core';
 export default class TicketList extends Command {
     static description: string;
+    /** Dynamic priority order (set from workspace settings in run()) */
+    private priorityOrder;
     static examples: string[];
     static flags: {
         column: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;

package/dist/commands/ticket/list.js

@@ -1,13 +1,19 @@
 import { Command, Flags } from '@oclif/core';
 import { pmoBaseFlags } from '../../lib/pmo/index.js';
-import { PRIORITIES } from '../../lib/pmo/types.js';
+import { getWorkspacePriorities } from '../../lib/pmo/utils.js';
 import { getPMOContext } from '../../lib/pmo/pmo-context.js';
 import { styles, formatPriority, formatCategory, getColumnStyle, getColumnEmoji, divider, getPriorityStyle, } from '../../lib/styles.js';
 import { isNonTTY } from '../../lib/prompt-json.js';
-// Priority order for grouping: P0, P1, P2, P3, None
-const PRIORITY_ORDER = ['P0', 'P1', 'P2', 'P3', 'None'];
+// Priority order for grouping - dynamically resolved from workspace settings
+// Computed at runtime and includes 'None' for unset priorities
+function getPriorityOrder(db) {
+    const priorities = getWorkspacePriorities(db);
+    return [...priorities, 'None'];
+}
 export default class TicketList extends Command {
     static description = 'List tickets from the PMO board';
+    /** Dynamic priority order (set from workspace settings in run()) */
+    priorityOrder = ['P0', 'P1', 'P2', 'P3', 'None'];
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --column Backlog',
@@ -29,8 +35,7 @@ export default class TicketList extends Command {
         }),
         priority: Flags.string({
             char: 'p',
-            description: 'Filter by priority',
-            options: [...PRIORITIES],
+            description: 'Filter by priority (uses workspace priority scale)',
         }),
         category: Flags.string({
             description: 'Filter by category',
@@ -79,6 +84,8 @@ export default class TicketList extends Command {
             logger: (msg) => this.log(styles.muted(msg)),
         });
         try {
+            // Set dynamic priority order from workspace settings
+            this.priorityOrder = getPriorityOrder(pmoContext.storage.getDatabase());
             // Build filter
             const filter = {};
             if (flags.all) {
@@ -239,7 +246,7 @@ export default class TicketList extends Command {
     outputCrossProjectTableByPriority(tickets) {
         // Group tickets by priority
         const byPriority = {};
-        for (const priority of PRIORITY_ORDER) {
+        for (const priority of this.priorityOrder) {
             byPriority[priority] = [];
         }
         for (const ticket of tickets) {
@@ -249,7 +256,7 @@ export default class TicketList extends Command {
             }
             byPriority[priority].push(ticket);
         }
-        for (const priority of PRIORITY_ORDER) {
+        for (const priority of this.priorityOrder) {
             const priorityTickets = byPriority[priority];
             // Priority header
             const headerColor = getPriorityStyle(priority);
@@ -305,7 +312,7 @@ export default class TicketList extends Command {
     outputCrossProjectCompactByPriority(tickets) {
         // Group tickets by priority
         const byPriority = {};
-        for (const priority of PRIORITY_ORDER) {
+        for (const priority of this.priorityOrder) {
             byPriority[priority] = [];
         }
         for (const ticket of tickets) {
@@ -315,7 +322,7 @@ export default class TicketList extends Command {
             }
             byPriority[priority].push(ticket);
         }
-        for (const priority of PRIORITY_ORDER) {
+        for (const priority of this.priorityOrder) {
             const priorityTickets = byPriority[priority];
             if (priorityTickets.length === 0)
                 continue;
@@ -380,7 +387,7 @@ export default class TicketList extends Command {
     outputTableByPriority(tickets) {
         // Group tickets by priority
         const byPriority = {};
-        for (const priority of PRIORITY_ORDER) {
+        for (const priority of this.priorityOrder) {
             byPriority[priority] = [];
         }
         for (const ticket of tickets) {
@@ -391,7 +398,7 @@ export default class TicketList extends Command {
             byPriority[priority].push(ticket);
         }
         // Display ALL priority groups
-        for (const priority of PRIORITY_ORDER) {
+        for (const priority of this.priorityOrder) {
             const priorityTickets = byPriority[priority];
             // Priority header with color
             const headerColor = getPriorityStyle(priority);
@@ -457,7 +464,7 @@ export default class TicketList extends Command {
     outputCompactByPriority(tickets) {
         // Group by priority
         const byPriority = {};
-        for (const priority of PRIORITY_ORDER) {
+        for (const priority of this.priorityOrder) {
             byPriority[priority] = [];
         }
         for (const ticket of tickets) {
@@ -467,7 +474,7 @@ export default class TicketList extends Command {
             }
             byPriority[priority].push(ticket);
         }
-        for (const priority of PRIORITY_ORDER) {
+        for (const priority of this.priorityOrder) {
             const priorityTickets = byPriority[priority];
             // Show all priority groups
             const headerColor = getPriorityStyle(priority);

package/dist/commands/ticket/update.js

@@ -1,6 +1,6 @@
 import { Args, Flags } from '@oclif/core';
 import { PMOCommand, pmoBaseFlags, autoExportToBoard } from '../../lib/pmo/index.js';
-import { PRIORITIES, PRIORITY_LABELS } from '../../lib/pmo/types.js';
+import { getWorkspacePriorities } from '../../lib/pmo/utils.js';
 import { styles } from '../../lib/styles.js';
 import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
 export default class TicketUpdate extends PMOCommand {
@@ -28,8 +28,7 @@ export default class TicketUpdate extends PMOCommand {
         }),
         priority: Flags.string({
             char: 'p',
-            description: 'Set priority (P0, P1, P2, P3)',
-            options: [...PRIORITIES],
+            description: 'Set priority (uses workspace priority scale)',
         }),
         category: Flags.string({
             char: 'c',
@@ -104,13 +103,15 @@ export default class TicketUpdate extends PMOCommand {
                     ],
                 }], jsonModeConfig);
             if (updateType === 'priority' || updateType === 'both') {
+                const db = this.storage.getDatabase();
+                const workspacePriorities = getWorkspacePriorities(db);
                 const { priority } = await this.prompt([{
                         type: 'list',
                         name: 'priority',
                         message: 'Set priority to:',
                         choices: [
                             { name: `(Keep existing: ${ticket.priority || 'none'})`, value: null, command: '' },
-                            ...PRIORITIES.map(p => ({ name: PRIORITY_LABELS[p], value: p, command: `prlt ticket update ${ticketId} --priority ${p}${projectId ? ` -P ${projectId}` : ''} --json` })),
+                            ...workspacePriorities.map(p => ({ name: p, value: p, command: `prlt ticket update ${ticketId} --priority ${p}${projectId ? ` -P ${projectId}` : ''} --json` })),
                             { name: 'None (clear priority)', value: '', command: `prlt ticket update ${ticketId} --priority none${projectId ? ` -P ${projectId}` : ''} --json` },
                         ],
                     }], jsonModeConfig);
@@ -208,13 +209,15 @@ export default class TicketUpdate extends PMOCommand {
                     ],
                 }], jsonModeConfig);
             if (updateType === 'priority' || updateType === 'both') {
+                const db = this.storage.getDatabase();
+                const bulkWorkspacePriorities = getWorkspacePriorities(db);
                 const { priority } = await this.prompt([{
                         type: 'list',
                         name: 'priority',
                         message: 'Set priority to:',
                         choices: [
                             { name: '(Keep existing)', value: null, command: '' },
-                            ...PRIORITIES.map(p => ({ name: PRIORITY_LABELS[p], value: p, command: `prlt ticket update --bulk --priority ${p} --json` })),
+                            ...bulkWorkspacePriorities.map(p => ({ name: p, value: p, command: `prlt ticket update --bulk --priority ${p} --json` })),
                             { name: 'None (clear priority)', value: '', command: 'prlt ticket update --bulk --priority none --json' },
                         ],
                     }], jsonModeConfig);

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

@@ -26,7 +26,20 @@ export default class WorkSpawn extends PMOCommand {
         session: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         focus: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         clone: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        count: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        diet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        category: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        priority: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        epic: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        status: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     execute(): Promise<void>;
+    /**
+     * Select tickets using diet-balanced category weighting.
+     * Uses a two-pass algorithm:
+     * Pass 1: Walk candidates in position order, pull if category not over ceiling.
+     * Pass 2: Force-pull from underrepresented categories.
+     */
+    private selectDietBalanced;
 }