@proletariat/cli 0.3.16 → 0.3.18

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

@@ -1,10 +1,12 @@
 /**
  * Roadmap operations for PMO.
  * Roadmaps are curated collections of projects for documentation/visualization.
+ *
+ * This module uses Drizzle ORM for type-safe database queries.
  */
-import { PMO_TABLES } from '../schema.js';
+import { eq, and, like, or, desc, asc, sql, gte, gt, lt, lte } from 'drizzle-orm';
+import { pmoRoadmaps, pmoRoadmapProjects, pmoProjects, } from '../../database/drizzle-schema.js';
 import { PMOError } from '../types.js';
-const T = PMO_TABLES;
 export class RoadmapStorage {
     ctx;
     constructor(ctx) {
@@ -16,15 +18,22 @@ export class RoadmapStorage {
      */
     async createRoadmap(roadmap) {
         const id = roadmap.id || `roadmap-${Date.now()}`;
-        const now = Date.now();
+        const now = new Date().toISOString();
         // If setting as default, unset other defaults first
         if (roadmap.isDefault) {
-            this.ctx.db.prepare(`UPDATE ${T.roadmaps} SET is_default = 0`).run();
+            this.ctx.drizzle
+                .update(pmoRoadmaps)
+                .set({ isDefault: false })
+                .run();
         }
-        this.ctx.db.prepare(`
-      INSERT INTO ${T.roadmaps} (id, name, description, is_default, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `).run(id, roadmap.name, roadmap.description || null, roadmap.isDefault ? 1 : 0, now, now);
+        this.ctx.drizzle.insert(pmoRoadmaps).values({
+            id,
+            name: roadmap.name,
+            description: roadmap.description || null,
+            isDefault: roadmap.isDefault || false,
+            createdAt: now,
+            updatedAt: now,
+        }).run();
         return {
             id,
             name: roadmap.name,
@@ -38,9 +47,11 @@ export class RoadmapStorage {
      * Get a roadmap by ID.
      */
     async getRoadmap(id) {
-        const row = this.ctx.db.prepare(`
-      SELECT * FROM ${T.roadmaps} WHERE id = ?
-    `).get(id);
+        const row = this.ctx.drizzle
+            .select()
+            .from(pmoRoadmaps)
+            .where(eq(pmoRoadmaps.id, id))
+            .get();
         if (!row)
             return null;
         return this.rowToRoadmap(row);
@@ -49,18 +60,23 @@ export class RoadmapStorage {
      * List roadmaps with optional filters.
      */
     async listRoadmaps(filter) {
-        let query = `SELECT * FROM ${T.roadmaps} WHERE 1=1`;
-        const params = [];
+        let query = this.ctx.drizzle
+            .select()
+            .from(pmoRoadmaps)
+            .$dynamic();
+        const conditions = [];
         if (filter?.search) {
-            query += ' AND (name LIKE ? OR description LIKE ?)';
-            params.push(`%${filter.search}%`, `%${filter.search}%`);
+            conditions.push(or(like(pmoRoadmaps.name, `%${filter.search}%`), like(pmoRoadmaps.description, `%${filter.search}%`)));
         }
         if (filter?.isDefault !== undefined) {
-            query += ' AND is_default = ?';
-            params.push(filter.isDefault ? 1 : 0);
+            conditions.push(eq(pmoRoadmaps.isDefault, filter.isDefault));
+        }
+        if (conditions.length > 0) {
+            query = query.where(and(...conditions));
         }
-        query += ' ORDER BY is_default DESC, name ASC';
-        const rows = this.ctx.db.prepare(query).all(...params);
+        const rows = query
+            .orderBy(desc(pmoRoadmaps.isDefault), asc(pmoRoadmaps.name))
+            .all();
         return rows.map(row => this.rowToRoadmap(row));
     }
     /**
@@ -71,29 +87,30 @@ export class RoadmapStorage {
         if (!roadmap) {
             throw new PMOError('NOT_FOUND', `Roadmap not found: ${id}`);
         }
-        const updates = [];
-        const params = [];
+        const updates = {};
         if (changes.name !== undefined) {
-            updates.push('name = ?');
-            params.push(changes.name);
+            updates.name = changes.name;
         }
         if (changes.description !== undefined) {
-            updates.push('description = ?');
-            params.push(changes.description || null);
+            updates.description = changes.description || null;
         }
         if (changes.isDefault !== undefined) {
             // If setting as default, unset other defaults first
             if (changes.isDefault) {
-                this.ctx.db.prepare(`UPDATE ${T.roadmaps} SET is_default = 0`).run();
+                this.ctx.drizzle
+                    .update(pmoRoadmaps)
+                    .set({ isDefault: false })
+                    .run();
             }
-            updates.push('is_default = ?');
-            params.push(changes.isDefault ? 1 : 0);
+            updates.isDefault = changes.isDefault;
         }
-        if (updates.length > 0) {
-            updates.push('updated_at = ?');
-            params.push(Date.now());
-            params.push(id);
-            this.ctx.db.prepare(`UPDATE ${T.roadmaps} SET ${updates.join(', ')} WHERE id = ?`).run(...params);
+        if (Object.keys(updates).length > 0) {
+            updates.updatedAt = new Date().toISOString();
+            this.ctx.drizzle
+                .update(pmoRoadmaps)
+                .set(updates)
+                .where(eq(pmoRoadmaps.id, id))
+                .run();
         }
         return (await this.getRoadmap(id));
     }
@@ -106,15 +123,21 @@ export class RoadmapStorage {
             throw new PMOError('NOT_FOUND', `Roadmap not found: ${id}`);
         }
         // Delete roadmap (cascades to roadmap_projects)
-        this.ctx.db.prepare(`DELETE FROM ${T.roadmaps} WHERE id = ?`).run(id);
+        this.ctx.drizzle
+            .delete(pmoRoadmaps)
+            .where(eq(pmoRoadmaps.id, id))
+            .run();
     }
     /**
      * Get the default roadmap.
      */
     async getDefaultRoadmap() {
-        const row = this.ctx.db.prepare(`
-      SELECT * FROM ${T.roadmaps} WHERE is_default = 1 LIMIT 1
-    `).get();
+        const row = this.ctx.drizzle
+            .select()
+            .from(pmoRoadmaps)
+            .where(eq(pmoRoadmaps.isDefault, true))
+            .limit(1)
+            .get();
         if (!row)
             return null;
         return this.rowToRoadmap(row);
@@ -130,12 +153,26 @@ export class RoadmapStorage {
      * List projects in a roadmap, ordered by position.
      */
     async listRoadmapProjects(roadmapId) {
-        const rows = this.ctx.db.prepare(`
-      SELECT p.* FROM ${T.projects} p
-      JOIN ${T.roadmap_projects} rp ON p.id = rp.project_id
-      WHERE rp.roadmap_id = ?
-      ORDER BY rp.position ASC
-    `).all(roadmapId);
+        const rows = this.ctx.drizzle
+            .select({
+            id: pmoProjects.id,
+            name: pmoProjects.name,
+            template: pmoProjects.template,
+            description: pmoProjects.description,
+            status: pmoProjects.status,
+            phaseId: pmoProjects.phaseId,
+            workflowId: pmoProjects.workflowId,
+            isArchived: pmoProjects.isArchived,
+            targetDate: pmoProjects.targetDate,
+            initiativeId: pmoProjects.initiativeId,
+            createdAt: pmoProjects.createdAt,
+            updatedAt: pmoProjects.updatedAt,
+        })
+            .from(pmoProjects)
+            .innerJoin(pmoRoadmapProjects, eq(pmoProjects.id, pmoRoadmapProjects.projectId))
+            .where(eq(pmoRoadmapProjects.roadmapId, roadmapId))
+            .orderBy(asc(pmoRoadmapProjects.position))
+            .all();
         return rows.map(row => this.rowToProject(row));
     }
     /**
@@ -148,34 +185,44 @@ export class RoadmapStorage {
             throw new PMOError('NOT_FOUND', `Roadmap not found: ${roadmapId}`);
         }
         // Check if project is already in roadmap
-        const existing = this.ctx.db.prepare(`
-      SELECT * FROM ${T.roadmap_projects} WHERE roadmap_id = ? AND project_id = ?
-    `).get(roadmapId, projectId);
+        const existing = this.ctx.drizzle
+            .select()
+            .from(pmoRoadmapProjects)
+            .where(and(eq(pmoRoadmapProjects.roadmapId, roadmapId), eq(pmoRoadmapProjects.projectId, projectId)))
+            .get();
         if (existing) {
             throw new PMOError('CONFLICT', `Project ${projectId} is already in roadmap ${roadmapId}`);
         }
         // Get next position if not provided
         if (position === undefined) {
-            const maxPos = this.ctx.db.prepare(`
-        SELECT COALESCE(MAX(position), -1) as max_pos FROM ${T.roadmap_projects} WHERE roadmap_id = ?
-      `).get(roadmapId);
-            position = maxPos.max_pos + 1;
+            const maxPosResult = this.ctx.drizzle
+                .select({ maxPos: sql `COALESCE(MAX(${pmoRoadmapProjects.position}), -1)` })
+                .from(pmoRoadmapProjects)
+                .where(eq(pmoRoadmapProjects.roadmapId, roadmapId))
+                .get();
+            position = (maxPosResult?.maxPos ?? -1) + 1;
         }
         else {
             // Shift existing projects at or after this position
-            this.ctx.db.prepare(`
-        UPDATE ${T.roadmap_projects}
-        SET position = position + 1
-        WHERE roadmap_id = ? AND position >= ?
-      `).run(roadmapId, position);
+            this.ctx.drizzle
+                .update(pmoRoadmapProjects)
+                .set({ position: sql `${pmoRoadmapProjects.position} + 1` })
+                .where(and(eq(pmoRoadmapProjects.roadmapId, roadmapId), gte(pmoRoadmapProjects.position, position)))
+                .run();
         }
-        const now = Date.now();
-        this.ctx.db.prepare(`
-      INSERT INTO ${T.roadmap_projects} (roadmap_id, project_id, position, created_at)
-      VALUES (?, ?, ?, ?)
-    `).run(roadmapId, projectId, position, now);
+        const now = new Date().toISOString();
+        this.ctx.drizzle.insert(pmoRoadmapProjects).values({
+            roadmapId,
+            projectId,
+            position,
+            createdAt: now,
+        }).run();
         // Update roadmap timestamp
-        this.ctx.db.prepare(`UPDATE ${T.roadmaps} SET updated_at = ? WHERE id = ?`).run(now, roadmapId);
+        this.ctx.drizzle
+            .update(pmoRoadmaps)
+            .set({ updatedAt: now })
+            .where(eq(pmoRoadmaps.id, roadmapId))
+            .run();
         return {
             roadmapId,
             projectId,
@@ -188,33 +235,45 @@ export class RoadmapStorage {
      */
     async removeProjectFromRoadmap(roadmapId, projectId) {
         // Get current position for reordering
-        const current = this.ctx.db.prepare(`
-      SELECT position FROM ${T.roadmap_projects} WHERE roadmap_id = ? AND project_id = ?
-    `).get(roadmapId, projectId);
+        const current = this.ctx.drizzle
+            .select({ position: pmoRoadmapProjects.position })
+            .from(pmoRoadmapProjects)
+            .where(and(eq(pmoRoadmapProjects.roadmapId, roadmapId), eq(pmoRoadmapProjects.projectId, projectId)))
+            .get();
         if (!current) {
             throw new PMOError('NOT_FOUND', `Project ${projectId} not in roadmap ${roadmapId}`);
         }
         // Delete the association
-        this.ctx.db.prepare(`
-      DELETE FROM ${T.roadmap_projects} WHERE roadmap_id = ? AND project_id = ?
-    `).run(roadmapId, projectId);
+        this.ctx.drizzle
+            .delete(pmoRoadmapProjects)
+            .where(and(eq(pmoRoadmapProjects.roadmapId, roadmapId), eq(pmoRoadmapProjects.projectId, projectId)))
+            .run();
         // Reorder remaining projects to fill the gap
-        this.ctx.db.prepare(`
-      UPDATE ${T.roadmap_projects}
-      SET position = position - 1
-      WHERE roadmap_id = ? AND position > ?
-    `).run(roadmapId, current.position);
+        this.ctx.drizzle
+            .update(pmoRoadmapProjects)
+            .set({ position: sql `${pmoRoadmapProjects.position} - 1` })
+            .where(and(eq(pmoRoadmapProjects.roadmapId, roadmapId), gt(pmoRoadmapProjects.position, current.position)))
+            .run();
         // Update roadmap timestamp
-        this.ctx.db.prepare(`UPDATE ${T.roadmaps} SET updated_at = ? WHERE id = ?`).run(Date.now(), roadmapId);
+        this.ctx.drizzle
+            .update(pmoRoadmaps)
+            .set({ updatedAt: new Date().toISOString() })
+            .where(eq(pmoRoadmaps.id, roadmapId))
+            .run();
     }
     /**
      * Reorder a project within a roadmap.
      */
     async reorderRoadmapProject(roadmapId, projectId, newPosition) {
         // Get current position
-        const current = this.ctx.db.prepare(`
-      SELECT position, created_at FROM ${T.roadmap_projects} WHERE roadmap_id = ? AND project_id = ?
-    `).get(roadmapId, projectId);
+        const current = this.ctx.drizzle
+            .select({
+            position: pmoRoadmapProjects.position,
+            createdAt: pmoRoadmapProjects.createdAt,
+        })
+            .from(pmoRoadmapProjects)
+            .where(and(eq(pmoRoadmapProjects.roadmapId, roadmapId), eq(pmoRoadmapProjects.projectId, projectId)))
+            .get();
         if (!current) {
             throw new PMOError('NOT_FOUND', `Project ${projectId} not in roadmap ${roadmapId}`);
         }
@@ -224,51 +283,63 @@ export class RoadmapStorage {
                 roadmapId,
                 projectId,
                 position: newPosition,
-                createdAt: new Date(current.created_at),
+                createdAt: new Date(current.createdAt),
             };
         }
-        // Shift positions (same pattern as EpicStorage.reorderEpic)
+        // Shift positions
         if (newPosition < oldPosition) {
             // Moving up: increment positions in between
-            this.ctx.db.prepare(`
-        UPDATE ${T.roadmap_projects}
-        SET position = position + 1
-        WHERE roadmap_id = ? AND position >= ? AND position < ?
-      `).run(roadmapId, newPosition, oldPosition);
+            this.ctx.drizzle
+                .update(pmoRoadmapProjects)
+                .set({ position: sql `${pmoRoadmapProjects.position} + 1` })
+                .where(and(eq(pmoRoadmapProjects.roadmapId, roadmapId), gte(pmoRoadmapProjects.position, newPosition), lt(pmoRoadmapProjects.position, oldPosition)))
+                .run();
         }
         else {
             // Moving down: decrement positions in between
-            this.ctx.db.prepare(`
-        UPDATE ${T.roadmap_projects}
-        SET position = position - 1
-        WHERE roadmap_id = ? AND position > ? AND position <= ?
-      `).run(roadmapId, oldPosition, newPosition);
+            this.ctx.drizzle
+                .update(pmoRoadmapProjects)
+                .set({ position: sql `${pmoRoadmapProjects.position} - 1` })
+                .where(and(eq(pmoRoadmapProjects.roadmapId, roadmapId), gt(pmoRoadmapProjects.position, oldPosition), lte(pmoRoadmapProjects.position, newPosition)))
+                .run();
         }
         // Update the target project's position
-        this.ctx.db.prepare(`
-      UPDATE ${T.roadmap_projects}
-      SET position = ?
-      WHERE roadmap_id = ? AND project_id = ?
-    `).run(newPosition, roadmapId, projectId);
+        this.ctx.drizzle
+            .update(pmoRoadmapProjects)
+            .set({ position: newPosition })
+            .where(and(eq(pmoRoadmapProjects.roadmapId, roadmapId), eq(pmoRoadmapProjects.projectId, projectId)))
+            .run();
         // Update roadmap timestamp
-        this.ctx.db.prepare(`UPDATE ${T.roadmaps} SET updated_at = ? WHERE id = ?`).run(Date.now(), roadmapId);
+        this.ctx.drizzle
+            .update(pmoRoadmaps)
+            .set({ updatedAt: new Date().toISOString() })
+            .where(eq(pmoRoadmaps.id, roadmapId))
+            .run();
         return {
             roadmapId,
             projectId,
             position: newPosition,
-            createdAt: new Date(current.created_at),
+            createdAt: new Date(current.createdAt),
         };
     }
     /**
      * Get all roadmaps that contain a project.
      */
     async getRoadmapsForProject(projectId) {
-        const rows = this.ctx.db.prepare(`
-      SELECT r.* FROM ${T.roadmaps} r
-      JOIN ${T.roadmap_projects} rp ON r.id = rp.roadmap_id
-      WHERE rp.project_id = ?
-      ORDER BY r.name ASC
-    `).all(projectId);
+        const rows = this.ctx.drizzle
+            .select({
+            id: pmoRoadmaps.id,
+            name: pmoRoadmaps.name,
+            description: pmoRoadmaps.description,
+            isDefault: pmoRoadmaps.isDefault,
+            createdAt: pmoRoadmaps.createdAt,
+            updatedAt: pmoRoadmaps.updatedAt,
+        })
+            .from(pmoRoadmaps)
+            .innerJoin(pmoRoadmapProjects, eq(pmoRoadmaps.id, pmoRoadmapProjects.roadmapId))
+            .where(eq(pmoRoadmapProjects.projectId, projectId))
+            .orderBy(asc(pmoRoadmaps.name))
+            .all();
         return rows.map(row => this.rowToRoadmap(row));
     }
     // ===== Helpers =====
@@ -277,9 +348,9 @@ export class RoadmapStorage {
             id: row.id,
             name: row.name,
             description: row.description || undefined,
-            isDefault: row.is_default === 1,
-            createdAt: new Date(row.created_at),
-            updatedAt: new Date(row.updated_at),
+            isDefault: row.isDefault ?? false,
+            createdAt: new Date(row.createdAt || Date.now()),
+            updatedAt: new Date(row.updatedAt || Date.now()),
         };
     }
     rowToProject(row) {
@@ -289,13 +360,13 @@ export class RoadmapStorage {
             template: row.template || undefined,
             description: row.description || undefined,
             status: (row.status || 'active'),
-            phaseId: row.phase_id || undefined,
-            workflowId: row.workflow_id || undefined,
-            isArchived: row.is_archived === 1,
-            targetDate: row.target_date ? new Date(row.target_date) : undefined,
-            initiativeId: row.initiative_id || undefined,
-            createdAt: new Date(row.created_at),
-            updatedAt: new Date(row.updated_at),
+            phaseId: row.phaseId || undefined,
+            workflowId: row.workflowId || undefined,
+            isArchived: row.isArchived ?? false,
+            targetDate: row.targetDate ? new Date(row.targetDate) : undefined,
+            initiativeId: row.initiativeId || undefined,
+            createdAt: new Date(row.createdAt || Date.now()),
+            updatedAt: new Date(row.updatedAt || Date.now()),
         };
     }
 }

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

@@ -19,21 +19,22 @@ export class SpecStorage {
         const now = Date.now();
         this.ctx.db.prepare(`
       INSERT INTO ${T.specs} (
-        id, title, status, type, tags, depends_on,
+        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.dependsOn ? JSON.stringify(spec.dependsOn) : 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);
+      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);
         return {
             id,
             title: spec.title || 'Untitled Spec',
             status: spec.status || 'draft',
             type: spec.type,
             tags: spec.tags,
-            dependsOn: spec.dependsOn,
+            // Note: dependsOn is now handled via spec_dependencies table
+            dependsOn: undefined,
             problem: spec.problem,
             solution: spec.solution,
             decisions: spec.decisions,
@@ -53,7 +54,7 @@ export class SpecStorage {
      */
     async getSpec(id) {
         const row = this.ctx.db.prepare(`
-      SELECT id, title, status, type, tags, depends_on,
+      SELECT id, title, status, type, tags,
              problem, solution, decisions, not_now, ui_ux,
              acceptance_criteria, open_questions,
              requirements_functional, requirements_technical,
@@ -69,7 +70,7 @@ export class SpecStorage {
      */
     async listSpecs(filter) {
         let query = `
-      SELECT id, title, status, type, tags, depends_on,
+      SELECT id, title, status, type, tags,
              problem, solution, decisions, not_now, ui_ux,
              acceptance_criteria, open_questions,
              requirements_functional, requirements_technical,
@@ -119,10 +120,6 @@ export class SpecStorage {
             updates.push('tags = ?');
             params.push(JSON.stringify(changes.tags));
         }
-        if (changes.dependsOn !== undefined) {
-            updates.push('depends_on = ?');
-            params.push(JSON.stringify(changes.dependsOn));
-        }
         if (changes.problem !== undefined) {
             updates.push('problem = ?');
             params.push(changes.problem);
@@ -272,7 +269,7 @@ export class SpecStorage {
             throw new PMOError('NOT_FOUND', `Spec not found: ${dependsOnId}`);
         }
         this.ctx.db.prepare(`
-      INSERT OR IGNORE INTO ${T.spec_dependencies} (spec_id, depends_on, created_at)
+      INSERT OR IGNORE INTO ${T.spec_dependencies} (spec_id, depends_on_spec_id, created_at)
       VALUES (?, ?, ?)
     `).run(specId, dependsOnId, Date.now());
     }
@@ -282,7 +279,7 @@ export class SpecStorage {
     async removeSpecDependency(specId, dependsOnId) {
         this.ctx.db.prepare(`
       DELETE FROM ${T.spec_dependencies}
-      WHERE spec_id = ? AND depends_on = ?
+      WHERE spec_id = ? AND depends_on_spec_id = ?
     `).run(specId, dependsOnId);
     }
     /**
@@ -290,12 +287,12 @@ export class SpecStorage {
      */
     async getSpecDependencies(specId) {
         const rows = this.ctx.db.prepare(`
-      SELECT depends_on FROM ${T.spec_dependencies} WHERE spec_id = ?
+      SELECT depends_on_spec_id FROM ${T.spec_dependencies} WHERE spec_id = ?
     `).all(specId);
         const specs = [];
         for (const row of rows) {
             // eslint-disable-next-line no-await-in-loop -- Sequential lookup for relationship chain
-            const spec = await this.getSpec(row.depends_on);
+            const spec = await this.getSpec(row.depends_on_spec_id);
             if (spec)
                 specs.push(spec);
         }
@@ -306,7 +303,7 @@ export class SpecStorage {
      */
     async getSpecDependents(specId) {
         const rows = this.ctx.db.prepare(`
-      SELECT spec_id FROM ${T.spec_dependencies} WHERE depends_on = ?
+      SELECT spec_id FROM ${T.spec_dependencies} WHERE depends_on_spec_id = ?
     `).all(specId);
         const specs = [];
         for (const row of rows) {
@@ -352,7 +349,7 @@ export class SpecStorage {
      */
     async getSpecsForProject(projectId) {
         const rows = this.ctx.db.prepare(`
-      SELECT s.id, s.title, s.status, s.type, s.tags, s.depends_on,
+      SELECT s.id, s.title, s.status, s.type, s.tags,
              s.problem, s.solution, s.decisions, s.not_now, s.ui_ux,
              s.acceptance_criteria, s.open_questions,
              s.requirements_functional, s.requirements_technical,

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

@@ -1,6 +1,7 @@
 /**
  * Subtask operations for tickets.
  */
+import { randomUUID } from 'node:crypto';
 import { PMO_TABLES } from '../schema.js';
 import { PMOError } from '../types.js';
 import { slugify } from '../utils.js';
@@ -26,7 +27,20 @@ export class SubtaskStorage {
       SELECT COALESCE(MAX(position), -1) as max_pos
       FROM ${T.subtasks} WHERE ticket_id = ?
     `).get(ticketId);
-        const id = slugify(title);
+        // Generate unique ID - start with slugified title, append counter if collision
+        const baseId = slugify(title);
+        let id = baseId;
+        let counter = 1;
+        // Check for existing subtask with same ID and append counter if needed
+        while (true) {
+            const existing = this.ctx.db.prepare(`
+        SELECT 1 FROM ${T.subtasks} WHERE ticket_id = ? AND id = ?
+      `).get(ticketId, id);
+            if (!existing)
+                break;
+            counter++;
+            id = `${baseId}-${counter}`;
+        }
         const position = maxPos.max_pos + 1;
         this.ctx.db.prepare(`
       INSERT INTO ${T.subtasks} (id, ticket_id, title, done, position)
@@ -122,7 +136,8 @@ export class AcceptanceCriteriaStorage {
       SELECT COALESCE(MAX(position), -1) as max_pos
       FROM ${T.ticket_acceptance_criteria} WHERE ticket_id = ?
     `).get(ticketId);
-        const id = `ac-${Date.now()}`;
+        // 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)

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

@@ -8,6 +8,16 @@ import { StorageContext } from './types.js';
 export declare class TicketStorage {
     private ctx;
     constructor(ctx: StorageContext);
+    /**
+     * Resolve a project identifier to its actual ID.
+     * Tries multiple strategies:
+     * 1. Exact ID match
+     * 2. Case-insensitive ID match
+     * 3. Exact name match
+     * 4. Case-insensitive name match
+     * 5. Slugified name match
+     */
+    private resolveProjectId;
     /**
      * Create a new ticket.
      * Gets default status from the project's workflow.
@@ -45,10 +55,10 @@ export declare class TicketStorage {
     deleteTicket(id: string): Promise<void>;
     /**
      * List tickets with optional filters.
-     * @param projectId - The project to filter by. Pass undefined to list all tickets across all projects.
+     * @param projectIdOrName - The project ID, name, or slug to filter by. Pass undefined to list all tickets across all projects.
      * @param filter - Additional filters to apply.
      */
-    listTickets(projectId: string | undefined, filter?: TicketFilter): Promise<Ticket[]>;
+    listTickets(projectIdOrName: string | undefined, filter?: TicketFilter): Promise<Ticket[]>;
     /**
      * Move a ticket to a different project.
      * The ticket will get the default status from the target project's workflow.