@proletariat/cli 0.3.20 → 0.3.22

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),
+        };
+    }
+}

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

@@ -4,7 +4,7 @@
 import { PMO_TABLES } from '../schema.js';
 import { PMOError } from '../types.js';
 import { generateEntityId } from '../utils.js';
-import { rowToTicket } from './helpers.js';
+import { rowToTicket, wrapSqliteError } from './helpers.js';
 const T = PMO_TABLES;
 export class EpicStorage {
     ctx;
@@ -27,10 +27,15 @@ export class EpicStorage {
       `).get(projectId);
             position = maxPos.max_pos + 1;
         }
-        this.ctx.db.prepare(`
-      INSERT INTO ${T.epics} (id, project_id, title, description, status, position, file_path, spec_id, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(id, projectId, title, epic.description || null, status, position, epic.filePath || null, epic.specId || null, now, now);
+        try {
+            this.ctx.db.prepare(`
+        INSERT INTO ${T.epics} (id, project_id, title, description, status, position, file_path, spec_id, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(id, projectId, title, epic.description || null, status, position, epic.filePath || null, epic.specId || null, now, now);
+        }
+        catch (err) {
+            wrapSqliteError('Epic', 'create', err);
+        }
         this.ctx.updateBoardTimestamp(projectId);
         return {
             id,
@@ -155,11 +160,16 @@ export class EpicStorage {
         if (!epic) {
             throw new PMOError('NOT_FOUND', `Epic not found: ${id}`);
         }
-        // Unlink tickets from this epic
-        this.ctx.db.prepare(`
-      UPDATE ${T.tickets} SET epic_id = NULL WHERE epic_id = ?
-    `).run(id);
-        this.ctx.db.prepare(`DELETE FROM ${T.epics} WHERE id = ?`).run(id);
+        try {
+            // Unlink tickets from this epic
+            this.ctx.db.prepare(`
+        UPDATE ${T.tickets} SET epic_id = NULL WHERE epic_id = ?
+      `).run(id);
+            this.ctx.db.prepare(`DELETE FROM ${T.epics} WHERE id = ?`).run(id);
+        }
+        catch (err) {
+            wrapSqliteError('Epic', 'delete', err);
+        }
         this.ctx.updateBoardTimestamp(epic.projectId);
     }
     /**

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

@@ -4,6 +4,16 @@
 import Database from 'better-sqlite3';
 import { AcceptanceCriterion, Spec, StateCategory, Ticket } from '../types.js';
 import { SpecRow, TicketRow, WorkflowStatusRow } from './types.js';
+/**
+ * Wrap SQLite constraint errors with user-friendly messages.
+ * This function always throws - it never returns.
+ *
+ * @param entityType - The type of entity being operated on (e.g., 'Ticket', 'Spec', 'Project')
+ * @param operation - The operation being performed ('create', 'update', 'delete')
+ * @param err - The error thrown by SQLite
+ * @throws {PMOError} Always throws a user-friendly PMOError
+ */
+export declare function wrapSqliteError(entityType: string, operation: 'create' | 'update' | 'delete', err: unknown): never;
 /**
  * Convert a database row to a Ticket object.
  * Fetches related data (subtasks, metadata, status info).

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

@@ -2,7 +2,65 @@
  * Helper functions for converting database rows to domain types.
  */
 import { PMO_TABLES } from '../schema.js';
-import { normalizePriority, } from '../types.js';
+import { PMOError, normalizePriority, } from '../types.js';
+/**
+ * Check if an error is a SQLite UNIQUE constraint violation.
+ */
+function isUniqueConstraintError(err) {
+    if (!(err instanceof Error))
+        return false;
+    const sqliteErr = err;
+    return (sqliteErr.code === 'SQLITE_CONSTRAINT_UNIQUE' ||
+        sqliteErr.message.includes('UNIQUE constraint failed'));
+}
+/**
+ * Check if an error is a SQLite FOREIGN KEY constraint violation.
+ */
+function isForeignKeyConstraintError(err) {
+    if (!(err instanceof Error))
+        return false;
+    const sqliteErr = err;
+    return (sqliteErr.code === 'SQLITE_CONSTRAINT_FOREIGNKEY' ||
+        sqliteErr.message.includes('FOREIGN KEY constraint failed'));
+}
+/**
+ * Check if an error is a SQLite CHECK constraint violation.
+ */
+function isCheckConstraintError(err) {
+    if (!(err instanceof Error))
+        return false;
+    const sqliteErr = err;
+    return (sqliteErr.code === 'SQLITE_CONSTRAINT_CHECK' ||
+        sqliteErr.message.includes('CHECK constraint failed'));
+}
+/**
+ * Wrap SQLite constraint errors with user-friendly messages.
+ * This function always throws - it never returns.
+ *
+ * @param entityType - The type of entity being operated on (e.g., 'Ticket', 'Spec', 'Project')
+ * @param operation - The operation being performed ('create', 'update', 'delete')
+ * @param err - The error thrown by SQLite
+ * @throws {PMOError} Always throws a user-friendly PMOError
+ */
+export function wrapSqliteError(entityType, operation, err) {
+    if (isUniqueConstraintError(err)) {
+        if (operation === 'create') {
+            throw new PMOError('CONFLICT', `${entityType} with this ID already exists`);
+        }
+        throw new PMOError('CONFLICT', `${entityType} already exists with that value`);
+    }
+    if (isForeignKeyConstraintError(err)) {
+        if (operation === 'delete') {
+            throw new PMOError('CONFLICT', `Cannot delete ${entityType.toLowerCase()}: it has dependencies. Remove them first.`);
+        }
+        throw new PMOError('INVALID', `Cannot ${operation} ${entityType.toLowerCase()}: referenced entity does not exist`);
+    }
+    if (isCheckConstraintError(err)) {
+        throw new PMOError('INVALID', `Invalid ${entityType.toLowerCase()} data: constraint check failed`);
+    }
+    // Re-throw unknown errors
+    throw err;
+}
 const T = PMO_TABLES;
 /**
  * Convert a database row to a Ticket object.

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

@@ -9,7 +9,7 @@
  */
 import Database from 'better-sqlite3';
 import { DrizzleDB } from '../../database/drizzle.js';
-import { AcceptanceCriterion, Board, BoardConfig, BoardView, BoardViewFilter, BoardViewFilters, Column, CreateTicketInput, Epic, EpicDependency, EpicDependencyType, EpicFilter, PhaseFilter, PhaseTemplate, PhaseTemplateFilter, PMOStorage, Project, ProjectFilter, ProjectPhase, Roadmap, RoadmapFilter, RoadmapProject, Spec, SpecDependency, SpecDependencyType, SpecFilter, StateCategory, Subtask, SyncResult, SyncStatus, Ticket, TicketDependency, TicketDependencyType, TicketFilter, TicketTemplate, TicketTemplateFilter, WorkAction, WorkActionFilter, Workflow, WorkflowFilter, WorkflowStatus } from '../types.js';
+import { AcceptanceCriterion, Board, BoardConfig, BoardView, BoardViewFilter, BoardViewFilters, Category, CategoryFilter, CategoryType, Column, CreateTicketInput, Epic, EpicDependency, EpicDependencyType, EpicFilter, PhaseFilter, PhaseTemplate, PhaseTemplateFilter, PMOStorage, Project, ProjectFilter, ProjectPhase, Roadmap, RoadmapFilter, RoadmapProject, Spec, SpecDependency, SpecDependencyType, SpecFilter, StateCategory, Subtask, SyncResult, SyncStatus, Ticket, TicketDependency, TicketDependencyType, TicketFilter, TicketTemplate, TicketTemplateFilter, WorkAction, WorkActionFilter, Workflow, WorkflowFilter, WorkflowStatus } from '../types.js';
 export declare class SQLiteStorage implements PMOStorage {
     readonly type: "sqlite";
     private db;
@@ -28,6 +28,7 @@ export declare class SQLiteStorage implements PMOStorage {
     private actionStorage;
     private viewStorage;
     private roadmapStorage;
+    private categoryStorage;
     constructor(dbPath: string);
     /**
      * Get the underlying database connection.
@@ -186,6 +187,18 @@ export declare class SQLiteStorage implements PMOStorage {
     removeProjectFromRoadmap(roadmapId: string, projectId: string): Promise<void>;
     reorderRoadmapProject(roadmapId: string, projectId: string, newPosition: number): Promise<RoadmapProject>;
     getRoadmapsForProject(projectId: string): Promise<Roadmap[]>;
+    listCategories(filter?: CategoryFilter): Promise<Category[]>;
+    getCategory(id: string): Promise<Category | null>;
+    getCategoryByName(name: string, type: CategoryType): Promise<Category | null>;
+    createCategory(category: Partial<Category> & {
+        name: string;
+        type: CategoryType;
+    }): Promise<Category>;
+    updateCategory(id: string, changes: Partial<Category>): Promise<Category>;
+    renameCategory(id: string, newName: string): Promise<Category>;
+    deleteCategory(id: string): Promise<void>;
+    getCategoryNames(type: CategoryType): Promise<string[]>;
+    isValidCategory(name: string, type: CategoryType): Promise<boolean>;
     pull(): Promise<SyncResult>;
     push(): Promise<SyncResult>;
     status(): Promise<SyncStatus>;

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

@@ -10,7 +10,7 @@
 import Database from 'better-sqlite3';
 import { createDrizzleConnection } from '../../database/drizzle.js';
 import { PMO_TABLES, PMO_SCHEMA_SQL, validateTicketSchema } from '../schema.js';
-import { runMigrations, seedBuiltinWorkflows, seedBuiltinPhases, seedBuiltinPhaseTemplates, seedBuiltinActions, seedBuiltinTicketTemplates, updateBoardTimestamp, } from './base.js';
+import { runMigrations, seedBuiltinWorkflows, seedBuiltinPhases, seedBuiltinPhaseTemplates, seedBuiltinActions, seedBuiltinTicketTemplates, seedBuiltinCategories, updateBoardTimestamp, } from './base.js';
 import { ProjectStorage } from './projects.js';
 import { TicketStorage } from './tickets.js';
 import { SubtaskStorage, AcceptanceCriteriaStorage } from './subtasks.js';
@@ -23,6 +23,7 @@ import { PhaseStorage } from './phases.js';
 import { ActionStorage } from './actions.js';
 import { ViewStorage } from './views.js';
 import { RoadmapStorage } from './roadmaps.js';
+import { CategoryStorage } from './categories.js';
 const T = PMO_TABLES;
 export class SQLiteStorage {
     type = 'sqlite';
@@ -43,6 +44,7 @@ export class SQLiteStorage {
     actionStorage;
     viewStorage;
     roadmapStorage;
+    categoryStorage;
     constructor(dbPath) {
         this.dbPath = dbPath;
         // Open database (creates if doesn't exist)
@@ -71,6 +73,7 @@ export class SQLiteStorage {
         this.actionStorage = new ActionStorage(ctx);
         this.viewStorage = new ViewStorage(ctx);
         this.roadmapStorage = new RoadmapStorage(ctx);
+        this.categoryStorage = new CategoryStorage(ctx);
         // Ensure PMO tables exist
         this.ensurePMOTables();
     }
@@ -100,6 +103,7 @@ export class SQLiteStorage {
         seedBuiltinPhaseTemplates(this.db);
         seedBuiltinActions(this.db);
         seedBuiltinTicketTemplates(this.db);
+        seedBuiltinCategories(this.db);
         // Validate schema
         validateTicketSchema(this.db);
     }
@@ -579,6 +583,36 @@ export class SQLiteStorage {
         return this.roadmapStorage.getRoadmapsForProject(projectId);
     }
     // ===========================================================================
+    // Category Operations
+    // ===========================================================================
+    async listCategories(filter) {
+        return this.categoryStorage.listCategories(filter);
+    }
+    async getCategory(id) {
+        return this.categoryStorage.getCategory(id);
+    }
+    async getCategoryByName(name, type) {
+        return this.categoryStorage.getCategoryByName(name, type);
+    }
+    async createCategory(category) {
+        return this.categoryStorage.createCategory(category);
+    }
+    async updateCategory(id, changes) {
+        return this.categoryStorage.updateCategory(id, changes);
+    }
+    async renameCategory(id, newName) {
+        return this.categoryStorage.renameCategory(id, newName);
+    }
+    async deleteCategory(id) {
+        return this.categoryStorage.deleteCategory(id);
+    }
+    async getCategoryNames(type) {
+        return this.categoryStorage.getCategoryNames(type);
+    }
+    async isValidCategory(name, type) {
+        return this.categoryStorage.isValidCategory(name, type);
+    }
+    // ===========================================================================
     // Sync Operations (no-op for pure SQLite)
     // ===========================================================================
     async pull() {

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

@@ -6,7 +6,7 @@ import { PMO_TABLES } from '../schema.js';
 import { PMOError, } from '../types.js';
 import { generateEntityId, slugify } from '../utils.js';
 import { generateBoardMarkdown } from '../markdown.js';
-import { rowToTicket } from './helpers.js';
+import { rowToTicket, wrapSqliteError } from './helpers.js';
 const T = PMO_TABLES;
 export class ProjectStorage {
     ctx;
@@ -144,10 +144,15 @@ export class ProjectStorage {
         // Use the requested workflow if it exists, otherwise fall back to default
         const finalWorkflowId = workflow ? workflowId : 'default';
         // Insert project with workflow
-        this.ctx.db.prepare(`
-      INSERT OR REPLACE INTO ${T.projects} (id, name, template, description, workflow_id, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-    `).run(id, project.name, workflowId, project.description || null, finalWorkflowId, now, now);
+        try {
+            this.ctx.db.prepare(`
+        INSERT OR REPLACE INTO ${T.projects} (id, name, template, description, workflow_id, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `).run(id, project.name, workflowId, project.description || null, finalWorkflowId, now, now);
+        }
+        catch (err) {
+            wrapSqliteError('Project', 'create', err);
+        }
         return this.getBoard(id);
     }
     /**
@@ -241,9 +246,16 @@ export class ProjectStorage {
         if (resolvedId === 'default') {
             throw new PMOError('INVALID', 'Cannot delete the default project');
         }
-        const result = this.ctx.db.prepare(`DELETE FROM ${T.projects} WHERE id = ?`).run(resolvedId);
-        if (result.changes === 0) {
-            throw new PMOError('NOT_FOUND', `Project not found: ${projectIdOrName}`);
+        try {
+            const result = this.ctx.db.prepare(`DELETE FROM ${T.projects} WHERE id = ?`).run(resolvedId);
+            if (result.changes === 0) {
+                throw new PMOError('NOT_FOUND', `Project not found: ${projectIdOrName}`);
+            }
+        }
+        catch (err) {
+            if (err instanceof PMOError)
+                throw err;
+            wrapSqliteError('Project', 'delete', err);
         }
         // Tickets are deleted via CASCADE
     }

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

@@ -4,7 +4,7 @@
 import { PMO_TABLES } from '../schema.js';
 import { PMOError } from '../types.js';
 import { generateEntityId } from '../utils.js';
-import { rowToSpec, rowToTicket } from './helpers.js';
+import { rowToSpec, rowToTicket, wrapSqliteError } from './helpers.js';
 const T = PMO_TABLES;
 export class SpecStorage {
     ctx;
@@ -17,16 +17,21 @@ export class SpecStorage {
     async createSpec(spec) {
         const id = spec.id || generateEntityId(this.ctx.db, 'spec');
         const now = Date.now();
-        this.ctx.db.prepare(`
-      INSERT INTO ${T.specs} (
-        id, title, status, type, tags,
-        problem, solution, decisions, not_now, ui_ux,
-        acceptance_criteria, open_questions,
-        requirements_functional, requirements_technical,
-        context, created_at, updated_at
-      )
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(id, spec.title || 'Untitled Spec', spec.status || 'draft', spec.type || null, spec.tags ? JSON.stringify(spec.tags) : null, spec.problem || null, spec.solution || null, spec.decisions || null, spec.notNow || null, spec.uiUx || null, spec.acceptanceCriteria || null, spec.openQuestions || null, spec.requirementsFunctional || null, spec.requirementsTechnical || null, spec.context || null, now, now);
+        try {
+            this.ctx.db.prepare(`
+        INSERT INTO ${T.specs} (
+          id, title, status, type, tags,
+          problem, solution, decisions, not_now, ui_ux,
+          acceptance_criteria, open_questions,
+          requirements_functional, requirements_technical,
+          context, created_at, updated_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(id, spec.title || 'Untitled Spec', spec.status || 'draft', spec.type || null, spec.tags ? JSON.stringify(spec.tags) : null, spec.problem || null, spec.solution || null, spec.decisions || null, spec.notNow || null, spec.uiUx || null, spec.acceptanceCriteria || null, spec.openQuestions || null, spec.requirementsFunctional || null, spec.requirementsTechnical || null, spec.context || null, now, now);
+        }
+        catch (err) {
+            wrapSqliteError('Spec', 'create', err);
+        }
         return {
             id,
             title: spec.title || 'Untitled Spec',
@@ -176,8 +181,13 @@ export class SpecStorage {
         if (!existing) {
             throw new PMOError('NOT_FOUND', `Spec not found: ${id}`);
         }
-        this.ctx.db.prepare(`DELETE FROM ${T.specs} WHERE id = ?`).run(id);
-        this.ctx.db.prepare(`UPDATE ${T.tickets} SET spec_id = NULL WHERE spec_id = ?`).run(id);
+        try {
+            this.ctx.db.prepare(`DELETE FROM ${T.specs} WHERE id = ?`).run(id);
+            this.ctx.db.prepare(`UPDATE ${T.tickets} SET spec_id = NULL WHERE spec_id = ?`).run(id);
+        }
+        catch (err) {
+            wrapSqliteError('Spec', 'delete', err);
+        }
     }
     /**
      * Link a ticket to a spec.

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

@@ -6,6 +6,7 @@
 import { PMO_TABLES } from '../schema.js';
 import { PMOError, STATE_CATEGORY_ORDER } from '../types.js';
 import { slugify } from '../utils.js';
+import { wrapSqliteError } from './helpers.js';
 const T = PMO_TABLES;
 /**
  * Convert database row to Workflow object.
@@ -87,10 +88,15 @@ export class StatusStorage {
         if (existing) {
             throw new PMOError('CONFLICT', `Workflow with name "${workflow.name}" already exists`);
         }
-        this.ctx.db.prepare(`
-      INSERT INTO ${T.workflows} (id, name, description, is_builtin, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `).run(id, workflow.name || 'New Workflow', workflow.description || null, workflow.isBuiltin ? 1 : 0, now, now);
+        try {
+            this.ctx.db.prepare(`
+        INSERT INTO ${T.workflows} (id, name, description, is_builtin, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `).run(id, workflow.name || 'New Workflow', workflow.description || null, workflow.isBuiltin ? 1 : 0, now, now);
+        }
+        catch (err) {
+            wrapSqliteError('Workflow', 'create', err);
+        }
         return {
             id,
             name: workflow.name || 'New Workflow',
@@ -153,9 +159,14 @@ export class StatusStorage {
         if (projectCount.count > 0) {
             throw new PMOError('CONFLICT', `Cannot delete workflow: ${projectCount.count} project(s) are using it`);
         }
-        // Delete associated statuses first (cascaded by FK, but explicit for safety)
-        this.ctx.db.prepare(`DELETE FROM ${T.workflow_statuses} WHERE workflow_id = ?`).run(id);
-        this.ctx.db.prepare(`DELETE FROM ${T.workflows} WHERE id = ?`).run(id);
+        try {
+            // Delete associated statuses first (cascaded by FK, but explicit for safety)
+            this.ctx.db.prepare(`DELETE FROM ${T.workflow_statuses} WHERE workflow_id = ?`).run(id);
+            this.ctx.db.prepare(`DELETE FROM ${T.workflows} WHERE id = ?`).run(id);
+        }
+        catch (err) {
+            wrapSqliteError('Workflow', 'delete', err);
+        }
     }
     /**
      * Get the workflow for a project.
@@ -237,10 +248,15 @@ export class StatusStorage {
         WHERE workflow_id = ?
       `).run(workflowId);
         }
-        this.ctx.db.prepare(`
-      INSERT INTO ${T.workflow_statuses} (id, workflow_id, name, category, position, color, description, is_default, created_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(id, workflowId, status.name || 'New Status', category, position, status.color || null, status.description || null, status.isDefault ? 1 : 0, now);
+        try {
+            this.ctx.db.prepare(`
+        INSERT INTO ${T.workflow_statuses} (id, workflow_id, name, category, position, color, description, is_default, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(id, workflowId, status.name || 'New Status', category, position, status.color || null, status.description || null, status.isDefault ? 1 : 0, now);
+        }
+        catch (err) {
+            wrapSqliteError('Status', 'create', err);
+        }
         // Update workflow's updated_at timestamp
         this.ctx.db.prepare(`UPDATE ${T.workflows} SET updated_at = ? WHERE id = ?`).run(now, workflowId);
         return {
@@ -332,13 +348,18 @@ export class StatusStorage {
         if (ticketCount.count > 0) {
             throw new PMOError('CONFLICT', `Cannot delete status: ${ticketCount.count} ticket(s) are using it`);
         }
-        this.ctx.db.prepare(`DELETE FROM ${T.workflow_statuses} WHERE id = ?`).run(id);
-        // Reorder remaining statuses
-        this.ctx.db.prepare(`
-      UPDATE ${T.workflow_statuses}
-      SET position = position - 1
-      WHERE workflow_id = ? AND position > ?
-    `).run(existing.workflowId, existing.position);
+        try {
+            this.ctx.db.prepare(`DELETE FROM ${T.workflow_statuses} WHERE id = ?`).run(id);
+            // Reorder remaining statuses
+            this.ctx.db.prepare(`
+        UPDATE ${T.workflow_statuses}
+        SET position = position - 1
+        WHERE workflow_id = ? AND position > ?
+      `).run(existing.workflowId, existing.position);
+        }
+        catch (err) {
+            wrapSqliteError('Status', 'delete', err);
+        }
         // Update workflow's updated_at timestamp
         this.ctx.db.prepare(`UPDATE ${T.workflows} SET updated_at = ? WHERE id = ?`).run(new Date().toISOString(), existing.workflowId);
     }