@proletariat/cli 0.3.34 → 0.3.36

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

@@ -5,7 +5,7 @@ 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', {
+    strictTool(server, 'ticket_list', 'List tickets with optional filters. Returns summary fields only (no descriptions). Use ticket_show for full details.', {
         project: z.string().optional().describe('Project ID'),
         column: z.string().optional().describe('Filter by column/status'),
         priority: z.string().optional().describe('Filter by priority (uses workspace priority scale)'),
@@ -14,10 +14,14 @@ export function registerTicketTools(server, ctx) {
         owner: z.string().optional().describe('Filter by owner'),
         search: z.string().optional().describe('Search in title/description'),
         epic: z.string().optional().describe('Filter by epic ID'),
+        label: z.string().optional().describe('Filter by label name'),
+        label_group: z.string().optional().describe('Filter by label group name'),
         all_projects: z.boolean().optional().describe('List from all projects'),
+        limit: z.number().min(1).optional().describe('Maximum number of tickets to return (default: 50)'),
+        offset: z.number().min(0).optional().describe('Number of tickets to skip for pagination (default: 0)'),
     }, async (params) => {
         try {
-            const tickets = await ctx.storage.listTickets(params.all_projects ? undefined : params.project, {
+            const allTickets = await ctx.storage.listTickets(params.all_projects ? undefined : params.project, {
                 column: params.column,
                 priority: params.priority,
                 category: params.category,
@@ -25,30 +29,36 @@ export function registerTicketTools(server, ctx) {
                 owner: params.owner,
                 search: params.search,
                 epic: params.epic,
+                label: params.label,
+                labelGroup: params.label_group,
                 allProjects: params.all_projects,
             });
+            const total = allTickets.length;
+            const offset = params.offset ?? 0;
+            const limit = params.limit ?? 50;
+            const tickets = allTickets.slice(offset, offset + limit);
             return {
                 content: [{
                         type: 'text',
                         text: JSON.stringify({
                             success: true,
+                            total,
                             count: tickets.length,
-                            tickets: tickets.map((t) => ({
-                                id: t.id,
-                                title: t.title,
-                                description: t.description,
-                                priority: t.priority,
-                                category: t.category,
-                                statusName: t.statusName,
-                                statusCategory: t.statusCategory,
-                                projectId: t.projectId,
-                                assignee: t.assignee,
-                                owner: t.owner,
-                                epicId: t.epicId,
-                                branch: t.branch,
-                                position: t.position,
-                                createdAt: t.createdAt.toISOString(),
-                                updatedAt: t.updatedAt.toISOString(),
+                            offset,
+                            limit,
+                            tickets: await Promise.all(tickets.map(async (t) => {
+                                const ticketLabels = await ctx.storage.getLabelsForTicket(t.id);
+                                return {
+                                    id: t.id,
+                                    title: t.title,
+                                    priority: t.priority,
+                                    category: t.category,
+                                    statusName: t.statusName,
+                                    statusCategory: t.statusCategory,
+                                    assignee: t.assignee,
+                                    position: t.position,
+                                    labels: ticketLabels.map(l => ({ id: l.id, name: l.name, groupName: l.groupName })),
+                                };
                             })),
                         }, null, 2),
                     }],
@@ -91,6 +101,24 @@ export function registerTicketTools(server, ctx) {
                 labels: params.labels,
                 subtasks: params.subtasks?.map((title) => ({ id: '', title, done: false })),
             });
+            // Add structured labels from the labels param via junction table
+            if (params.labels && params.labels.length > 0) {
+                for (const labelName of params.labels) {
+                    try {
+                        // Try to add as structured label (by name or ID)
+                        const labelById = await ctx.storage.getLabel(labelName);
+                        if (labelById) {
+                            await ctx.storage.addLabelToTicket(ticket.id, labelById.id);
+                        }
+                        else {
+                            await ctx.storage.addLabelToTicketByName(ticket.id, labelName);
+                        }
+                    }
+                    catch {
+                        // If label doesn't exist in the label system, it stays only in the legacy JSON array
+                    }
+                }
+            }
             return {
                 content: [{
                         type: 'text',
@@ -107,10 +135,20 @@ export function registerTicketTools(server, ctx) {
             const ticket = await ctx.storage.getTicket(params.id);
             if (!ticket)
                 throw new Error(`Ticket not found: ${params.id}`);
+            const ticketLabels = await ctx.storage.getLabelsForTicket(params.id);
+            const ticketData = formatTicketFull(ticket);
+            // Override labels with structured label data from junction table
+            ticketData.labels = ticketLabels.map(l => ({
+                id: l.id,
+                name: l.name,
+                color: l.color,
+                groupId: l.groupId,
+                groupName: l.groupName,
+            }));
             return {
                 content: [{
                         type: 'text',
-                        text: JSON.stringify({ success: true, ticket: formatTicketFull(ticket) }, null, 2),
+                        text: JSON.stringify({ success: true, ticket: ticketData }, null, 2),
                     }],
             };
         }

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

@@ -3,6 +3,8 @@
  */
 import { z } from 'zod';
 import { formatTicket, errorResponse, strictTool } from '../helpers.js';
+import { spawnAgentForTicket } from '../../execution/spawner.js';
+import { createEphemeralAgent } from '../../agents/commands.js';
 export function registerWorkTools(server, ctx) {
     strictTool(server, 'work_status', 'Get current work status (in-progress tickets)', {}, async () => {
         try {
@@ -31,7 +33,7 @@ export function registerWorkTools(server, ctx) {
             return errorResponse(error);
         }
     });
-    strictTool(server, 'work_start', 'Start working on a ticket (moves to In Progress)', {
+    strictTool(server, 'work_assign', 'Assign a ticket to someone for work preparation (does NOT move to In Progress — use the CLI "work start" command to actually start work with an agent/session)', {
         ticket_id: z.string().describe('Ticket ID'),
         assignee: z.string().optional().describe('Who is working'),
     }, async (params) => {
@@ -42,16 +44,14 @@ export function registerWorkTools(server, ctx) {
             if (params.assignee) {
                 await ctx.storage.updateTicket(params.ticket_id, { assignee: params.assignee });
             }
-            const columns = ctx.storage.getColumnNames(ticket.projectId);
-            const progressCol = columns.find((c) => c.toLowerCase().includes('progress') || c.toLowerCase().includes('doing')) || columns[Math.min(1, columns.length - 1)];
-            const moved = await ctx.storage.moveTicket(ticket.projectId, params.ticket_id, progressCol);
+            const updated = await ctx.storage.getTicket(params.ticket_id);
             return {
                 content: [{
                         type: 'text',
                         text: JSON.stringify({
                             success: true,
-                            ticket: formatTicket(moved),
-                            message: `Started ${moved.id}: ${moved.title}`,
+                            ticket: formatTicket(updated),
+                            message: `Assigned ${updated.id}: ${updated.title}${params.assignee ? ` to ${params.assignee}` : ''}`,
                         }, null, 2),
                     }],
             };
@@ -129,4 +129,94 @@ export function registerWorkTools(server, ctx) {
             return errorResponse(error);
         }
     });
+    strictTool(server, 'work_start', 'Start work on a ticket — spawns an agent with a running container/session, creates a git branch, and moves ticket to In Progress only after successful spawn', {
+        ticket_id: z.string().describe('Ticket ID to start work on'),
+        agent: z.string().optional().describe('Agent name to assign (defaults to creating an ephemeral agent)'),
+        environment: z.enum(['devcontainer', 'host']).optional().describe('Execution environment (default: devcontainer if available)'),
+        display_mode: z.enum(['background', 'terminal']).optional().describe('Display mode (default: background — MCP runs headless)'),
+        skip_permissions: z.boolean().optional().describe('Skip permission prompts (danger mode, default: false)'),
+        create_pr: z.boolean().optional().describe('Create PR when work is ready (default: false)'),
+    }, async (params) => {
+        try {
+            // Require workspace context for spawn operations
+            if (!ctx.getWorkspaceContext) {
+                throw new Error('Workspace not initialized. work_start requires a workspace with agents. Run "prlt init" first.');
+            }
+            const { workspaceInfo, executionStorage, db, pmoPath } = ctx.getWorkspaceContext();
+            // Validate ticket exists
+            const ticket = await ctx.storage.getTicket(params.ticket_id);
+            if (!ticket)
+                throw new Error(`Ticket not found: ${params.ticket_id}`);
+            // Check ticket is not blocked
+            if (ticket.blockedBy && ticket.blockedBy.length > 0) {
+                throw new Error(`Ticket ${ticket.id} is blocked by: ${ticket.blockedBy.join(', ')}. Resolve blockers first.`);
+            }
+            // Check for existing running execution
+            const runningExec = executionStorage.getRunningExecution(ticket.id);
+            if (runningExec) {
+                throw new Error(`Ticket ${ticket.id} already has a running execution: ${runningExec.id} (agent: ${runningExec.agentName})`);
+            }
+            // Select or create agent
+            let agentName;
+            if (params.agent) {
+                // Use specified agent — verify it exists
+                const agentExists = workspaceInfo.agents.some(a => a.name === params.agent);
+                if (!agentExists) {
+                    throw new Error(`Agent "${params.agent}" not found. Available agents: ${workspaceInfo.agents.map(a => a.name).join(', ') || 'none'}`);
+                }
+                agentName = params.agent;
+            }
+            else {
+                // Create an ephemeral agent (default for MCP)
+                const ephemeralResult = await createEphemeralAgent(workspaceInfo);
+                agentName = ephemeralResult.name;
+            }
+            // Spawn the agent with background mode (MCP is headless)
+            const displayMode = params.display_mode || 'background';
+            const environment = params.environment;
+            const result = await spawnAgentForTicket(ticket, agentName, ctx.storage, executionStorage, workspaceInfo, db, pmoPath, {
+                environment,
+                displayMode,
+                skipPermissions: params.skip_permissions ?? false,
+                createPR: params.create_pr ?? false,
+                skipRemoteCheck: false,
+            });
+            if (result.success) {
+                // Fetch updated ticket to return current state
+                const updatedTicket = await ctx.storage.getTicket(params.ticket_id);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                executionId: result.executionId,
+                                ticketId: result.ticketId,
+                                agent: result.agentName,
+                                status: 'running',
+                                ticket: updatedTicket ? formatTicket(updatedTicket) : undefined,
+                                message: `Started work on ${ticket.id}: ${ticket.title} (agent: ${agentName})`,
+                            }, null, 2),
+                        }],
+                };
+            }
+            else {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                ticketId: result.ticketId,
+                                agent: result.agentName,
+                                error: result.error || 'Spawn failed',
+                                message: `Failed to start work on ${ticket.id}: ${result.error}`,
+                            }, null, 2),
+                        }],
+                    isError: true,
+                };
+            }
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
 }

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

@@ -3,9 +3,19 @@
  */
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { SQLiteStorage } from '../pmo/storage/index.js';
+import type Database from 'better-sqlite3';
+import type { WorkspaceInfo } from '../agents/commands.js';
+import type { ExecutionStorage } from '../execution/storage.js';
 export interface McpToolContext {
     storage: SQLiteStorage;
     runCommand: (cmd: string) => string;
+    /** Workspace info — available when running in a workspace with agents */
+    getWorkspaceContext?: () => {
+        workspaceInfo: WorkspaceInfo;
+        executionStorage: ExecutionStorage;
+        db: Database.Database;
+        pmoPath: string;
+    };
 }
 export type McpToolResult = {
     content: Array<{

package/dist/lib/multiline-input.js

@@ -13,16 +13,17 @@
  * });
  * ```
  */
-import * as readline from 'readline';
+import * as readline from 'node:readline';
 import chalk from 'chalk';
+import { isNonTTY } from './prompt-json.js';
 // ANSI escape codes for terminal control
-const ESC = '\x1b';
+const ESC = '\u001B';
 const CSI = `${ESC}[`;
 // Control characters
-const CTRL_C = '\x03';
-const CTRL_D = '\x04';
-const BACKSPACE = '\x7f';
-const DELETE = '\x1b[3~';
+const CTRL_C = '\u0003';
+const CTRL_D = '\u0004';
+const BACKSPACE = '\u007F';
+const DELETE = '\u001B[3~';
 const ENTER = '\r';
 const NEWLINE = '\n';
 // Arrow keys (CSI sequences)
@@ -60,18 +61,6 @@ function moveDown(n) {
 function moveToColumn(col) {
     process.stdout.write(`${CSI}${col + 1}G`);
 }
-/**
- * Clear from cursor to end of screen
- */
-function clearToEnd() {
-    process.stdout.write(`${CSI}J`);
-}
-/**
- * Hide cursor
- */
-function hideCursor() {
-    process.stdout.write(`${CSI}?25l`);
-}
 /**
  * Show cursor
  */
@@ -95,7 +84,7 @@ function showCursor() {
 export async function multiLineInput(options) {
     const { message, default: defaultValue = '', hint = 'Ctrl+D to finish, Ctrl+C to cancel', required = false, validate, } = options;
     // If not a TTY, return the default value
-    if (!process.stdin.isTTY) {
+    if (isNonTTY()) {
         return { value: defaultValue, cancelled: false };
     }
     return new Promise((resolve) => {

package/dist/lib/pmo/base-command.d.ts

@@ -192,7 +192,6 @@ export declare abstract class PMOCommand extends PromptCommand {
      * @param code - Error code for JSON output (e.g., 'NOT_FOUND', 'DOCKER_NOT_RUNNING')
      * @param message - Human-readable error message (used in both modes)
      * @param options - Configuration for error handling
-     * @returns never - always throws or exits
      *
      * @example
      * ```typescript

package/dist/lib/pmo/base-command.js

@@ -3,7 +3,7 @@ import inquirer from 'inquirer';
 import { getPMOContext } from './pmo-context.js';
 import { styles } from '../styles.js';
 import { PromptCommand } from '../prompt-command.js';
-import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, } from '../prompt-json.js';
+import { shouldOutputJson, isNonTTY, outputPromptAsJson, outputErrorAsJson, createMetadata, } from '../prompt-json.js';
 /**
  * Base flags for JSON/agent mode support
  * Include these in your command's flags by spreading: ...jsonModeFlags
@@ -168,7 +168,7 @@ export class PMOCommand extends PromptCommand {
             return numA - numB;
         });
         // Auto-detect non-TTY: switch to JSON mode when no TTY present
-        const effectiveJsonMode = options?.jsonMode ?? (!process.stdin.isTTY
+        const effectiveJsonMode = options?.jsonMode ?? (isNonTTY()
             ? {
                 flags: { json: true },
                 commandName: this.id ?? 'unknown',
@@ -234,7 +234,7 @@ export class PMOCommand extends PromptCommand {
     async selectFromList(options) {
         const { message, items, getName, getValue, getCommand, jsonMode, allowCancel = false, cancelValue, } = options;
         // Auto-detect non-TTY: switch to JSON mode when no TTY present
-        const effectiveJsonMode = jsonMode ?? (!process.stdin.isTTY
+        const effectiveJsonMode = jsonMode ?? (isNonTTY()
             ? { flags: { json: true }, commandName: this.id ?? 'unknown' }
             : null);
         // Build choices with command field
@@ -285,7 +285,7 @@ export class PMOCommand extends PromptCommand {
     async promptForInput(options) {
         const { message, fieldName, defaultValue, validate, jsonMode } = options;
         // Auto-detect non-TTY: switch to JSON mode when no TTY present
-        const effectiveJsonMode = jsonMode ?? (!process.stdin.isTTY
+        const effectiveJsonMode = jsonMode ?? (isNonTTY()
             ? { flags: { json: true }, commandName: this.id ?? 'unknown', commandHint: '', example: undefined }
             : null);
         // Check for JSON mode
@@ -323,7 +323,6 @@ export class PMOCommand extends PromptCommand {
      * @param code - Error code for JSON output (e.g., 'NOT_FOUND', 'DOCKER_NOT_RUNNING')
      * @param message - Human-readable error message (used in both modes)
      * @param options - Configuration for error handling
-     * @returns never - always throws or exits
      *
      * @example
      * ```typescript

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

@@ -35,6 +35,9 @@ export declare const PMO_TABLES: {
     readonly ticket_templates: "pmo_ticket_templates";
     readonly roadmaps: "pmo_roadmaps";
     readonly roadmap_projects: "pmo_roadmap_projects";
+    readonly label_groups: "pmo_label_groups";
+    readonly labels: "pmo_labels";
+    readonly ticket_labels: "pmo_ticket_labels";
     readonly columns: "pmo_columns";
     readonly board_tickets: "pmo_board_tickets";
     readonly statuses: "pmo_statuses";
@@ -71,6 +74,9 @@ export declare const PMO_TABLE_SCHEMAS: {
     readonly phase_templates: "\n    CREATE TABLE IF NOT EXISTS pmo_phase_templates (\n      id TEXT PRIMARY KEY,\n      name TEXT NOT NULL UNIQUE,\n      description TEXT,\n      is_builtin INTEGER NOT NULL DEFAULT 0,\n      phases TEXT NOT NULL,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP\n    )";
     readonly actions: "\n    CREATE TABLE IF NOT EXISTS pmo_actions (\n      id TEXT PRIMARY KEY,\n      name TEXT NOT NULL UNIQUE,\n      description TEXT,\n      prompt TEXT NOT NULL,\n      end_prompt TEXT,\n      suggested_for_categories TEXT,\n      default_move_to_category TEXT,\n      modifies_code INTEGER NOT NULL DEFAULT 1,\n      is_builtin INTEGER NOT NULL DEFAULT 0,\n      position INTEGER NOT NULL DEFAULT 0,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP\n    )";
     readonly ticket_templates: "\n    CREATE TABLE IF NOT EXISTS pmo_ticket_templates (\n      id TEXT PRIMARY KEY,\n      name TEXT NOT NULL UNIQUE,\n      description TEXT,\n      is_builtin INTEGER NOT NULL DEFAULT 0,\n      title_pattern TEXT,\n      description_template TEXT,\n      default_priority TEXT,\n      default_category TEXT,\n      default_status_id TEXT,\n      default_assignee TEXT,\n      default_owner TEXT,\n      default_labels TEXT NOT NULL DEFAULT '[]',\n      suggested_subtasks TEXT NOT NULL DEFAULT '[]',\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP\n    )";
+    readonly label_groups: "\n    CREATE TABLE IF NOT EXISTS pmo_label_groups (\n      id TEXT PRIMARY KEY,\n      name TEXT NOT NULL UNIQUE,\n      description TEXT,\n      is_exclusive INTEGER NOT NULL DEFAULT 1,\n      is_required INTEGER NOT NULL DEFAULT 0,\n      position INTEGER NOT NULL DEFAULT 0,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP\n    )";
+    readonly labels: "\n    CREATE TABLE IF NOT EXISTS pmo_labels (\n      id TEXT PRIMARY KEY,\n      name TEXT NOT NULL,\n      color TEXT,\n      description TEXT,\n      group_id TEXT REFERENCES pmo_label_groups(id) ON DELETE SET NULL,\n      position INTEGER NOT NULL DEFAULT 0,\n      is_builtin INTEGER NOT NULL DEFAULT 0,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      UNIQUE(name, group_id)\n    )";
+    readonly ticket_labels: "\n    CREATE TABLE IF NOT EXISTS pmo_ticket_labels (\n      ticket_id TEXT NOT NULL REFERENCES pmo_tickets(id) ON DELETE CASCADE,\n      label_id TEXT NOT NULL REFERENCES pmo_labels(id) ON DELETE CASCADE,\n      PRIMARY KEY (ticket_id, label_id)\n    )";
     readonly roadmaps: "\n    CREATE TABLE IF NOT EXISTS pmo_roadmaps (\n      id TEXT PRIMARY KEY,\n      name TEXT NOT NULL UNIQUE,\n      description TEXT,\n      is_default INTEGER NOT NULL DEFAULT 0,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP\n    )";
     readonly roadmap_projects: "\n    CREATE TABLE IF NOT EXISTS pmo_roadmap_projects (\n      roadmap_id TEXT NOT NULL REFERENCES pmo_roadmaps(id) ON DELETE CASCADE,\n      project_id TEXT NOT NULL REFERENCES pmo_projects(id) ON DELETE CASCADE,\n      position INTEGER NOT NULL DEFAULT 0,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      PRIMARY KEY (roadmap_id, project_id)\n    )";
 };

package/dist/lib/pmo/schema.js

@@ -41,6 +41,10 @@ export const PMO_TABLES = {
     // Roadmap tables (ordered collections of projects for documentation)
     roadmaps: 'pmo_roadmaps', // Named roadmap definitions
     roadmap_projects: 'pmo_roadmap_projects', // Many-to-many: roadmaps ↔ projects with ordering
+    // Label system tables
+    label_groups: 'pmo_label_groups',
+    labels: 'pmo_labels',
+    ticket_labels: 'pmo_ticket_labels',
     // Legacy tables (deprecated, kept for migration)
     columns: 'pmo_columns', // DEPRECATED: use workflow_statuses
     board_tickets: 'pmo_board_tickets', // DEPRECATED: tickets now use status_id directly
@@ -427,6 +431,37 @@ export const PMO_TABLE_SCHEMAS = {
       suggested_subtasks TEXT NOT NULL DEFAULT '[]',
       created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
     )`,
+    // Label groups (workspace-scoped grouping for labels)
+    label_groups: `
+    CREATE TABLE IF NOT EXISTS ${PMO_TABLES.label_groups} (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL UNIQUE,
+      description TEXT,
+      is_exclusive INTEGER NOT NULL DEFAULT 1,
+      is_required INTEGER NOT NULL DEFAULT 0,
+      position INTEGER NOT NULL DEFAULT 0,
+      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    )`,
+    // Labels (workspace-scoped, optionally grouped)
+    labels: `
+    CREATE TABLE IF NOT EXISTS ${PMO_TABLES.labels} (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      color TEXT,
+      description TEXT,
+      group_id TEXT REFERENCES ${PMO_TABLES.label_groups}(id) ON DELETE SET NULL,
+      position INTEGER NOT NULL DEFAULT 0,
+      is_builtin INTEGER NOT NULL DEFAULT 0,
+      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+      UNIQUE(name, group_id)
+    )`,
+    // Junction table: ticket-label associations (replaces JSON labels field)
+    ticket_labels: `
+    CREATE TABLE IF NOT EXISTS ${PMO_TABLES.ticket_labels} (
+      ticket_id TEXT NOT NULL REFERENCES ${PMO_TABLES.tickets}(id) ON DELETE CASCADE,
+      label_id TEXT NOT NULL REFERENCES ${PMO_TABLES.labels}(id) ON DELETE CASCADE,
+      PRIMARY KEY (ticket_id, label_id)
+    )`,
     // Roadmap definitions (named collections of projects for documentation)
     roadmaps: `
     CREATE TABLE IF NOT EXISTS ${PMO_TABLES.roadmaps} (
@@ -502,6 +537,12 @@ export const PMO_INDEXES = `
   CREATE INDEX IF NOT EXISTS idx_pmo_roadmap_projects_position ON ${PMO_TABLES.roadmap_projects}(roadmap_id, position);
   CREATE INDEX IF NOT EXISTS idx_pmo_categories_type ON ${PMO_TABLES.categories}(type);
   CREATE INDEX IF NOT EXISTS idx_pmo_categories_position ON ${PMO_TABLES.categories}(type, position);
+  CREATE INDEX IF NOT EXISTS idx_pmo_label_groups_position ON ${PMO_TABLES.label_groups}(position);
+  CREATE INDEX IF NOT EXISTS idx_pmo_labels_group ON ${PMO_TABLES.labels}(group_id);
+  CREATE INDEX IF NOT EXISTS idx_pmo_labels_position ON ${PMO_TABLES.labels}(group_id, position);
+  CREATE INDEX IF NOT EXISTS idx_pmo_labels_builtin ON ${PMO_TABLES.labels}(is_builtin);
+  CREATE INDEX IF NOT EXISTS idx_pmo_ticket_labels_ticket ON ${PMO_TABLES.ticket_labels}(ticket_id);
+  CREATE INDEX IF NOT EXISTS idx_pmo_ticket_labels_label ON ${PMO_TABLES.ticket_labels}(label_id);
 `;
 // =============================================================================
 // Combined Schema
@@ -540,6 +581,9 @@ export const PMO_SCHEMA_SQL = [
     PMO_TABLE_SCHEMAS.id_sequences, // Sequence counters for ID generation
     PMO_TABLE_SCHEMAS.actions, // Work actions (reusable agent prompts)
     PMO_TABLE_SCHEMAS.ticket_templates, // Ticket templates for quick creation
+    PMO_TABLE_SCHEMAS.label_groups, // Label groups (before labels for FK)
+    PMO_TABLE_SCHEMAS.labels, // Labels (before ticket_labels for FK)
+    PMO_TABLE_SCHEMAS.ticket_labels, // Ticket-label junction table
     PMO_TABLE_SCHEMAS.roadmaps, // Named roadmap definitions
     PMO_TABLE_SCHEMAS.roadmap_projects, // Roadmap-to-project associations
     // Legacy tables (kept for migration, will be dropped after data migrated)

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

@@ -169,7 +169,7 @@ export class ActionStorage {
                 ? JSON.parse(row.default_category)
                 : undefined,
             defaultMoveToCategory: row.default_category,
-            modifiesCode: row.is_builtin === 1,
+            modifiesCode: row.modifies_code === 1,
             isBuiltin: row.is_builtin === 1,
             createdAt: new Date(row.created_at),
         };

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

@@ -42,6 +42,12 @@ export declare function seedBuiltinCategories(db: Database.Database): void;
  * Preserves any existing user-defined priority scale.
  */
 export declare function seedDefaultPriorities(db: Database.Database): void;
+/**
+ * Seed built-in label groups and labels.
+ * Creates Function, Type, and Area groups with their labels.
+ * Migrates existing ticket category values to Function labels.
+ */
+export declare function seedBuiltinLabels(db: Database.Database): void;
 /**
  * Update board timestamp for a project.
  */