@proletariat/cli 0.3.21 → 0.3.22

package/dist/commands/workspace/prune.js

@@ -0,0 +1,186 @@
+import { Command, Flags } from '@oclif/core';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { styles } from '../../lib/styles.js';
+import { getRegisteredHeadquarters, unregisterHeadquarters, } from '../../lib/machine-config.js';
+import { getWorkspaceAgents, removeAgentsFromDatabase, getDatabasePath, } from '../../lib/database/index.js';
+export default class WorkspacePrune extends Command {
+    static description = 'Remove stale workspace entries and agents with deleted worktrees';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --dry-run',
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        'dry-run': Flags.boolean({
+            char: 'd',
+            description: 'Show what would be removed without removing',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output as JSON',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(WorkspacePrune);
+        // Find stale entries
+        const staleWorkspaces = this.findStaleWorkspaces();
+        const staleAgents = this.findStaleAgents();
+        const totalStale = staleWorkspaces.length + staleAgents.length;
+        // JSON output
+        if (flags.json) {
+            const output = {
+                dryRun: flags['dry-run'],
+                staleWorkspaces: staleWorkspaces.map(w => ({
+                    name: w.name,
+                    path: w.path,
+                })),
+                staleAgents: staleAgents.map(a => ({
+                    workspaceName: a.workspaceName,
+                    agentName: a.agentName,
+                    expectedPath: a.expectedPath,
+                })),
+                totalRemoved: flags['dry-run'] ? 0 : totalStale,
+                totalFound: totalStale,
+            };
+            this.log(JSON.stringify(output, null, 2));
+            if (!flags['dry-run'] && totalStale > 0) {
+                this.performPrune(staleWorkspaces, staleAgents);
+            }
+            return;
+        }
+        // Human-readable output
+        this.log(`\n${styles.header('Workspace Prune')}`);
+        this.log('─'.repeat(50));
+        if (totalStale === 0) {
+            this.log(styles.success('\nNo stale entries found.'));
+            return;
+        }
+        // Show stale workspaces
+        if (staleWorkspaces.length > 0) {
+            this.log(styles.subheader('\nStale workspace registrations:'));
+            for (const workspace of staleWorkspaces) {
+                this.log(`  ${styles.removed('×')} ${styles.emphasis(workspace.name)}`);
+                this.log(styles.muted(`    Path no longer exists: ${workspace.path}`));
+            }
+        }
+        // Show stale agents
+        if (staleAgents.length > 0) {
+            this.log(styles.subheader('\nAgents with deleted worktrees:'));
+            // Group by workspace for cleaner output
+            const agentsByWorkspace = new Map();
+            for (const agent of staleAgents) {
+                const list = agentsByWorkspace.get(agent.workspaceName) || [];
+                list.push(agent);
+                agentsByWorkspace.set(agent.workspaceName, list);
+            }
+            for (const [workspaceName, agents] of agentsByWorkspace) {
+                this.log(`  ${styles.muted(`In ${workspaceName}:`)}`);
+                for (const agent of agents) {
+                    this.log(`    ${styles.removed('×')} ${agent.agentName}`);
+                    this.log(styles.muted(`      Expected: ${agent.expectedPath}`));
+                }
+            }
+        }
+        // Summary
+        this.log('');
+        if (flags['dry-run']) {
+            this.log(styles.warning(`[DRY RUN] Would remove:`));
+            if (staleWorkspaces.length > 0) {
+                this.log(styles.muted(`  • ${staleWorkspaces.length} workspace registration(s)`));
+            }
+            if (staleAgents.length > 0) {
+                this.log(styles.muted(`  • ${staleAgents.length} agent record(s)`));
+            }
+            this.log('');
+            this.log(styles.muted('Run without --dry-run to remove these entries.'));
+        }
+        else {
+            // Perform the actual prune
+            this.performPrune(staleWorkspaces, staleAgents);
+            this.log(styles.success('Pruned:'));
+            if (staleWorkspaces.length > 0) {
+                this.log(styles.muted(`  • ${staleWorkspaces.length} workspace registration(s)`));
+            }
+            if (staleAgents.length > 0) {
+                this.log(styles.muted(`  • ${staleAgents.length} agent record(s)`));
+            }
+        }
+        this.log('');
+    }
+    findStaleWorkspaces() {
+        const workspaces = getRegisteredHeadquarters();
+        const stale = [];
+        for (const workspace of workspaces) {
+            if (!fs.existsSync(workspace.path)) {
+                stale.push({
+                    name: workspace.name,
+                    path: workspace.path,
+                });
+            }
+        }
+        return stale;
+    }
+    findStaleAgents() {
+        const workspaces = getRegisteredHeadquarters();
+        const stale = [];
+        for (const workspace of workspaces) {
+            // Skip workspaces that don't exist (handled separately)
+            if (!fs.existsSync(workspace.path)) {
+                continue;
+            }
+            // Skip workspaces without a database
+            const dbPath = getDatabasePath(workspace.path);
+            if (!fs.existsSync(dbPath)) {
+                continue;
+            }
+            try {
+                // Get active agents in this workspace
+                const agents = getWorkspaceAgents(workspace.path, false);
+                for (const agent of agents) {
+                    // Determine expected directory path
+                    let agentDir;
+                    if (agent.worktree_path) {
+                        agentDir = path.join(workspace.path, agent.worktree_path);
+                    }
+                    else if (agent.type === 'ephemeral') {
+                        agentDir = path.join(workspace.path, 'agents', 'temp', agent.name);
+                    }
+                    else {
+                        agentDir = path.join(workspace.path, 'agents', 'staff', agent.name);
+                    }
+                    // If directory doesn't exist, mark as stale
+                    if (!fs.existsSync(agentDir)) {
+                        stale.push({
+                            workspacePath: workspace.path,
+                            workspaceName: workspace.name,
+                            agentName: agent.name,
+                            expectedPath: agentDir,
+                        });
+                    }
+                }
+            }
+            catch {
+                // Skip workspaces where we can't read agents (e.g., database issues)
+                continue;
+            }
+        }
+        return stale;
+    }
+    performPrune(staleWorkspaces, staleAgents) {
+        // Remove stale workspace registrations
+        for (const workspace of staleWorkspaces) {
+            unregisterHeadquarters(workspace.path);
+        }
+        // Remove stale agents, grouped by workspace
+        const agentsByWorkspace = new Map();
+        for (const agent of staleAgents) {
+            const list = agentsByWorkspace.get(agent.workspacePath) || [];
+            list.push(agent.agentName);
+            agentsByWorkspace.set(agent.workspacePath, list);
+        }
+        for (const [workspacePath, agentNames] of agentsByWorkspace) {
+            removeAgentsFromDatabase(workspacePath, agentNames);
+        }
+    }
+}

package/dist/commands/workspace/remove.js

@@ -17,6 +17,8 @@ export default class WorkspaceRemove extends PromptCommand {
     };
     static flags = {
         json: Flags.boolean({
+            char: 'm',
+            aliases: ['machine'],
             description: 'Output prompt configuration as JSON (for AI agents/scripts)',
             default: false,
         }),

package/dist/commands/workspace/use.js

@@ -18,6 +18,8 @@ export default class WorkspaceUse extends PromptCommand {
     };
     static flags = {
         json: Flags.boolean({
+            char: 'm',
+            aliases: ['machine'],
             description: 'Output prompt configuration as JSON (for AI agents/scripts)',
             default: false,
         }),

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

@@ -2,7 +2,7 @@ import { type PMOContext } from './pmo-context.js';
 import { PromptCommand } from '../prompt-command.js';
 import { type JsonFlags } from '../prompt-json.js';
 /**
- * Base flags for JSON/agent mode support (legacy)
+ * Base flags for JSON/agent mode support
  * Include these in your command's flags by spreading: ...jsonModeFlags
  * @deprecated Use machineOutputFlags instead
  */
@@ -12,10 +12,9 @@ export declare const jsonModeFlags: {
 /**
  * Base flags for machine-readable output mode
  * Include these in your command's flags by spreading: ...machineOutputFlags
- * Supports both --machine (new) and --json (legacy, deprecated)
+ * --json is the primary flag, -m/--machine are aliases
  */
 export declare const machineOutputFlags: {
-    machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
 };
 /**
@@ -23,7 +22,6 @@ export declare const machineOutputFlags: {
  * Include these in your command's flags by spreading: ...pmoBaseFlags
  */
 export declare const pmoBaseFlags: {
-    machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
 };

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

@@ -5,31 +5,29 @@ import { styles } from '../styles.js';
 import { PromptCommand } from '../prompt-command.js';
 import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, } from '../prompt-json.js';
 /**
- * Base flags for JSON/agent mode support (legacy)
+ * Base flags for JSON/agent mode support
  * Include these in your command's flags by spreading: ...jsonModeFlags
  * @deprecated Use machineOutputFlags instead
  */
 export const jsonModeFlags = {
     json: Flags.boolean({
-        description: 'Output prompts as JSON for AI agents/scripts',
+        char: 'm',
+        aliases: ['machine'],
+        description: 'Output as JSON for AI agents/scripts',
         default: false,
     }),
 };
 /**
  * Base flags for machine-readable output mode
  * Include these in your command's flags by spreading: ...machineOutputFlags
- * Supports both --machine (new) and --json (legacy, deprecated)
+ * --json is the primary flag, -m/--machine are aliases
  */
 export const machineOutputFlags = {
-    machine: Flags.boolean({
-        char: 'm',
-        description: 'Output as JSON for AI agents/scripts (machine-readable mode)',
-        default: false,
-    }),
     json: Flags.boolean({
-        description: 'Output as JSON (deprecated, use --machine)',
+        char: 'm',
+        aliases: ['machine'],
+        description: 'Output as JSON for AI agents/scripts',
         default: false,
-        hidden: true, // Hide from help since it's deprecated
     }),
 };
 /**

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

@@ -8,6 +8,7 @@ export declare const PMO_TABLES: {
     readonly projects: "pmo_projects";
     readonly initiatives: "pmo_initiatives";
     readonly tickets: "pmo_tickets";
+    readonly categories: "pmo_categories";
     readonly board_views: "pmo_board_views";
     readonly subtasks: "pmo_subtasks";
     readonly ticket_metadata: "pmo_ticket_metadata";
@@ -41,6 +42,7 @@ export declare const PMO_TABLES: {
 export declare const PMO_TABLE_SCHEMAS: {
     readonly projects: "\n    CREATE TABLE IF NOT EXISTS pmo_projects (\n      id TEXT PRIMARY KEY,\n      name TEXT NOT NULL,\n      template TEXT,\n      description TEXT,\n      status TEXT NOT NULL DEFAULT 'active',\n      phase_id TEXT,\n      workflow_id TEXT,\n      is_archived INTEGER NOT NULL DEFAULT 0,\n      target_date TIMESTAMP,\n      initiative_id TEXT,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      FOREIGN KEY (phase_id) REFERENCES pmo_phases(id) ON DELETE SET NULL,\n      FOREIGN KEY (workflow_id) REFERENCES pmo_workflows(id) ON DELETE SET NULL\n    )";
     readonly initiatives: "\n    CREATE TABLE IF NOT EXISTS pmo_initiatives (\n      id TEXT PRIMARY KEY,\n      name TEXT NOT NULL,\n      objective TEXT,\n      key_results TEXT,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP\n    )";
+    readonly categories: "\n    CREATE TABLE IF NOT EXISTS pmo_categories (\n      id TEXT PRIMARY KEY,\n      name TEXT NOT NULL,\n      type TEXT NOT NULL CHECK (type IN ('ticket', 'status')),\n      description TEXT,\n      color TEXT,\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, type)\n    )";
     readonly workflows: "\n    CREATE TABLE IF NOT EXISTS pmo_workflows (\n      id TEXT PRIMARY KEY,\n      name TEXT NOT NULL UNIQUE,\n      description TEXT,\n      is_builtin INTEGER NOT NULL DEFAULT 0,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP\n    )";
     readonly workflow_statuses: "\n    CREATE TABLE IF NOT EXISTS pmo_workflow_statuses (\n      id TEXT PRIMARY KEY,\n      workflow_id TEXT NOT NULL,\n      name TEXT NOT NULL,\n      category TEXT NOT NULL,\n      position INTEGER NOT NULL DEFAULT 0,\n      color TEXT,\n      description TEXT,\n      is_default INTEGER NOT NULL DEFAULT 0,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      FOREIGN KEY (workflow_id) REFERENCES pmo_workflows(id) ON DELETE CASCADE,\n      UNIQUE(workflow_id, name)\n    )";
     readonly columns: "\n    CREATE TABLE IF NOT EXISTS pmo_columns (\n      id TEXT NOT NULL,\n      project_id TEXT NOT NULL DEFAULT 'default',\n      name TEXT NOT NULL,\n      position INTEGER NOT NULL,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      PRIMARY KEY (project_id, id)\n    )";

package/dist/lib/pmo/schema.js

@@ -11,6 +11,7 @@ export const PMO_TABLES = {
     projects: 'pmo_projects',
     initiatives: 'pmo_initiatives',
     tickets: 'pmo_tickets',
+    categories: 'pmo_categories',
     board_views: 'pmo_board_views', // Saved board view configurations
     subtasks: 'pmo_subtasks',
     ticket_metadata: 'pmo_ticket_metadata',
@@ -75,6 +76,19 @@ export const PMO_TABLE_SCHEMAS = {
       created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
       updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
     )`,
+    // Categories for tickets and status types
+    categories: `
+    CREATE TABLE IF NOT EXISTS ${PMO_TABLES.categories} (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      type TEXT NOT NULL CHECK (type IN ('ticket', 'status')),
+      description TEXT,
+      color TEXT,
+      position INTEGER NOT NULL DEFAULT 0,
+      is_builtin INTEGER NOT NULL DEFAULT 0,
+      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+      UNIQUE(name, type)
+    )`,
     // Shared workflow definitions - projects reference these via workflow_id
     workflows: `
     CREATE TABLE IF NOT EXISTS ${PMO_TABLES.workflows} (
@@ -484,6 +498,8 @@ export const PMO_INDEXES = `
   CREATE INDEX IF NOT EXISTS idx_pmo_roadmap_projects_roadmap ON ${PMO_TABLES.roadmap_projects}(roadmap_id);
   CREATE INDEX IF NOT EXISTS idx_pmo_roadmap_projects_project ON ${PMO_TABLES.roadmap_projects}(project_id);
   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);
 `;
 // =============================================================================
 // Combined Schema
@@ -499,6 +515,7 @@ export const PMO_SCHEMA_SQL = [
     PMO_TABLE_SCHEMAS.workflow_statuses, // Workflow statuses (= board columns)
     PMO_TABLE_SCHEMAS.projects,
     PMO_TABLE_SCHEMAS.initiatives,
+    PMO_TABLE_SCHEMAS.categories, // Ticket and status categories
     // PMO_TABLE_SCHEMAS.templates,  // REMOVED: workflows are now used directly
     PMO_TABLE_SCHEMAS.specs, // Must be before tickets (FK reference)
     PMO_TABLE_SCHEMAS.spec_dependencies, // Spec-to-spec dependencies

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

@@ -33,6 +33,10 @@ export declare function seedBuiltinActions(db: Database.Database): void;
  * Seed built-in ticket templates.
  */
 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;
 /**
  * Update board timestamp for a project.
  */

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

@@ -3,6 +3,7 @@
  * This module handles database setup and provides shared utilities.
  */
 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';
 const T = PMO_TABLES;
 /**
@@ -802,6 +803,36 @@ Why is this refactor needed?
         insertTemplate.run(template.id, template.name, template.description || null, template.titlePattern || null, template.descriptionTemplate || null, template.defaultPriority || null, template.defaultCategory || null, null, null, null, '[]', JSON.stringify(template.suggestedSubtasks || []), now);
     }
 }
+/**
+ * Seed built-in categories from TICKET_CATEGORIES and STATE_CATEGORY_ORDER.
+ */
+export function seedBuiltinCategories(db) {
+    const insertCategory = db.prepare(`
+    INSERT OR IGNORE INTO ${T.categories} (id, name, type, description, position, is_builtin, created_at)
+    VALUES (?, ?, ?, ?, ?, 1, ?)
+  `);
+    const now = new Date().toISOString();
+    // Seed ticket categories from TICKET_CATEGORIES
+    for (let i = 0; i < TICKET_CATEGORIES.length; i++) {
+        const category = TICKET_CATEGORIES[i];
+        const id = `ticket-${category}`;
+        insertCategory.run(id, category, 'ticket', null, i, now);
+    }
+    // Seed status categories from STATE_CATEGORY_ORDER
+    const statusCategoryDescriptions = {
+        triage: 'Inbox - needs review before entering workflow',
+        backlog: 'Not yet scheduled for work',
+        unstarted: 'Scheduled but work has not begun',
+        started: 'Work is actively in progress',
+        completed: 'Work finished successfully',
+        canceled: 'Work will not be done',
+    };
+    for (let i = 0; i < STATE_CATEGORY_ORDER.length; i++) {
+        const category = STATE_CATEGORY_ORDER[i];
+        const id = `status-${category}`;
+        insertCategory.run(id, category, 'status', statusCategoryDescriptions[category] || null, i, now);
+    }
+}
 /**
  * Update board timestamp for a project.
  */

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

@@ -0,0 +1,50 @@
+/**
+ * Category operations.
+ * Manages ticket and status categories.
+ */
+import { Category, CategoryFilter, CategoryType } from '../types.js';
+import { StorageContext } from './types.js';
+export declare class CategoryStorage {
+    private ctx;
+    constructor(ctx: StorageContext);
+    /**
+     * List categories.
+     */
+    listCategories(filter?: CategoryFilter): Promise<Category[]>;
+    /**
+     * Get a category by ID.
+     */
+    getCategory(id: string): Promise<Category | null>;
+    /**
+     * Get a category by name and type.
+     */
+    getCategoryByName(name: string, type: CategoryType): Promise<Category | null>;
+    /**
+     * Create a new category.
+     */
+    createCategory(category: Partial<Category> & {
+        name: string;
+        type: CategoryType;
+    }): Promise<Category>;
+    /**
+     * Update a category.
+     */
+    updateCategory(id: string, changes: Partial<Category>): Promise<Category>;
+    /**
+     * Rename a category.
+     */
+    renameCategory(id: string, newName: string): Promise<Category>;
+    /**
+     * Delete a category.
+     */
+    deleteCategory(id: string): Promise<void>;
+    /**
+     * Get category names for a type (for validation and autocomplete).
+     */
+    getCategoryNames(type: CategoryType): Promise<string[]>;
+    /**
+     * Check if a category name is valid for a type.
+     */
+    isValidCategory(name: string, type: CategoryType): Promise<boolean>;
+    private rowToCategory;
+}

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

@@ -0,0 +1,205 @@
+/**
+ * Category operations.
+ * Manages ticket and status categories.
+ */
+import { PMO_TABLES } from '../schema.js';
+import { PMOError } from '../types.js';
+import { slugify } from '../utils.js';
+const T = PMO_TABLES;
+export class CategoryStorage {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /**
+     * List categories.
+     */
+    async listCategories(filter) {
+        let sql = `SELECT * FROM ${T.categories}`;
+        const conditions = [];
+        const params = [];
+        if (filter?.type) {
+            conditions.push('type = ?');
+            params.push(filter.type);
+        }
+        if (filter?.isBuiltin !== undefined) {
+            conditions.push('is_builtin = ?');
+            params.push(filter.isBuiltin ? 1 : 0);
+        }
+        if (filter?.search) {
+            conditions.push('(name LIKE ? OR description LIKE ?)');
+            params.push(`%${filter.search}%`, `%${filter.search}%`);
+        }
+        if (conditions.length > 0) {
+            sql += ` WHERE ${conditions.join(' AND ')}`;
+        }
+        sql += ' ORDER BY type, position ASC, name ASC';
+        const rows = this.ctx.db.prepare(sql).all(...params);
+        return rows.map((row) => this.rowToCategory(row));
+    }
+    /**
+     * Get a category by ID.
+     */
+    async getCategory(id) {
+        const row = this.ctx.db.prepare(`SELECT * FROM ${T.categories} WHERE id = ?`).get(id);
+        if (!row)
+            return null;
+        return this.rowToCategory(row);
+    }
+    /**
+     * Get a category by name and type.
+     */
+    async getCategoryByName(name, type) {
+        const row = this.ctx.db.prepare(`
+      SELECT * FROM ${T.categories} WHERE LOWER(name) = LOWER(?) AND type = ?
+    `).get(name, type);
+        if (!row)
+            return null;
+        return this.rowToCategory(row);
+    }
+    /**
+     * Create a new category.
+     */
+    async createCategory(category) {
+        if (!category.name) {
+            throw new PMOError('INVALID', 'Category name is required');
+        }
+        if (!category.type) {
+            throw new PMOError('INVALID', 'Category type is required');
+        }
+        const id = category.id || slugify(category.name);
+        // Check for duplicate name within the same type
+        const existing = this.ctx.db.prepare(`
+      SELECT id FROM ${T.categories} WHERE LOWER(name) = LOWER(?) AND type = ?
+    `).get(category.name, category.type);
+        if (existing) {
+            throw new PMOError('CONFLICT', `Category "${category.name}" already exists for type "${category.type}"`);
+        }
+        // Get the next position
+        const maxPos = this.ctx.db.prepare(`
+      SELECT MAX(position) as max FROM ${T.categories} WHERE type = ?
+    `).get(category.type);
+        const position = category.position ?? (maxPos.max ?? -1) + 1;
+        const now = new Date().toISOString();
+        this.ctx.db.prepare(`
+      INSERT INTO ${T.categories} (id, name, type, description, color, position, is_builtin, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, category.name, category.type, category.description || null, category.color || null, position, category.isBuiltin ? 1 : 0, now);
+        return {
+            id,
+            name: category.name,
+            type: category.type,
+            description: category.description,
+            color: category.color,
+            position,
+            isBuiltin: category.isBuiltin || false,
+            createdAt: new Date(now),
+        };
+    }
+    /**
+     * Update a category.
+     */
+    async updateCategory(id, changes) {
+        const existing = await this.getCategory(id);
+        if (!existing) {
+            throw new PMOError('NOT_FOUND', `Category not found: ${id}`);
+        }
+        if (existing.isBuiltin) {
+            throw new PMOError('INVALID', 'Cannot modify built-in categories');
+        }
+        // Check for duplicate name if name is changing
+        if (changes.name && changes.name.toLowerCase() !== existing.name.toLowerCase()) {
+            const dup = this.ctx.db.prepare(`
+        SELECT id FROM ${T.categories} WHERE LOWER(name) = LOWER(?) AND type = ? AND id != ?
+      `).get(changes.name, existing.type, id);
+            if (dup) {
+                throw new PMOError('CONFLICT', `Category "${changes.name}" already exists for type "${existing.type}"`);
+            }
+        }
+        const updates = [];
+        const params = [];
+        if (changes.name !== undefined) {
+            updates.push('name = ?');
+            params.push(changes.name);
+        }
+        if (changes.description !== undefined) {
+            updates.push('description = ?');
+            params.push(changes.description || null);
+        }
+        if (changes.color !== undefined) {
+            updates.push('color = ?');
+            params.push(changes.color || null);
+        }
+        if (changes.position !== undefined) {
+            updates.push('position = ?');
+            params.push(changes.position);
+        }
+        if (updates.length > 0) {
+            params.push(id);
+            this.ctx.db.prepare(`UPDATE ${T.categories} SET ${updates.join(', ')} WHERE id = ?`).run(...params);
+        }
+        return (await this.getCategory(id));
+    }
+    /**
+     * Rename a category.
+     */
+    async renameCategory(id, newName) {
+        return this.updateCategory(id, { name: newName });
+    }
+    /**
+     * Delete a category.
+     */
+    async deleteCategory(id) {
+        const existing = await this.getCategory(id);
+        if (!existing) {
+            throw new PMOError('NOT_FOUND', `Category not found: ${id}`);
+        }
+        if (existing.isBuiltin) {
+            throw new PMOError('INVALID', 'Cannot delete built-in categories');
+        }
+        // Check if the category is in use
+        if (existing.type === 'ticket') {
+            const ticketsUsing = this.ctx.db.prepare(`
+        SELECT COUNT(*) as count FROM ${T.tickets} WHERE category = ?
+      `).get(existing.name);
+            if (ticketsUsing.count > 0) {
+                throw new PMOError('INVALID', `Cannot delete category "${existing.name}": ${ticketsUsing.count} ticket(s) are using it. Reassign tickets first.`);
+            }
+        }
+        else if (existing.type === 'status') {
+            const statusesUsing = this.ctx.db.prepare(`
+        SELECT COUNT(*) as count FROM ${T.workflow_statuses} WHERE category = ?
+      `).get(existing.name);
+            if (statusesUsing.count > 0) {
+                throw new PMOError('INVALID', `Cannot delete category "${existing.name}": ${statusesUsing.count} status(es) are using it. Reassign statuses first.`);
+            }
+        }
+        this.ctx.db.prepare(`DELETE FROM ${T.categories} WHERE id = ?`).run(id);
+    }
+    /**
+     * Get category names for a type (for validation and autocomplete).
+     */
+    async getCategoryNames(type) {
+        const categories = await this.listCategories({ type });
+        return categories.map(c => c.name);
+    }
+    /**
+     * Check if a category name is valid for a type.
+     */
+    async isValidCategory(name, type) {
+        const category = await this.getCategoryByName(name, type);
+        return category !== null;
+    }
+    rowToCategory(row) {
+        return {
+            id: row.id,
+            name: row.name,
+            type: row.type,
+            description: row.description || undefined,
+            color: row.color || undefined,
+            position: row.position,
+            isBuiltin: row.is_builtin === 1,
+            createdAt: new Date(row.created_at),
+        };
+    }
+}