@proletariat/cli 0.3.31 → 0.3.32

package/dist/lib/mcp/tools/diet.js

@@ -0,0 +1,261 @@
+/**
+ * MCP Diet & Pull Tools
+ */
+import { z } from 'zod';
+import { errorResponse, strictTool } from '../helpers.js';
+import { loadDietConfig, saveDietConfig, parseDietString, formatDietConfig, } from '../../pmo/diet.js';
+export function registerDietTools(server, ctx) {
+    strictTool(server, 'diet_show', 'Show current diet configuration and distribution report', {
+        project_id: z.string().optional().describe('Project ID (uses default if omitted)'),
+    }, async (params) => {
+        try {
+            const db = ctx.storage.getDatabase();
+            const dietConfig = loadDietConfig(db);
+            const projectId = params.project_id || (await getDefaultProjectId(ctx));
+            const report = await buildDietReport(ctx, projectId, dietConfig);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            diet: formatDietConfig(dietConfig),
+                            ratios: dietConfig.ratios,
+                            report: {
+                                totalReady: report.totalReady,
+                                uncategorized: report.uncategorized,
+                                categories: report.categories,
+                            },
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    strictTool(server, 'diet_set', 'Set diet weights (relative values normalized to percentages automatically)', {
+        ratios: z.string().describe('Diet weights as "category=weight,..." e.g. "ship=4,grow=2.5,support=1.5,bizops=1,strategy=1"'),
+    }, async (params) => {
+        try {
+            const db = ctx.storage.getDatabase();
+            const newConfig = parseDietString(params.ratios);
+            saveDietConfig(db, newConfig);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            diet: formatDietConfig(newConfig),
+                            ratios: newConfig.ratios,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    strictTool(server, 'pull_tickets', 'Pull tickets from Backlog to Ready with diet ratio enforcement', {
+        project_id: z.string().optional().describe('Project ID (uses default if omitted)'),
+        count: z.number().optional().describe('Number of tickets to pull (default 50)'),
+        dry_run: z.boolean().optional().describe('If true, show what would be pulled without moving'),
+    }, async (params) => {
+        try {
+            const db = ctx.storage.getDatabase();
+            const dietConfig = loadDietConfig(db);
+            const projectId = params.project_id || (await getDefaultProjectId(ctx));
+            const count = params.count || 50;
+            const dryRun = params.dry_run || false;
+            const result = await runPull(ctx, projectId, dietConfig, count, dryRun);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            dryRun,
+                            totalCandidates: result.totalCandidates,
+                            skippedBlocked: result.skippedBlocked,
+                            skippedCeiling: result.skippedCeiling,
+                            pulled: result.pulled.map(t => ({
+                                id: t.id,
+                                title: t.title,
+                                category: t.category,
+                                pass: t.pass,
+                            })),
+                            pulledCount: result.pulled.length,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+}
+// =============================================================================
+// Helpers
+// =============================================================================
+async function getDefaultProjectId(ctx) {
+    const projects = await ctx.storage.listProjects();
+    if (projects.length === 0)
+        throw new Error('No projects found');
+    return projects[0].id;
+}
+async function buildDietReport(ctx, projectId, dietConfig) {
+    const project = await ctx.storage.getProject(projectId);
+    if (!project)
+        throw new Error(`Project not found: ${projectId}`);
+    const workflowId = project.workflowId || 'default';
+    const statuses = await ctx.storage.listStatuses(workflowId);
+    const readyStatuses = statuses.filter((s) => s.category === 'unstarted');
+    const readyTickets = [];
+    for (const status of readyStatuses) {
+        const tickets = await ctx.storage.listTickets(projectId, { statusId: status.id });
+        readyTickets.push(...tickets);
+    }
+    const totalReady = readyTickets.length;
+    const categoryCounts = new Map();
+    let uncategorized = 0;
+    for (const ticket of readyTickets) {
+        const cat = (ticket.category || '').toLowerCase();
+        if (cat) {
+            categoryCounts.set(cat, (categoryCounts.get(cat) || 0) + 1);
+        }
+        else {
+            uncategorized++;
+        }
+    }
+    const categories = dietConfig.ratios.map(ratio => {
+        const count = categoryCounts.get(ratio.category) || 0;
+        const actual = totalReady > 0 ? count / totalReady : 0;
+        const targetCount = Math.round(totalReady * ratio.target);
+        const delta = actual - ratio.target;
+        const tolerance = 0.05;
+        let status = 'ok';
+        if (delta > tolerance)
+            status = 'over';
+        else if (delta < -tolerance)
+            status = 'under';
+        return { category: ratio.category, target: ratio.target, actual, count, targetCount, delta, status };
+    });
+    return { categories, totalReady, uncategorized };
+}
+async function runPull(ctx, projectId, dietConfig, targetCount, dryRun) {
+    const project = await ctx.storage.getProject(projectId);
+    if (!project)
+        throw new Error(`Project not found: ${projectId}`);
+    const workflowId = project.workflowId || 'default';
+    const statuses = await ctx.storage.listStatuses(workflowId);
+    const backlogStatuses = statuses.filter((s) => s.category === 'backlog');
+    const readyStatuses = statuses.filter((s) => s.category === 'unstarted');
+    if (backlogStatuses.length === 0)
+        throw new Error('No backlog statuses found');
+    if (readyStatuses.length === 0)
+        throw new Error('No ready/unstarted statuses found');
+    const targetStatus = readyStatuses.sort((a, b) => a.position - b.position)[0];
+    // Get backlog tickets sorted by position
+    const backlogTickets = [];
+    for (const status of backlogStatuses) {
+        const tickets = await ctx.storage.listTickets(projectId, { statusId: status.id });
+        backlogTickets.push(...tickets);
+    }
+    backlogTickets.sort((a, b) => (a.position || 0) - (b.position || 0));
+    // Get existing ready tickets
+    const existingReady = [];
+    for (const status of readyStatuses) {
+        const tickets = await ctx.storage.listTickets(projectId, { statusId: status.id });
+        existingReady.push(...tickets);
+    }
+    // Pull algorithm
+    const pulled = [];
+    let skippedBlocked = 0;
+    let skippedCeiling = 0;
+    const categoryCounts = new Map();
+    for (const ratio of dietConfig.ratios) {
+        categoryCounts.set(ratio.category, 0);
+    }
+    for (const ticket of existingReady) {
+        const cat = (ticket.category || '').toLowerCase();
+        if (cat)
+            categoryCounts.set(cat, (categoryCounts.get(cat) || 0) + 1);
+    }
+    const pulledIds = new Set();
+    const totalTarget = existingReady.length + targetCount;
+    const getCeiling = (category) => {
+        const ratio = dietConfig.ratios.find(r => r.category === category);
+        if (!ratio)
+            return targetCount;
+        return Math.ceil(totalTarget * ratio.target);
+    };
+    // Pass 1
+    const remainingBacklog = [];
+    for (const ticket of backlogTickets) {
+        if (pulled.length >= targetCount)
+            break;
+        const blocked = await ctx.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
+    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;
+                    const blocked = await ctx.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);
+                }
+            }
+        }
+    }
+    // Move tickets if not dry run
+    if (!dryRun) {
+        for (const ticket of pulled) {
+            await ctx.storage.moveTicket(projectId, ticket.id, targetStatus.name);
+        }
+    }
+    return {
+        pulled,
+        skippedBlocked,
+        skippedCeiling,
+        totalCandidates: backlogTickets.length,
+    };
+}

package/dist/lib/mcp/tools/index.d.ts

@@ -15,4 +15,5 @@ export { registerRoadmapTools } from './roadmap.js';
 export { registerCategoryTools } from './category.js';
 export { registerTemplateTools } from './template.js';
 export { registerViewTools } from './view.js';
+export { registerDietTools } from './diet.js';
 export { registerAgentTools, registerDockerTools, registerRepoTools, registerBranchTools, registerGitHubTools, registerInitTools, registerUtilityTools, } from './cli-passthrough.js';

package/dist/lib/mcp/tools/index.js

@@ -15,5 +15,6 @@ export { registerRoadmapTools } from './roadmap.js';
 export { registerCategoryTools } from './category.js';
 export { registerTemplateTools } from './template.js';
 export { registerViewTools } from './view.js';
+export { registerDietTools } from './diet.js';
 // CLI passthrough tools
 export { registerAgentTools, registerDockerTools, registerRepoTools, registerBranchTools, registerGitHubTools, registerInitTools, registerUtilityTools, } from './cli-passthrough.js';

package/dist/lib/mcp/tools/template.js

@@ -49,7 +49,7 @@ export function registerTemplateTools(server, ctx) {
         description: z.string().optional(),
         title_pattern: z.string().optional(),
         description_template: z.string().optional(),
-        default_priority: z.enum(['P0', 'P1', 'P2', 'P3']).optional(),
+        default_priority: z.string().optional().describe('Default priority (uses workspace priority scale)'),
         default_category: z.string().optional(),
     }, async (params) => {
         try {

package/dist/lib/mcp/tools/ticket.js

@@ -3,11 +3,12 @@
  */
 import { z } from 'zod';
 import { formatTicket, formatTicketFull, errorResponse, strictTool } from '../helpers.js';
+import { getWorkspacePriorities, setWorkspacePriorities } from '../../pmo/utils.js';
 export function registerTicketTools(server, ctx) {
     strictTool(server, 'ticket_list', 'List tickets with optional filters', {
         project: z.string().optional().describe('Project ID'),
         column: z.string().optional().describe('Filter by column/status'),
-        priority: z.enum(['P0', 'P1', 'P2', 'P3']).optional().describe('Filter by priority'),
+        priority: z.string().optional().describe('Filter by priority (uses workspace priority scale)'),
         category: z.string().optional().describe('Filter by category'),
         assignee: z.string().optional().describe('Filter by assignee'),
         owner: z.string().optional().describe('Filter by owner'),
@@ -61,7 +62,7 @@ export function registerTicketTools(server, ctx) {
         title: z.string().describe('Ticket title (required)'),
         project: z.string().optional().describe('Project ID'),
         description: z.string().optional().describe('Ticket description'),
-        priority: z.enum(['P0', 'P1', 'P2', 'P3']).optional().describe('Priority'),
+        priority: z.string().optional().describe('Priority (uses workspace priority scale)'),
         category: z.string().optional().describe('Category (feature, bug, etc.)'),
         column: z.string().optional().describe('Column/status name'),
         assignee: z.string().optional().describe('Assignee'),
@@ -121,7 +122,7 @@ export function registerTicketTools(server, ctx) {
         id: z.string().describe('Ticket ID'),
         title: z.string().optional().describe('New title'),
         description: z.string().optional().describe('New description'),
-        priority: z.enum(['P0', 'P1', 'P2', 'P3']).optional().describe('New priority'),
+        priority: z.string().optional().describe('New priority (uses workspace priority scale)'),
         category: z.string().optional().describe('New category'),
         assignee: z.string().optional().describe('New assignee'),
         owner: z.string().optional().describe('New owner'),
@@ -415,4 +416,48 @@ export function registerTicketTools(server, ctx) {
             return errorResponse(error);
         }
     });
+    strictTool(server, 'priority_list', 'List the workspace priority scale (ordered from highest to lowest)', {}, async () => {
+        try {
+            const db = ctx.storage.getDatabase();
+            const priorities = getWorkspacePriorities(db);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, priorities }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    strictTool(server, 'priority_set', 'Set the workspace priority scale (replaces all existing priorities)', {
+        priorities: z.array(z.string()).min(1).describe('Priority values from highest to lowest'),
+    }, async (params) => {
+        try {
+            const db = ctx.storage.getDatabase();
+            // Check for duplicates
+            const seen = new Set();
+            for (const p of params.priorities) {
+                if (seen.has(p))
+                    throw new Error(`Duplicate priority value: "${p}"`);
+                seen.add(p);
+            }
+            const oldPriorities = getWorkspacePriorities(db);
+            setWorkspacePriorities(db, params.priorities);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            previous: oldPriorities,
+                            priorities: params.priorities,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
 }

package/dist/lib/pmo/diet.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Diet configuration for balanced ticket pulling.
+ *
+ * The "diet" defines target ratios for business categories (e.g., ship, grow, support).
+ * Users specify relative weights (e.g., ship=4, grow=2, support=1) which are
+ * normalized to percentages internally. No need to sum to 100.
+ */
+import Database from 'better-sqlite3';
+/**
+ * Diet ratio for a single category.
+ * `weight` is the user-facing relative weight.
+ * `target` is the normalized percentage (0.0-1.0), computed from weights.
+ */
+export interface DietRatio {
+    category: string;
+    weight: number;
+    target: number;
+}
+/**
+ * Full diet configuration.
+ */
+export interface DietConfig {
+    ratios: DietRatio[];
+}
+/**
+ * Diet report for a single category showing actual vs target.
+ */
+export interface DietCategoryReport {
+    category: string;
+    target: number;
+    actual: number;
+    count: number;
+    targetCount: number;
+    delta: number;
+    status: 'over' | 'under' | 'ok';
+}
+/**
+ * Full diet report.
+ */
+export interface DietReport {
+    categories: DietCategoryReport[];
+    totalReady: number;
+    uncategorized: number;
+}
+/**
+ * Result of a pull operation.
+ */
+export interface PullResult {
+    pulled: PulledTicket[];
+    skippedBlocked: number;
+    skippedCeiling: number;
+    totalCandidates: number;
+}
+export interface PulledTicket {
+    id: string;
+    title: string;
+    category: string | undefined;
+    position: number;
+    pass: 'first' | 'second';
+}
+/**
+ * Default diet weights matching the 5-Tool Founder business categories.
+ * Weights: ship=4, grow=2.5, support=1.5, bizops=1, strategy=1
+ * Normalizes to: ship=40%, grow=25%, support=15%, bizops=10%, strategy=10%
+ */
+export declare const DEFAULT_DIET_WEIGHTS: Array<{
+    category: string;
+    weight: number;
+}>;
+export declare const DEFAULT_DIET_CONFIG: DietConfig;
+/**
+ * Normalize an array of category weights into a DietConfig with target percentages.
+ */
+export declare function normalizeWeights(weights: Array<{
+    category: string;
+    weight: number;
+}>): DietConfig;
+/**
+ * Load diet configuration from the database.
+ * Returns default config if none is stored.
+ *
+ * Handles backward compatibility: if stored config has ratios without weights,
+ * reconstructs weights from target percentages.
+ */
+export declare function loadDietConfig(db: Database.Database): DietConfig;
+/**
+ * Save diet configuration to the database.
+ */
+export declare function saveDietConfig(db: Database.Database, config: DietConfig): void;
+/**
+ * Parse a diet string like "ship=4,grow=2.5,support=1.5,bizops=1,strategy=1"
+ * into a DietConfig. Values are relative weights that get normalized internally.
+ */
+export declare function parseDietString(input: string): DietConfig;
+/**
+ * Format a diet config showing weights and computed percentages.
+ */
+export declare function formatDietConfig(config: DietConfig): string;
+/**
+ * Format a diet config showing only the weights (compact form).
+ */
+export declare function formatDietWeights(config: DietConfig): string;

package/dist/lib/pmo/diet.js

@@ -0,0 +1,127 @@
+/**
+ * Diet configuration for balanced ticket pulling.
+ *
+ * The "diet" defines target ratios for business categories (e.g., ship, grow, support).
+ * Users specify relative weights (e.g., ship=4, grow=2, support=1) which are
+ * normalized to percentages internally. No need to sum to 100.
+ */
+import { PMO_TABLES } from './schema.js';
+const T = PMO_TABLES;
+// =============================================================================
+// Default Diet
+// =============================================================================
+/**
+ * Default diet weights matching the 5-Tool Founder business categories.
+ * Weights: ship=4, grow=2.5, support=1.5, bizops=1, strategy=1
+ * Normalizes to: ship=40%, grow=25%, support=15%, bizops=10%, strategy=10%
+ */
+export const DEFAULT_DIET_WEIGHTS = [
+    { category: 'ship', weight: 4 },
+    { category: 'grow', weight: 2.5 },
+    { category: 'support', weight: 1.5 },
+    { category: 'bizops', weight: 1 },
+    { category: 'strategy', weight: 1 },
+];
+export const DEFAULT_DIET_CONFIG = normalizeWeights(DEFAULT_DIET_WEIGHTS);
+// =============================================================================
+// Weight Normalization
+// =============================================================================
+/**
+ * Normalize an array of category weights into a DietConfig with target percentages.
+ */
+export function normalizeWeights(weights) {
+    const totalWeight = weights.reduce((sum, w) => sum + w.weight, 0);
+    if (totalWeight === 0) {
+        throw new Error('Total weight must be greater than 0');
+    }
+    const ratios = weights.map(w => ({
+        category: w.category,
+        weight: w.weight,
+        target: w.weight / totalWeight,
+    }));
+    return { ratios };
+}
+// =============================================================================
+// Diet Storage (pmo_settings table)
+// =============================================================================
+const DIET_CONFIG_KEY = 'diet_config';
+/**
+ * Load diet configuration from the database.
+ * Returns default config if none is stored.
+ *
+ * Handles backward compatibility: if stored config has ratios without weights,
+ * reconstructs weights from target percentages.
+ */
+export function loadDietConfig(db) {
+    try {
+        const row = db.prepare(`SELECT value FROM ${T.settings} WHERE key = ?`).get(DIET_CONFIG_KEY);
+        if (row) {
+            const parsed = JSON.parse(row.value);
+            if (parsed.ratios && Array.isArray(parsed.ratios)) {
+                // Backward compatibility: if weights are missing, reconstruct from targets
+                const needsWeights = parsed.ratios.some(r => r.weight === undefined || r.weight === null);
+                if (needsWeights) {
+                    const weights = parsed.ratios.map(r => ({
+                        category: r.category,
+                        weight: r.weight ?? Math.round(r.target * 100),
+                    }));
+                    return normalizeWeights(weights);
+                }
+                return parsed;
+            }
+        }
+    }
+    catch {
+        // Fall through to default
+    }
+    return DEFAULT_DIET_CONFIG;
+}
+/**
+ * Save diet configuration to the database.
+ */
+export function saveDietConfig(db, config) {
+    db.prepare(`INSERT OR REPLACE INTO ${T.settings} (key, value) VALUES (?, ?)`).run(DIET_CONFIG_KEY, JSON.stringify(config));
+}
+/**
+ * Parse a diet string like "ship=4,grow=2.5,support=1.5,bizops=1,strategy=1"
+ * into a DietConfig. Values are relative weights that get normalized internally.
+ */
+export function parseDietString(input) {
+    const parts = input.split(',').map(s => s.trim()).filter(Boolean);
+    const weights = [];
+    for (const part of parts) {
+        const [category, weightStr] = part.split('=').map(s => s.trim());
+        if (!category || !weightStr) {
+            throw new Error(`Invalid diet entry: "${part}". Expected format: category=weight`);
+        }
+        const weight = Number.parseFloat(weightStr);
+        if (Number.isNaN(weight) || weight < 0) {
+            throw new Error(`Invalid weight for "${category}": ${weightStr}. Must be a non-negative number.`);
+        }
+        weights.push({ category: category.toLowerCase(), weight });
+    }
+    if (weights.length === 0) {
+        throw new Error('At least one category weight is required');
+    }
+    const totalWeight = weights.reduce((sum, w) => sum + w.weight, 0);
+    if (totalWeight === 0) {
+        throw new Error('At least one category must have a weight greater than 0');
+    }
+    return normalizeWeights(weights);
+}
+/**
+ * Format a diet config showing weights and computed percentages.
+ */
+export function formatDietConfig(config) {
+    return config.ratios
+        .map(r => `${r.category}=${r.weight} (${Math.round(r.target * 100)}%)`)
+        .join(', ');
+}
+/**
+ * Format a diet config showing only the weights (compact form).
+ */
+export function formatDietWeights(config) {
+    return config.ratios
+        .map(r => `${r.category}=${r.weight}`)
+        .join(', ');
+}

package/dist/lib/pmo/storage/base.d.ts

@@ -37,6 +37,11 @@ export declare function seedBuiltinTicketTemplates(db: Database.Database): void;
  * Seed built-in categories from TICKET_CATEGORIES and STATE_CATEGORY_ORDER.
  */
 export declare function seedBuiltinCategories(db: Database.Database): void;
+/**
+ * Seed default priorities if not already set.
+ * Preserves any existing user-defined priority scale.
+ */
+export declare function seedDefaultPriorities(db: Database.Database): void;
 /**
  * Update board timestamp for a project.
  */

package/dist/lib/pmo/storage/base.js

@@ -5,6 +5,7 @@
 import { PMO_TABLES, PMO_SCHEMA_SQL, validateTicketSchema } from '../schema.js';
 import { TICKET_CATEGORIES, STATE_CATEGORY_ORDER } from '../types.js';
 import { BUILTIN_TEMPLATES } from '../templates-builtin.js';
+import { getWorkspacePriorities, setWorkspacePriorities, DEFAULT_PRIORITIES } from '../utils.js';
 const T = PMO_TABLES;
 /**
  * Initialize PMO tables in the database.
@@ -18,6 +19,7 @@ export function initializePMOTables(db) {
     seedBuiltinPhaseTemplates(db);
     seedBuiltinActions(db);
     seedBuiltinTicketTemplates(db);
+    seedDefaultPriorities(db); // Seed default priority scale if not set
     validateTicketSchema(db);
 }
 /**
@@ -913,6 +915,20 @@ export function seedBuiltinCategories(db) {
         insertCategory.run(id, category, 'status', statusCategoryDescriptions[category] || null, i, now);
     }
 }
+/**
+ * Seed default priorities if not already set.
+ * Preserves any existing user-defined priority scale.
+ */
+export function seedDefaultPriorities(db) {
+    const existing = getWorkspacePriorities(db);
+    // getWorkspacePriorities returns DEFAULT_PRIORITIES if not set,
+    // but we need to check if it's actually stored in the DB
+    const row = db.prepare(`SELECT value FROM ${T.settings} WHERE key = 'priorities'`).get();
+    if (!row) {
+        // No priorities set yet - seed with defaults
+        setWorkspacePriorities(db, [...DEFAULT_PRIORITIES]);
+    }
+}
 /**
  * Update board timestamp for a project.
  */

package/dist/lib/pmo/types.d.ts

@@ -59,17 +59,23 @@ export interface Epic {
  */
 export type TicketStatus = string;
 /**
- * Standardized priority values: P0 (critical) through P3 (low).
+ * Priority is now a string to support user-defined priority scales.
+ * The workspace's priority scale is stored in pmo_settings.
+ * Use getWorkspacePriorities() from utils.ts to get the current scale.
  */
-export type Priority = 'P0' | 'P1' | 'P2' | 'P3';
+export type Priority = string;
 /**
- * Valid priority values as a const array for validation and CLI options.
+ * Default priority values as a const array.
+ * @deprecated Use getWorkspacePriorities() from utils.ts instead for runtime priority resolution.
+ * This constant is kept for backwards compatibility and as the default when no workspace scale is set.
  */
-export declare const PRIORITIES: readonly Priority[];
+export declare const PRIORITIES: readonly string[];
 /**
- * Priority display names for UI presentation.
+ * Default priority display names for UI presentation.
+ * @deprecated Priority labels are derived from the workspace priority scale.
+ * For user-defined priorities, the label IS the priority value.
  */
-export declare const PRIORITY_LABELS: Record<Priority, string>;
+export declare const PRIORITY_LABELS: Record<string, string>;
 /**
  * Legacy priority values for backwards compatibility.
  */