@proletariat/cli 0.3.20 → 0.3.21

package/dist/commands/work/spawn.js

@@ -119,14 +119,6 @@ export default class WorkSpawn extends PMOCommand {
         const { flags, argv } = await this.parse(WorkSpawn);
         // Check if JSON output mode is active
         const jsonMode = shouldOutputJson(flags);
-        // This command requires project context (pass JSON mode config for AI agents)
-        const projectId = await this.requireProject({
-            jsonMode: {
-                flags,
-                commandName: 'work spawn',
-                baseCommand: 'prlt work spawn',
-            },
-        });
         // Helper to handle errors in JSON mode
         const handleError = (code, message) => {
             if (jsonMode) {
@@ -137,6 +129,38 @@ export default class WorkSpawn extends PMOCommand {
         };
         // Parse ticket IDs from args (everything after flags)
         const ticketIdArgs = argv;
+        // Try to infer project from ticket IDs if provided
+        let projectId;
+        if (ticketIdArgs.length > 0) {
+            // Look up tickets to get their project IDs
+            const projectIds = new Set();
+            for (const ticketId of ticketIdArgs) {
+                // eslint-disable-next-line no-await-in-loop
+                const ticket = await this.storage.getTicket(ticketId);
+                if (ticket?.projectId) {
+                    projectIds.add(ticket.projectId);
+                }
+            }
+            if (projectIds.size === 1) {
+                // All tickets from same project - use that project
+                projectId = [...projectIds][0];
+            }
+            else if (projectIds.size > 1) {
+                // Tickets from multiple projects - warn and require prompt
+                this.warn('Tickets are from multiple projects. Please specify --project.');
+            }
+            // If size === 0, tickets not found - will be handled later in validation
+        }
+        // Only call requireProject() if we couldn't infer from tickets
+        if (!projectId) {
+            projectId = await this.requireProject({
+                jsonMode: {
+                    flags,
+                    commandName: 'work spawn',
+                    baseCommand: 'prlt work spawn',
+                },
+            });
+        }
         // Note: Docker check is handled by work:start command when spawning each ticket
         // This allows for the interactive devcontainer/host selection with retry loop
         // Get workspace info (for agent worktree paths)

package/dist/commands/work/watch.js

@@ -42,11 +42,13 @@ export default class WorkWatch extends PMOCommand {
         limit: Flags.integer({
             char: 'l',
             description: 'Maximum concurrent executions',
+            min: 1,
         }),
         interval: Flags.integer({
             char: 'i',
             description: 'Polling interval in seconds',
             default: 5,
+            min: 1,
         }),
         once: Flags.boolean({
             description: 'Check once and exit (no continuous watching)',

package/dist/lib/agents/commands.d.ts

@@ -1,4 +1,11 @@
 import { Agent, Repository, MountMode as DBMountMode } from '../database/index.js';
+/**
+ * Format a list of agents for display in error messages.
+ * Truncates long lists to avoid overwhelming output.
+ */
+export declare function formatAgentList(agents: {
+    name: string;
+}[], maxShow?: number): string;
 export interface AgentStatus {
     name: string;
     exists: boolean;

package/dist/lib/agents/commands.js

@@ -9,6 +9,17 @@ import { getWorkspaceConfig, getWorkspaceAgents, getWorkspaceRepositories, getAg
 import { isValidAgentName, getSuggestedAgentNames, generateEphemeralAgentName, getThemePersistentDir, getThemeEphemeralDir, extractBaseName, getAgentBaseName, } from '../themes.js';
 import { createDevcontainerConfig } from '../execution/devcontainer.js';
 import { getPMOContext } from '../pmo/index.js';
+/**
+ * Format a list of agents for display in error messages.
+ * Truncates long lists to avoid overwhelming output.
+ */
+export function formatAgentList(agents, maxShow = 10) {
+    const names = agents.map(a => a.name);
+    if (names.length <= maxShow) {
+        return names.join(', ');
+    }
+    return `${names.slice(0, maxShow).join(', ')} ...and ${names.length - maxShow} more. Run 'prlt agent list' to see all.`;
+}
 /**
  * Find workspace root and return workspace information.
  *

package/dist/lib/execution/runners.js

@@ -612,8 +612,7 @@ export function isDockerRunning() {
             execSync('docker info', { stdio: 'pipe', timeout });
             return true;
         }
-        catch (err) {
-            console.debug(`[runners:docker] Docker check attempt ${attempt}/${maxRetries} failed:`, err);
+        catch {
             if (attempt === maxRetries) {
                 return false;
             }

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/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);
     }

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

@@ -5,6 +5,7 @@ import { randomUUID } from 'node:crypto';
 import { PMO_TABLES } from '../schema.js';
 import { PMOError } from '../types.js';
 import { slugify } from '../utils.js';
+import { wrapSqliteError } from './helpers.js';
 const T = PMO_TABLES;
 export class SubtaskStorage {
     ctx;
@@ -42,10 +43,15 @@ export class SubtaskStorage {
             id = `${baseId}-${counter}`;
         }
         const position = maxPos.max_pos + 1;
-        this.ctx.db.prepare(`
-      INSERT INTO ${T.subtasks} (id, ticket_id, title, done, position)
-      VALUES (?, ?, ?, 0, ?)
-    `).run(id, ticketId, title, position);
+        try {
+            this.ctx.db.prepare(`
+        INSERT INTO ${T.subtasks} (id, ticket_id, title, done, position)
+        VALUES (?, ?, ?, 0, ?)
+      `).run(id, ticketId, title, position);
+        }
+        catch (err) {
+            wrapSqliteError('Subtask', 'create', err);
+        }
         // Update ticket timestamp
         this.ctx.db.prepare(`
       UPDATE ${T.tickets} SET updated_at = ? WHERE id = ?
@@ -139,10 +145,15 @@ export class AcceptanceCriteriaStorage {
         // Use UUID to guarantee uniqueness even when multiple ACs are added in the same millisecond
         const id = `ac-${randomUUID()}`;
         const position = maxPos.max_pos + 1;
-        this.ctx.db.prepare(`
-      INSERT INTO ${T.ticket_acceptance_criteria} (id, ticket_id, criterion, verifiable, verified, position)
-      VALUES (?, ?, ?, 1, 0, ?)
-    `).run(id, ticketId, criterion, position);
+        try {
+            this.ctx.db.prepare(`
+        INSERT INTO ${T.ticket_acceptance_criteria} (id, ticket_id, criterion, verifiable, verified, position)
+        VALUES (?, ?, ?, 1, 0, ?)
+      `).run(id, ticketId, criterion, position);
+        }
+        catch (err) {
+            wrapSqliteError('Acceptance criterion', 'create', err);
+        }
         this.ctx.db.prepare(`
       UPDATE ${T.tickets} SET updated_at = ? WHERE id = ?
     `).run(Date.now(), ticketId);

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

@@ -6,7 +6,7 @@
 import { PMO_TABLES } from '../schema.js';
 import { PMOError } from '../types.js';
 import { slugify, generateEntityId } from '../utils.js';
-import { rowToTicket } from './helpers.js';
+import { rowToTicket, wrapSqliteError } from './helpers.js';
 const T = PMO_TABLES;
 export class TicketStorage {
     ctx;
@@ -126,14 +126,19 @@ export class TicketStorage {
         }
         // Insert ticket
         const labels = ticket.labels || [];
-        this.ctx.db.prepare(`
-      INSERT INTO ${T.tickets} (
-        id, project_id, title, description, priority, category,
-        status_id, owner, assignee, spec_id, epic_id, labels,
-        created_at, updated_at, last_synced_from_spec, last_synced_from_board
-      )
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(id, projectId, title, ticket.description || null, ticket.priority || null, ticket.category || null, statusId, ticket.owner || null, ticket.assignee || null, specId, ticket.epicId || null, JSON.stringify(labels), now, now, ticket.lastSyncedFromSpec || null, ticket.lastSyncedFromBoard || null);
+        try {
+            this.ctx.db.prepare(`
+        INSERT INTO ${T.tickets} (
+          id, project_id, title, description, priority, category,
+          status_id, owner, assignee, spec_id, epic_id, labels,
+          created_at, updated_at, last_synced_from_spec, last_synced_from_board
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(id, projectId, title, ticket.description || null, ticket.priority || null, ticket.category || null, statusId, ticket.owner || null, ticket.assignee || null, specId, ticket.epicId || null, JSON.stringify(labels), now, now, ticket.lastSyncedFromSpec || null, ticket.lastSyncedFromBoard || null);
+        }
+        catch (err) {
+            wrapSqliteError('Ticket', 'create', err);
+        }
         // Insert subtasks
         if (ticket.subtasks && ticket.subtasks.length > 0) {
             const insertSubtask = this.ctx.db.prepare(`
@@ -335,12 +340,19 @@ export class TicketStorage {
         }
         // Delete ticket (by ID only, since IDs are globally unique)
         // Related data (subtasks, metadata) are deleted via CASCADE
-        const result = this.ctx.db.prepare(`
-      DELETE FROM ${T.tickets}
-      WHERE id = ?
-    `).run(id);
-        if (result.changes === 0) {
-            throw new PMOError('NOT_FOUND', `Ticket not found: ${id}`, id);
+        try {
+            const result = this.ctx.db.prepare(`
+        DELETE FROM ${T.tickets}
+        WHERE id = ?
+      `).run(id);
+            if (result.changes === 0) {
+                throw new PMOError('NOT_FOUND', `Ticket not found: ${id}`, id);
+            }
+        }
+        catch (err) {
+            if (err instanceof PMOError)
+                throw err;
+            wrapSqliteError('Ticket', 'delete', err);
         }
         // Update board timestamp for the ticket's project
         this.updateProjectTimestamp(ticketProjectId);