@proletariat/cli 0.3.33 → 0.3.35

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

@@ -87,6 +87,7 @@ export interface ExecutionContext {
     actionEndPrompt?: string;
     modifiesCode?: boolean;
     customMessage?: string;
+    useApiKey?: boolean;
     prFeedback?: string;
     isRevision?: boolean;
 }

package/dist/lib/flags/resolver.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-await-in-loop */
 /**
  * FlagResolver - Unified flag resolution for human and machine interactive modes
  *

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

@@ -3,9 +3,8 @@
  */
 import { z } from 'zod';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { CallToolResult, ServerRequest, ServerNotification } from '@modelcontextprotocol/sdk/types.js';
 import type { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.js';
-import type { ServerRequest, ServerNotification } from '@modelcontextprotocol/sdk/types.js';
 import type { Ticket } from '../pmo/types.js';
 import type { McpToolResult } from './types.js';
 /**

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

@@ -1,3 +1,4 @@
+/* eslint-disable no-await-in-loop */
 /**
  * MCP Diet & Pull Tools
  */

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

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

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

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

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

@@ -0,0 +1,6 @@
+/**
+ * MCP Label Tools
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpToolContext } from '../types.js';
+export declare function registerLabelTools(server: McpServer, ctx: McpToolContext): void;

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

@@ -0,0 +1,338 @@
+/**
+ * MCP Label Tools
+ */
+import { z } from 'zod';
+import { errorResponse, strictTool } from '../helpers.js';
+export function registerLabelTools(server, ctx) {
+    // ===========================================================================
+    // Label Group Tools
+    // ===========================================================================
+    strictTool(server, 'label_group_list', 'List all label groups', {
+        search: z.string().optional().describe('Search in name/description'),
+    }, async (params) => {
+        try {
+            const groups = await ctx.storage.listLabelGroups({
+                search: params.search,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            count: groups.length,
+                            groups: groups.map(g => ({
+                                id: g.id,
+                                name: g.name,
+                                description: g.description,
+                                isExclusive: g.isExclusive,
+                                isRequired: g.isRequired,
+                                position: g.position,
+                            })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    strictTool(server, 'label_group_create', 'Create a new label group', {
+        name: z.string().describe('Group name (must be unique)'),
+        description: z.string().optional().describe('Group description'),
+        is_exclusive: z.boolean().optional().describe('Only one label from this group per ticket (default: true)'),
+        is_required: z.boolean().optional().describe('Must have one label from this group (default: false)'),
+    }, async (params) => {
+        try {
+            const group = await ctx.storage.createLabelGroup({
+                name: params.name,
+                description: params.description,
+                isExclusive: params.is_exclusive,
+                isRequired: params.is_required,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            group: {
+                                id: group.id,
+                                name: group.name,
+                                description: group.description,
+                                isExclusive: group.isExclusive,
+                                isRequired: group.isRequired,
+                            },
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    strictTool(server, 'label_group_update', 'Update a label group', {
+        id: z.string().describe('Group ID'),
+        name: z.string().optional().describe('New name'),
+        description: z.string().optional().describe('New description'),
+        is_exclusive: z.boolean().optional().describe('Only one label from this group per ticket'),
+        is_required: z.boolean().optional().describe('Must have one label from this group'),
+    }, async (params) => {
+        try {
+            const changes = {};
+            if (params.name !== undefined)
+                changes.name = params.name;
+            if (params.description !== undefined)
+                changes.description = params.description;
+            if (params.is_exclusive !== undefined)
+                changes.isExclusive = params.is_exclusive;
+            if (params.is_required !== undefined)
+                changes.isRequired = params.is_required;
+            const group = await ctx.storage.updateLabelGroup(params.id, changes);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            group: {
+                                id: group.id,
+                                name: group.name,
+                                description: group.description,
+                                isExclusive: group.isExclusive,
+                                isRequired: group.isRequired,
+                            },
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    strictTool(server, 'label_group_delete', 'Delete a label group (labels in the group become ungrouped)', {
+        id: z.string().describe('Group ID'),
+    }, async (params) => {
+        try {
+            await ctx.storage.deleteLabelGroup(params.id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, message: `Deleted label group ${params.id}` }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    // ===========================================================================
+    // Label Tools
+    // ===========================================================================
+    strictTool(server, 'label_list', 'List all labels, optionally filtered by group', {
+        group: z.string().optional().describe('Filter by group ID'),
+        search: z.string().optional().describe('Search in name/description'),
+    }, async (params) => {
+        try {
+            const labels = await ctx.storage.listLabels({
+                groupId: params.group,
+                search: params.search,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            count: labels.length,
+                            labels: labels.map(l => ({
+                                id: l.id,
+                                name: l.name,
+                                color: l.color,
+                                description: l.description,
+                                groupId: l.groupId,
+                                groupName: l.groupName,
+                                isBuiltin: l.isBuiltin,
+                            })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    strictTool(server, 'label_create', 'Create a new label', {
+        name: z.string().describe('Label name'),
+        color: z.string().optional().describe('Label color (hex, e.g. #ff0000)'),
+        description: z.string().optional().describe('Label description'),
+        group_id: z.string().optional().describe('Label group ID to add this label to'),
+    }, async (params) => {
+        try {
+            const label = await ctx.storage.createLabel({
+                name: params.name,
+                color: params.color,
+                description: params.description,
+                groupId: params.group_id,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            label: {
+                                id: label.id,
+                                name: label.name,
+                                color: label.color,
+                                description: label.description,
+                                groupId: label.groupId,
+                                groupName: label.groupName,
+                            },
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    strictTool(server, 'label_update', 'Update a label (rename, recolor, regroup)', {
+        id: z.string().describe('Label ID'),
+        name: z.string().optional().describe('New name'),
+        color: z.string().optional().describe('New color (hex)'),
+        description: z.string().optional().describe('New description'),
+        group_id: z.string().optional().describe('Move to different group'),
+    }, async (params) => {
+        try {
+            const changes = {};
+            if (params.name !== undefined)
+                changes.name = params.name;
+            if (params.color !== undefined)
+                changes.color = params.color;
+            if (params.description !== undefined)
+                changes.description = params.description;
+            if (params.group_id !== undefined)
+                changes.groupId = params.group_id;
+            const label = await ctx.storage.updateLabel(params.id, changes);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            label: {
+                                id: label.id,
+                                name: label.name,
+                                color: label.color,
+                                description: label.description,
+                                groupId: label.groupId,
+                                groupName: label.groupName,
+                            },
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    strictTool(server, 'label_delete', 'Delete a label (removes from all tickets)', {
+        id: z.string().describe('Label ID'),
+    }, async (params) => {
+        try {
+            await ctx.storage.deleteLabel(params.id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, message: `Deleted label ${params.id}` }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    // ===========================================================================
+    // Ticket-Label Association Tools
+    // ===========================================================================
+    strictTool(server, 'ticket_add_label', 'Add a label to a ticket. For exclusive groups, replaces existing label from same group.', {
+        ticket_id: z.string().describe('Ticket ID'),
+        label: z.string().describe('Label ID or name (supports group:name format)'),
+    }, async (params) => {
+        try {
+            // Try by ID first, then by name
+            const labelById = await ctx.storage.getLabel(params.label);
+            if (labelById) {
+                await ctx.storage.addLabelToTicket(params.ticket_id, labelById.id);
+            }
+            else {
+                await ctx.storage.addLabelToTicketByName(params.ticket_id, params.label);
+            }
+            const labels = await ctx.storage.getLabelsForTicket(params.ticket_id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: `Label added to ${params.ticket_id}`,
+                            labels: labels.map(l => ({
+                                id: l.id,
+                                name: l.name,
+                                groupName: l.groupName,
+                            })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    strictTool(server, 'ticket_remove_label', 'Remove a label from a ticket', {
+        ticket_id: z.string().describe('Ticket ID'),
+        label: z.string().describe('Label ID or name'),
+    }, async (params) => {
+        try {
+            const labelById = await ctx.storage.getLabel(params.label);
+            if (labelById) {
+                await ctx.storage.removeLabelFromTicket(params.ticket_id, labelById.id);
+            }
+            else {
+                await ctx.storage.removeLabelFromTicketByName(params.ticket_id, params.label);
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: `Label removed from ${params.ticket_id}`,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    strictTool(server, 'ticket_labels', 'List all labels on a ticket', {
+        ticket_id: z.string().describe('Ticket ID'),
+    }, async (params) => {
+        try {
+            const labels = await ctx.storage.getLabelsForTicket(params.ticket_id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            count: labels.length,
+                            labels: labels.map(l => ({
+                                id: l.id,
+                                name: l.name,
+                                color: l.color,
+                                groupId: l.groupId,
+                                groupName: l.groupName,
+                            })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+}

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

@@ -14,6 +14,8 @@ 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'),
     }, async (params) => {
         try {
@@ -25,6 +27,8 @@ 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,
             });
             return {
@@ -33,22 +37,26 @@ export function registerTicketTools(server, ctx) {
                         text: JSON.stringify({
                             success: true,
                             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(),
+                            tickets: await Promise.all(tickets.map(async (t) => {
+                                const ticketLabels = await ctx.storage.getLabelsForTicket(t.id);
+                                return {
+                                    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,
+                                    labels: ticketLabels.map(l => ({ id: l.id, name: l.name, groupName: l.groupName })),
+                                    createdAt: t.createdAt.toISOString(),
+                                    updatedAt: t.updatedAt.toISOString(),
+                                };
                             })),
                         }, null, 2),
                     }],
@@ -91,6 +99,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 +133,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/multiline-input.js

@@ -13,16 +13,16 @@
  * });
  * ```
  */
-import * as readline from 'readline';
+import * as readline from 'node:readline';
 import chalk from 'chalk';
 // 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 +60,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
  */

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

@@ -8,14 +8,16 @@ import { type JsonFlags } from '../prompt-json.js';
  */
 export declare const jsonModeFlags: {
     json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
 };
 /**
  * Base flags for machine-readable output mode
  * Include these in your command's flags by spreading: ...machineOutputFlags
- * --json is the primary flag, -m/--machine are aliases
+ * --json and --machine/-m both trigger JSON output mode
  */
 export declare const machineOutputFlags: {
     json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
 };
 /**
  * Base flags shared by all PMO commands
@@ -23,6 +25,7 @@ export declare const machineOutputFlags: {
  */
 export declare const pmoBaseFlags: {
     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>;
 };
 /**
@@ -189,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

@@ -11,8 +11,11 @@ import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata
  */
 export const jsonModeFlags = {
     json: Flags.boolean({
+        description: 'Output as JSON for AI agents/scripts',
+        default: false,
+    }),
+    machine: Flags.boolean({
         char: 'm',
-        aliases: ['machine'],
         description: 'Output as JSON for AI agents/scripts',
         default: false,
     }),
@@ -20,12 +23,15 @@ export const jsonModeFlags = {
 /**
  * Base flags for machine-readable output mode
  * Include these in your command's flags by spreading: ...machineOutputFlags
- * --json is the primary flag, -m/--machine are aliases
+ * --json and --machine/-m both trigger JSON output mode
  */
 export const machineOutputFlags = {
     json: Flags.boolean({
+        description: 'Output as JSON for AI agents/scripts',
+        default: false,
+    }),
+    machine: Flags.boolean({
         char: 'm',
-        aliases: ['machine'],
         description: 'Output as JSON for AI agents/scripts',
         default: false,
     }),
@@ -317,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    )";
 };