@proletariat/cli 0.3.19 → 0.3.21

package/dist/lib/branch/index.js

@@ -129,6 +129,14 @@ export function validateBranchName(name) {
     if (parts.length === 2) {
         // {type}/{description}
         const description = parts[1];
+        // Check if description looks like a ticket ID (user put ticket in wrong position)
+        if (isTicketId(description)) {
+            return {
+                valid: false,
+                error: `Segment "${description}" looks like a ticket ID, but ticket IDs must be the first segment. ` +
+                    `Expected format: {ticketId}/{type}/{description}`,
+            };
+        }
         if (!isKebabCase(description)) {
             return {
                 valid: false,
@@ -143,12 +151,28 @@ export function validateBranchName(name) {
     // {type}/{owner}/{description}
     const owner = parts[1];
     const description = parts[2];
+    // Check if owner looks like a ticket ID (user put ticket in wrong position)
+    if (isTicketId(owner)) {
+        return {
+            valid: false,
+            error: `Segment "${owner}" looks like a ticket ID, but it's in the owner position (segment 2). ` +
+                `Ticket IDs must be the first segment. Expected format: {ticketId}/{type}/{owner}/{description}`,
+        };
+    }
     if (!isKebabCase(owner)) {
         return {
             valid: false,
             error: `Owner name must be kebab-case: "${owner}"`,
         };
     }
+    // Check if description looks like a ticket ID (user put ticket in wrong position)
+    if (isTicketId(description)) {
+        return {
+            valid: false,
+            error: `Segment "${description}" looks like a ticket ID, but it's in the description position (segment 3). ` +
+                `Ticket IDs must be the first segment.`,
+        };
+    }
     if (!isKebabCase(description)) {
         return {
             valid: false,

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

@@ -14,6 +14,8 @@ declare const CONFIG_KEYS: {
     defaultMode: string;
     defaultExecutor: string;
     autoExecute: string;
+    outputMode: string;
+    sandboxed: string;
     tmuxSession: string;
     tmuxLayout: string;
     tmuxControlMode: string;

package/dist/lib/execution/config.js

@@ -18,6 +18,8 @@ const CONFIG_KEYS = {
     defaultMode: 'execution.default_mode',
     defaultExecutor: 'execution.default_executor',
     autoExecute: 'execution.auto_execute',
+    outputMode: 'execution.output_mode',
+    sandboxed: 'execution.sandboxed',
     tmuxSession: 'execution.tmux.session',
     tmuxLayout: 'execution.tmux.layout',
     tmuxControlMode: 'execution.tmux.control_mode',
@@ -85,6 +87,16 @@ export function loadExecutionConfig(db) {
     if (autoExecute !== null) {
         config.autoExecute = autoExecute === 'true';
     }
+    // Load output mode
+    const outputMode = getSetting(db, CONFIG_KEYS.outputMode);
+    if (outputMode) {
+        config.outputMode = outputMode;
+    }
+    // Load sandboxed preference
+    const sandboxed = getSetting(db, CONFIG_KEYS.sandboxed);
+    if (sandboxed !== null) {
+        config.sandboxed = sandboxed === 'true';
+    }
     // Load tmux settings
     const tmuxSession = getSetting(db, CONFIG_KEYS.tmuxSession);
     if (tmuxSession) {

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

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

@@ -75,14 +75,16 @@ export declare function deepClone<T>(obj: T): T;
 /**
  * Default column names for work commands (Linear-style workflow)
  *
- * Linear-style: Backlog → Planned → In Progress → Done
+ * Linear-style: Backlog → Planned → In Progress → Review → Done
  * - planned: Move tickets here when scheduled/assigned
  * - in_progress: Move tickets here when work starts
- * - done: Move tickets here when work is complete (includes review/merged)
+ * - review: Move tickets here when work is ready for review
+ * - done: Move tickets here when work is complete (reviewed/merged)
  */
 export declare const DEFAULT_WORK_COLUMNS: {
     readonly planned: "Planned";
     readonly in_progress: "In Progress";
+    readonly review: "Review";
     readonly done: "Done";
 };
 export type WorkColumnType = keyof typeof DEFAULT_WORK_COLUMNS;

package/dist/lib/pmo/utils.js

@@ -122,14 +122,16 @@ export function deepClone(obj) {
 /**
  * Default column names for work commands (Linear-style workflow)
  *
- * Linear-style: Backlog → Planned → In Progress → Done
+ * Linear-style: Backlog → Planned → In Progress → Review → Done
  * - planned: Move tickets here when scheduled/assigned
  * - in_progress: Move tickets here when work starts
- * - done: Move tickets here when work is complete (includes review/merged)
+ * - review: Move tickets here when work is ready for review
+ * - done: Move tickets here when work is complete (reviewed/merged)
  */
 export const DEFAULT_WORK_COLUMNS = {
     planned: 'Planned',
     in_progress: 'In Progress',
+    review: 'Review',
     done: 'Done',
 };
 /**