@amsterdamdatalabs/enact-factory 0.1.1

package/dist/workItems/postgresStore.js

@@ -0,0 +1,937 @@
+// ============================================
+// Enact Factory - PostgreSQL WorkItem Store
+// Alternative to SQLite for multi-instance deployments
+// ============================================
+import { Pool } from 'pg';
+import { nanoid } from 'nanoid';
+export class PostgresWorkItemStore {
+    pool;
+    schema;
+    constructor(config) {
+        const defaultPort = 45432;
+        const defaultDatabase = 'enact_factory_dev';
+        const poolConfig = config.connectionString
+            ? { connectionString: config.connectionString }
+            : {
+                host: config.host ?? 'localhost',
+                port: config.port ?? defaultPort,
+                database: config.database ?? defaultDatabase,
+                user: config.user ?? 'postgres',
+                password: config.password ?? '',
+                max: config.maxConnections ?? 10,
+            };
+        this.pool = new Pool(poolConfig);
+        this.schema = config.schema ?? 'public';
+        // Handle pool errors
+        this.pool.on('error', (err) => {
+            console.error('[PostgresStore] Unexpected pool error:', err);
+        });
+    }
+    async init() {
+        await this.migrate();
+    }
+    async close() {
+        await this.pool.end();
+    }
+    async migrate() {
+        const client = await this.pool.connect();
+        try {
+            // Create schema if not exists
+            await client.query(`CREATE SCHEMA IF NOT EXISTS ${this.schema}`);
+            // Create workItems table
+            await client.query(`
+        CREATE TABLE IF NOT EXISTS ${this.schema}.work_items (
+          id TEXT PRIMARY KEY,
+          project_id TEXT NOT NULL,
+          title TEXT NOT NULL,
+          description TEXT DEFAULT '',
+          status TEXT,
+          priority TEXT,
+          source TEXT,
+          kind TEXT,
+          area TEXT,
+          review_state TEXT,
+          resolution TEXT,
+          assignee TEXT,
+          milestone TEXT,
+          estimate_minutes INTEGER,
+          complexity TEXT,
+          parent_id TEXT REFERENCES ${this.schema}.work_items(id) ON DELETE SET NULL,
+          azdo_id TEXT,
+          azdo_identifier TEXT,
+          azdo_url TEXT,
+          payload_json JSONB,
+          operator_session_id TEXT,
+          operator_lane TEXT,
+          is_session_root BOOLEAN DEFAULT FALSE,
+          external_work_item_id TEXT,
+          created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+          updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+          closed_at TIMESTAMPTZ
+        )
+      `);
+            // Add azdo columns if they don't exist (idempotent migration for existing schemas)
+            await client.query(`ALTER TABLE ${this.schema}.work_items ADD COLUMN IF NOT EXISTS azdo_id TEXT`);
+            await client.query(`ALTER TABLE ${this.schema}.work_items ADD COLUMN IF NOT EXISTS azdo_identifier TEXT`);
+            await client.query(`ALTER TABLE ${this.schema}.work_items ADD COLUMN IF NOT EXISTS azdo_url TEXT`);
+            await client.query(`ALTER TABLE ${this.schema}.work_items ADD COLUMN IF NOT EXISTS operator_session_id TEXT`);
+            await client.query(`ALTER TABLE ${this.schema}.work_items ADD COLUMN IF NOT EXISTS operator_lane TEXT`);
+            await client.query(`ALTER TABLE ${this.schema}.work_items ADD COLUMN IF NOT EXISTS is_session_root BOOLEAN DEFAULT FALSE`);
+            await client.query(`ALTER TABLE ${this.schema}.work_items ADD COLUMN IF NOT EXISTS external_work_item_id TEXT`);
+            // Drop content-field DEFAULTs on existing DBs so real Azure DevOps values (or NULL) persist
+            // instead of being silently replaced by fabricated literals. DROP DEFAULT is idempotent.
+            await client.query(`ALTER TABLE ${this.schema}.work_items ALTER COLUMN status DROP DEFAULT`);
+            await client.query(`ALTER TABLE ${this.schema}.work_items ALTER COLUMN priority DROP DEFAULT`);
+            await client.query(`ALTER TABLE ${this.schema}.work_items ALTER COLUMN source DROP DEFAULT`);
+            await client.query(`ALTER TABLE ${this.schema}.work_items ALTER COLUMN kind DROP DEFAULT`);
+            await client.query(`ALTER TABLE ${this.schema}.work_items ALTER COLUMN area DROP DEFAULT`);
+            await client.query(`ALTER TABLE ${this.schema}.work_items ALTER COLUMN review_state DROP DEFAULT`);
+            await client.query(`ALTER TABLE ${this.schema}.work_items ALTER COLUMN resolution DROP DEFAULT`);
+            // Create sync_meta KV table for sync watermarks
+            await client.query(`
+        CREATE TABLE IF NOT EXISTS ${this.schema}.sync_meta (
+          key TEXT PRIMARY KEY,
+          value TEXT NOT NULL,
+          updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+        )
+      `);
+            await client.query(`
+        CREATE TABLE IF NOT EXISTS ${this.schema}.projects (
+          name TEXT PRIMARY KEY,
+          path TEXT NOT NULL UNIQUE,
+          heartbeat_ms INTEGER NOT NULL,
+          azdo_label TEXT,
+          enabled BOOLEAN NOT NULL DEFAULT TRUE,
+          paused BOOLEAN NOT NULL DEFAULT FALSE,
+          operators JSONB NOT NULL DEFAULT '[]'::jsonb
+        )
+      `);
+            // Create labels table
+            await client.query(`
+        CREATE TABLE IF NOT EXISTS ${this.schema}.labels (
+          id TEXT PRIMARY KEY,
+          name TEXT NOT NULL UNIQUE,
+          color TEXT DEFAULT '#6B7280',
+          description TEXT
+        )
+      `);
+            // Create work_item_labels junction table
+            await client.query(`
+        CREATE TABLE IF NOT EXISTS ${this.schema}.work_item_labels (
+          work_item_id TEXT NOT NULL REFERENCES ${this.schema}.work_items(id) ON DELETE CASCADE,
+          label_id TEXT NOT NULL REFERENCES ${this.schema}.labels(id) ON DELETE CASCADE,
+          PRIMARY KEY (work_item_id, label_id)
+        )
+      `);
+            // Create work_item_dependencies table
+            await client.query(`
+        CREATE TABLE IF NOT EXISTS ${this.schema}.work_item_dependencies (
+          work_item_id TEXT NOT NULL REFERENCES ${this.schema}.work_items(id) ON DELETE CASCADE,
+          depends_on_id TEXT NOT NULL REFERENCES ${this.schema}.work_items(id) ON DELETE CASCADE,
+          PRIMARY KEY (work_item_id, depends_on_id)
+        )
+      `);
+            // Create work_item_relevant_files table
+            await client.query(`
+        CREATE TABLE IF NOT EXISTS ${this.schema}.work_item_relevant_files (
+          work_item_id TEXT NOT NULL REFERENCES ${this.schema}.work_items(id) ON DELETE CASCADE,
+          file_path TEXT NOT NULL,
+          PRIMARY KEY (work_item_id, file_path)
+        )
+      `);
+            // Create work_item_acceptance_criteria table
+            await client.query(`
+        CREATE TABLE IF NOT EXISTS ${this.schema}.work_item_acceptance_criteria (
+          work_item_id TEXT NOT NULL REFERENCES ${this.schema}.work_items(id) ON DELETE CASCADE,
+          criterion TEXT NOT NULL,
+          sort_order INTEGER DEFAULT 0
+        )
+      `);
+            // Create work_item_memory_links table
+            await client.query(`
+        CREATE TABLE IF NOT EXISTS ${this.schema}.work_item_memory_links (
+          work_item_id TEXT NOT NULL REFERENCES ${this.schema}.work_items(id) ON DELETE CASCADE,
+          memory_id TEXT NOT NULL,
+          linked_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+          PRIMARY KEY (work_item_id, memory_id)
+        )
+      `);
+            // Create work_item_events table
+            await client.query(`
+        CREATE TABLE IF NOT EXISTS ${this.schema}.work_item_events (
+          id TEXT PRIMARY KEY,
+          work_item_id TEXT NOT NULL REFERENCES ${this.schema}.work_items(id) ON DELETE CASCADE,
+          type TEXT NOT NULL,
+          old_value TEXT,
+          new_value TEXT,
+          content TEXT,
+          memory_id TEXT,
+          actor TEXT DEFAULT 'system',
+          created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+        )
+      `);
+            // Create milestones table
+            await client.query(`
+        CREATE TABLE IF NOT EXISTS ${this.schema}.milestones (
+          id TEXT PRIMARY KEY,
+          name TEXT NOT NULL,
+          description TEXT,
+          due_date TIMESTAMPTZ,
+          status TEXT DEFAULT 'active',
+          created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+        )
+      `);
+            // Create indexes
+            await client.query(`CREATE INDEX IF NOT EXISTS idx_work_items_project ON ${this.schema}.work_items(project_id)`);
+            await client.query(`CREATE INDEX IF NOT EXISTS idx_work_items_status ON ${this.schema}.work_items(status)`);
+            await client.query(`CREATE INDEX IF NOT EXISTS idx_work_items_priority ON ${this.schema}.work_items(priority)`);
+            await client.query(`CREATE INDEX IF NOT EXISTS idx_work_items_parent ON ${this.schema}.work_items(parent_id)`);
+            await client.query(`CREATE INDEX IF NOT EXISTS idx_work_items_azdo ON ${this.schema}.work_items(azdo_id)`);
+            await client.query(`CREATE INDEX IF NOT EXISTS idx_work_item_events_item ON ${this.schema}.work_item_events(work_item_id)`);
+            await client.query(`CREATE INDEX IF NOT EXISTS idx_work_item_events_created ON ${this.schema}.work_item_events(created_at)`);
+            // Create full-text search index (using tsvector for Postgres)
+            await client.query(`
+        CREATE INDEX IF NOT EXISTS idx_work_items_fts ON ${this.schema}.work_items
+        USING gin(to_tsvector('english', title || ' ' || COALESCE(description, '')))
+      `);
+            // Drop the legacy updated_at auto-update trigger. It force-overwrote updated_at = NOW()
+            // on every UPDATE, which made persisting a real System.ChangedDate impossible.
+            // updated_at is now written explicitly by each write path.
+            await client.query(`DROP TRIGGER IF EXISTS update_work_items_updated_at ON ${this.schema}.work_items`);
+        }
+        finally {
+            client.release();
+        }
+    }
+    // ============ WorkItem CRUD ============
+    async createWorkItem(input) {
+        const id = input.id ?? nanoid(12);
+        const now = new Date().toISOString();
+        const workItem = {
+            id,
+            projectId: input.projectId,
+            title: input.title,
+            description: input.description ?? '',
+            // No content-field fabrication: the caller's value (or undefined → SQL NULL) passes
+            // straight through. WorkItemRecord types these as required, so we assert here; a missing
+            // value surfaces as NULL in the DB and fails loudly at any call site that assumes a value.
+            status: input.status,
+            priority: input.priority,
+            source: input.source,
+            kind: input.kind,
+            area: input.area,
+            reviewState: input.reviewState,
+            resolution: input.resolution,
+            assignee: input.assignee ?? undefined,
+            milestone: input.milestone,
+            labels: input.labels ?? [],
+            dependencies: input.dependencies ?? [],
+            relevantFiles: input.relevantFiles ?? [],
+            acceptanceCriteria: input.acceptanceCriteria ?? [],
+            estimateMinutes: input.estimateMinutes,
+            complexity: input.complexity,
+            parentId: input.parentId,
+            azdoId: input.azdoId,
+            azdoIdentifier: input.azdoIdentifier,
+            azdoUrl: input.azdoUrl,
+            memoryIds: [],
+            childIds: [],
+            operatorLane: input.operatorLane,
+            isSessionRoot: input.isSessionRoot ?? false,
+            externalWorkItemId: input.externalWorkItemId,
+            createdAt: input.createdAt ?? now,
+            updatedAt: input.updatedAt ?? now,
+            closedAt: input.closedAt ?? undefined,
+        };
+        await this.createWorkItemAsync(workItem, input);
+        return workItem;
+    }
+    async createWorkItemAsync(workItem, input) {
+        const client = await this.pool.connect();
+        try {
+            await client.query('BEGIN');
+            // Insert workItem
+            await client.query(`
+        INSERT INTO ${this.schema}.work_items (id, project_id, title, description, status, priority, source,
+          kind, area, review_state, resolution, assignee, milestone, estimate_minutes, complexity,
+          parent_id, azdo_id, azdo_identifier, azdo_url,
+          operator_lane, is_session_root, external_work_item_id,
+          created_at, updated_at, closed_at)
+        VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $25)
+      `, [
+                workItem.id, workItem.projectId, workItem.title, workItem.description, workItem.status ?? null,
+                workItem.priority ?? null, workItem.source ?? null, workItem.kind ?? null, workItem.area ?? null,
+                workItem.reviewState ?? null, workItem.resolution ?? null, workItem.assignee, workItem.milestone,
+                workItem.estimateMinutes, workItem.complexity, workItem.parentId, workItem.azdoId, workItem.azdoIdentifier, workItem.azdoUrl,
+                workItem.operatorLane ?? null,
+                workItem.isSessionRoot ?? false,
+                workItem.externalWorkItemId ?? null,
+                workItem.createdAt, workItem.updatedAt, workItem.closedAt ?? null,
+            ]);
+            // Insert labels
+            if (input.labels?.length) {
+                for (const labelId of input.labels) {
+                    await client.query(`
+            INSERT INTO ${this.schema}.work_item_labels (work_item_id, label_id)
+            VALUES ($1, $2)
+            ON CONFLICT DO NOTHING
+          `, [workItem.id, labelId]);
+                }
+            }
+            // Insert dependencies
+            if (input.dependencies?.length) {
+                for (const depId of input.dependencies) {
+                    await client.query(`
+            INSERT INTO ${this.schema}.work_item_dependencies (work_item_id, depends_on_id)
+            VALUES ($1, $2)
+            ON CONFLICT DO NOTHING
+          `, [workItem.id, depId]);
+                }
+            }
+            // Insert relevant files
+            if (input.relevantFiles?.length) {
+                for (const file of input.relevantFiles) {
+                    await client.query(`
+            INSERT INTO ${this.schema}.work_item_relevant_files (work_item_id, file_path)
+            VALUES ($1, $2)
+            ON CONFLICT DO NOTHING
+          `, [workItem.id, file]);
+                }
+            }
+            // Insert acceptance criteria
+            if (input.acceptanceCriteria?.length) {
+                for (const [idx, criterion] of input.acceptanceCriteria.entries()) {
+                    await client.query(`
+            INSERT INTO ${this.schema}.work_item_acceptance_criteria (work_item_id, criterion, sort_order)
+            VALUES ($1, $2, $3)
+          `, [workItem.id, criterion, idx]);
+                }
+            }
+            await client.query('COMMIT');
+        }
+        catch (err) {
+            await client.query('ROLLBACK');
+            throw err;
+        }
+        finally {
+            client.release();
+        }
+    }
+    async getWorkItem(id) {
+        return this.getWorkItemAsync(id);
+    }
+    async getWorkItemAsync(id) {
+        const result = await this.pool.query(`
+      SELECT * FROM ${this.schema}.work_items WHERE id = $1
+    `, [id]);
+        if (result.rows.length === 0)
+            return null;
+        const row = result.rows[0];
+        return this.rowToWorkItem(row);
+    }
+    async updateWorkItem(id, patch) {
+        return this.updateWorkItemAsync(id, patch);
+    }
+    async updateWorkItemAsync(id, patch) {
+        const client = await this.pool.connect();
+        try {
+            await client.query('BEGIN');
+            // Build update query dynamically
+            const updates = [];
+            const values = [];
+            let paramIdx = 1;
+            if (patch.title !== undefined) {
+                updates.push(`title = $${paramIdx++}`);
+                values.push(patch.title);
+            }
+            if (patch.description !== undefined) {
+                updates.push(`description = $${paramIdx++}`);
+                values.push(patch.description);
+            }
+            if (patch.status !== undefined) {
+                updates.push(`status = $${paramIdx++}`);
+                values.push(patch.status);
+            }
+            if (patch.priority !== undefined) {
+                updates.push(`priority = $${paramIdx++}`);
+                values.push(patch.priority);
+            }
+            if (patch.source !== undefined) {
+                updates.push(`source = $${paramIdx++}`);
+                values.push(patch.source);
+            }
+            if (patch.kind !== undefined) {
+                updates.push(`kind = $${paramIdx++}`);
+                values.push(patch.kind);
+            }
+            if (patch.area !== undefined) {
+                updates.push(`area = $${paramIdx++}`);
+                values.push(patch.area);
+            }
+            if (patch.reviewState !== undefined) {
+                updates.push(`review_state = $${paramIdx++}`);
+                values.push(patch.reviewState);
+            }
+            if (patch.resolution !== undefined) {
+                updates.push(`resolution = $${paramIdx++}`);
+                values.push(patch.resolution);
+            }
+            if (patch.assignee !== undefined) {
+                updates.push(`assignee = $${paramIdx++}`);
+                values.push(patch.assignee);
+            }
+            if (patch.milestone !== undefined) {
+                updates.push(`milestone = $${paramIdx++}`);
+                values.push(patch.milestone);
+            }
+            if (patch.estimateMinutes !== undefined) {
+                updates.push(`estimate_minutes = $${paramIdx++}`);
+                values.push(patch.estimateMinutes);
+            }
+            if (patch.complexity !== undefined) {
+                updates.push(`complexity = $${paramIdx++}`);
+                values.push(patch.complexity);
+            }
+            if (patch.parentId !== undefined) {
+                updates.push(`parent_id = $${paramIdx++}`);
+                values.push(patch.parentId);
+            }
+            if (patch.operatorLane !== undefined) {
+                updates.push(`operator_lane = $${paramIdx++}`);
+                values.push(patch.operatorLane);
+            }
+            if (patch.isSessionRoot !== undefined) {
+                updates.push(`is_session_root = $${paramIdx++}`);
+                values.push(patch.isSessionRoot);
+            }
+            if (patch.externalWorkItemId !== undefined) {
+                updates.push(`external_work_item_id = $${paramIdx++}`);
+                values.push(patch.externalWorkItemId);
+            }
+            if (patch.createdAt !== undefined) {
+                updates.push(`created_at = $${paramIdx++}`);
+                values.push(patch.createdAt);
+            }
+            if (patch.closedAt !== undefined) {
+                updates.push(`closed_at = $${paramIdx++}`);
+                values.push(patch.closedAt);
+            }
+            // The legacy trigger that auto-bumped updated_at is gone, so write it explicitly here.
+            // A caller-supplied updatedAt (e.g. a real System.ChangedDate from sync) wins; otherwise
+            // a normal local edit bumps to NOW(). updated_at is always written on update.
+            if (patch.updatedAt !== undefined) {
+                updates.push(`updated_at = $${paramIdx++}`);
+                values.push(patch.updatedAt);
+            }
+            else {
+                updates.push(`updated_at = NOW()`);
+            }
+            if (updates.length > 0) {
+                values.push(id);
+                await client.query(`
+          UPDATE ${this.schema}.work_items
+          SET ${updates.join(', ')}
+          WHERE id = $${paramIdx}
+        `, values);
+            }
+            await client.query('COMMIT');
+            return this.getWorkItemAsync(id);
+        }
+        catch (err) {
+            await client.query('ROLLBACK');
+            throw err;
+        }
+        finally {
+            client.release();
+        }
+    }
+    async deleteWorkItem(id) {
+        return this.deleteWorkItemAsync(id);
+    }
+    async deleteWorkItemAsync(id) {
+        const result = await this.pool.query(`
+      DELETE FROM ${this.schema}.work_items WHERE id = $1
+    `, [id]);
+        return (result.rowCount ?? 0) > 0;
+    }
+    async listWorkItems(filter) {
+        return this.listWorkItemsAsync(filter);
+    }
+    async listWorkItemsAsync(filter) {
+        const where = ['1=1'];
+        const params = [];
+        let paramIdx = 1;
+        if (filter?.projectId) {
+            where.push(`project_id = $${paramIdx++}`);
+            params.push(filter.projectId);
+        }
+        if (filter?.status?.length) {
+            where.push(`status = ANY($${paramIdx++})`);
+            params.push(filter.status);
+        }
+        if (filter?.priority?.length) {
+            where.push(`priority = ANY($${paramIdx++})`);
+            params.push(filter.priority);
+        }
+        if (filter?.assignee) {
+            where.push(`assignee = $${paramIdx++}`);
+            params.push(filter.assignee);
+        }
+        if (filter?.source) {
+            where.push(`source = $${paramIdx++}`);
+            params.push(filter.source);
+        }
+        if (filter?.search) {
+            where.push(`(
+        to_tsvector('english', title || ' ' || COALESCE(description, '')) @@ plainto_tsquery('english', $${paramIdx++})
+        OR title ILIKE $${paramIdx++}
+      )`);
+            params.push(filter.search, `%${filter.search}%`);
+        }
+        const limit = filter?.limit ?? 50;
+        const offset = filter?.offset ?? 0;
+        // Get total count
+        const countResult = await this.pool.query(`
+      SELECT COUNT(*) as total FROM ${this.schema}.work_items WHERE ${where.join(' AND ')}
+    `, params);
+        const total = parseInt(countResult.rows[0].total, 10);
+        // Get workItems
+        const result = await this.pool.query(`
+      SELECT * FROM ${this.schema}.work_items
+      WHERE ${where.join(' AND ')}
+      ORDER BY created_at DESC
+      LIMIT $${paramIdx++} OFFSET $${paramIdx++}
+    `, [...params, limit, offset]);
+        const workItems = await Promise.all(result.rows.map((row) => this.loadWorkItemDetails(row)));
+        return { workItems, total };
+    }
+    async loadWorkItemDetails(row) {
+        const client = await this.pool.connect();
+        try {
+            const workItem = this.rowToWorkItem(row);
+            // Load labels
+            const labelsResult = await client.query(`
+        SELECT l.name FROM ${this.schema}.labels l
+        JOIN ${this.schema}.work_item_labels il ON l.id = il.label_id
+        WHERE il.work_item_id = $1
+      `, [workItem.id]);
+            workItem.labels = labelsResult.rows.map((r) => r.name);
+            // Load dependencies
+            const depsResult = await client.query(`
+        SELECT depends_on_id FROM ${this.schema}.work_item_dependencies WHERE work_item_id = $1
+      `, [workItem.id]);
+            workItem.dependencies = depsResult.rows.map((r) => r.depends_on_id);
+            // Load relevant files
+            const filesResult = await client.query(`
+        SELECT file_path FROM ${this.schema}.work_item_relevant_files WHERE work_item_id = $1
+      `, [workItem.id]);
+            workItem.relevantFiles = filesResult.rows.map((r) => r.file_path);
+            // Load acceptance criteria
+            const acResult = await client.query(`
+        SELECT criterion FROM ${this.schema}.work_item_acceptance_criteria
+        WHERE work_item_id = $1 ORDER BY sort_order
+      `, [workItem.id]);
+            workItem.acceptanceCriteria = acResult.rows.map((r) => r.criterion);
+            // Load memory links
+            const memResult = await client.query(`
+        SELECT memory_id FROM ${this.schema}.work_item_memory_links WHERE work_item_id = $1
+      `, [workItem.id]);
+            workItem.memoryIds = memResult.rows.map((r) => r.memory_id);
+            return workItem;
+        }
+        finally {
+            client.release();
+        }
+    }
+    rowToWorkItem(row) {
+        return {
+            id: row.id,
+            projectId: row.project_id,
+            title: row.title,
+            description: row.description ?? '',
+            status: row.status,
+            priority: row.priority,
+            source: row.source,
+            kind: row.kind ?? undefined,
+            area: row.area ?? undefined,
+            reviewState: row.review_state ?? undefined,
+            resolution: row.resolution ?? undefined,
+            labels: [],
+            assignee: row.assignee ?? undefined,
+            milestone: row.milestone ?? undefined,
+            relevantFiles: [],
+            acceptanceCriteria: [],
+            estimateMinutes: row.estimate_minutes ?? undefined,
+            complexity: row.complexity ?? undefined,
+            dependencies: [],
+            parentId: row.parent_id ?? undefined,
+            childIds: [],
+            azdoId: row.azdo_id ?? undefined,
+            azdoIdentifier: row.azdo_identifier ?? undefined,
+            azdoUrl: row.azdo_url ?? undefined,
+            operatorSessionId: row.operator_session_id ?? undefined,
+            operatorLane: row.operator_lane ?? undefined,
+            isSessionRoot: row.is_session_root === true || row.is_session_root === 't' || row.is_session_root === 1,
+            externalWorkItemId: row.external_work_item_id ?? undefined,
+            memoryIds: [],
+            createdAt: row.created_at instanceof Date
+                ? row.created_at.toISOString()
+                : row.created_at,
+            updatedAt: row.updated_at instanceof Date
+                ? row.updated_at.toISOString()
+                : row.updated_at,
+            closedAt: row.closed_at instanceof Date
+                ? row.closed_at.toISOString()
+                : (row.closed_at ?? undefined),
+        };
+    }
+    // ============ Status Changes ============
+    async changeStatus(id, status, actor) {
+        return this.changeStatusAsync(id, status, actor);
+    }
+    async changeStatusAsync(id, status, actor) {
+        const closedAt = status === 'done' || status === 'cancelled' ? new Date().toISOString() : null;
+        await this.pool.query(`
+      UPDATE ${this.schema}.work_items
+      SET status = $1, closed_at = $2, updated_at = NOW()
+      WHERE id = $3
+    `, [status, closedAt, id]);
+        // Add event
+        await this.addEvent(id, 'status_changed', {
+            newValue: status,
+            actor,
+        });
+        return this.getWorkItemAsync(id);
+    }
+    // ============ Events ============
+    async addEvent(workItemId, type, data) {
+        const event = {
+            id: nanoid(12),
+            workItemId,
+            type,
+            oldValue: data?.oldValue,
+            newValue: data?.newValue,
+            content: data?.content,
+            memoryId: data?.memoryId,
+            actor: data?.actor ?? 'system',
+            createdAt: new Date().toISOString(),
+        };
+        await this.addEventAsync(event);
+        return event;
+    }
+    async addEventAsync(event) {
+        await this.pool.query(`
+      INSERT INTO ${this.schema}.work_item_events (id, work_item_id, type, old_value, new_value, content, memory_id, actor, created_at)
+      VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+    `, [
+            event.id, event.workItemId, event.type, event.oldValue, event.newValue,
+            event.content, event.memoryId, event.actor, event.createdAt,
+        ]);
+    }
+    async getEvents(workItemId, limit) {
+        return this.getEventsAsync(workItemId, limit);
+    }
+    async getEventsAsync(workItemId, limit) {
+        const result = await this.pool.query(`
+      SELECT * FROM ${this.schema}.work_item_events
+      WHERE work_item_id = $1
+      ORDER BY created_at DESC
+      LIMIT $2
+    `, [workItemId, limit ?? 50]);
+        return result.rows.map((row) => ({
+            id: row.id,
+            workItemId: row.work_item_id,
+            type: row.type,
+            oldValue: row.old_value ?? undefined,
+            newValue: row.new_value ?? undefined,
+            content: row.content ?? undefined,
+            memoryId: row.memory_id ?? undefined,
+            actor: row.actor,
+            createdAt: row.created_at instanceof Date
+                ? row.created_at.toISOString()
+                : row.created_at,
+        }));
+    }
+    async getRecentEvents(limit) {
+        return this.getRecentEventsAsync(limit);
+    }
+    async getRecentEventsAsync(limit) {
+        const result = await this.pool.query(`
+      SELECT * FROM ${this.schema}.work_item_events
+      ORDER BY created_at DESC
+      LIMIT $1
+    `, [limit ?? 50]);
+        return result.rows.map((row) => ({
+            id: row.id,
+            workItemId: row.work_item_id,
+            type: row.type,
+            oldValue: row.old_value ?? undefined,
+            newValue: row.new_value ?? undefined,
+            content: row.content ?? undefined,
+            memoryId: row.memory_id ?? undefined,
+            actor: row.actor,
+            createdAt: row.created_at instanceof Date
+                ? row.created_at.toISOString()
+                : row.created_at,
+        }));
+    }
+    // ============ Labels ============
+    async createLabel(name, color, description) {
+        const label = {
+            id: nanoid(12),
+            name,
+            color: color ?? '#6B7280',
+            description,
+        };
+        await this.createLabelAsync(label);
+        return label;
+    }
+    async createLabelAsync(label) {
+        await this.pool.query(`
+      INSERT INTO ${this.schema}.labels (id, name, color, description)
+      VALUES ($1, $2, $3, $4)
+      ON CONFLICT (name) DO NOTHING
+    `, [label.id, label.name, label.color, label.description]);
+    }
+    async listLabels() {
+        return this.listLabelsAsync();
+    }
+    async listLabelsAsync() {
+        const result = await this.pool.query(`SELECT * FROM ${this.schema}.labels`);
+        return result.rows.map((row) => ({
+            id: row.id,
+            name: row.name,
+            color: row.color,
+            description: row.description ?? undefined,
+        }));
+    }
+    async deleteLabel(id) {
+        return this.deleteLabelAsync(id);
+    }
+    async deleteLabelAsync(id) {
+        const result = await this.pool.query(`
+      DELETE FROM ${this.schema}.labels WHERE id = $1
+    `, [id]);
+        return (result.rowCount ?? 0) > 0;
+    }
+    // ============ Milestones ============
+    async createMilestone(name, description, dueDate) {
+        const milestone = {
+            id: nanoid(12),
+            name,
+            description,
+            dueDate,
+            status: 'active',
+            createdAt: new Date().toISOString(),
+        };
+        await this.createMilestoneAsync(milestone);
+        return milestone;
+    }
+    async createMilestoneAsync(milestone) {
+        await this.pool.query(`
+      INSERT INTO ${this.schema}.milestones (id, name, description, due_date, status, created_at)
+      VALUES ($1, $2, $3, $4, $5, $6)
+    `, [
+            milestone.id, milestone.name, milestone.description,
+            milestone.dueDate, milestone.status, milestone.createdAt,
+        ]);
+    }
+    async listMilestones() {
+        return this.listMilestonesAsync();
+    }
+    async listMilestonesAsync() {
+        const result = await this.pool.query(`
+      SELECT * FROM ${this.schema}.milestones WHERE status = 'active'
+    `);
+        return result.rows.map((row) => ({
+            id: row.id,
+            name: row.name,
+            description: row.description ?? undefined,
+            dueDate: row.due_date ?? undefined,
+            status: row.status,
+            createdAt: row.created_at instanceof Date
+                ? row.created_at.toISOString()
+                : row.created_at,
+        }));
+    }
+    // ============ Memory Links ============
+    async linkMemory(workItemId, memoryId) {
+        await this.linkMemoryAsync(workItemId, memoryId);
+    }
+    async linkMemoryAsync(workItemId, memoryId) {
+        await this.pool.query(`
+      INSERT INTO ${this.schema}.work_item_memory_links (work_item_id, memory_id, linked_at)
+      VALUES ($1, $2, NOW())
+      ON CONFLICT DO NOTHING
+    `, [workItemId, memoryId]);
+    }
+    async getLinkedMemories(workItemId) {
+        return this.getLinkedMemoriesAsync(workItemId);
+    }
+    async getLinkedMemoriesAsync(workItemId) {
+        const result = await this.pool.query(`
+      SELECT memory_id FROM ${this.schema}.work_item_memory_links WHERE work_item_id = $1
+    `, [workItemId]);
+        return result.rows.map((r) => r.memory_id);
+    }
+    // ============ Stats ============
+    async getStats() {
+        return this.getStatsAsync();
+    }
+    async getStatsAsync() {
+        const client = await this.pool.connect();
+        try {
+            // Total count
+            const totalResult = await client.query(`SELECT COUNT(*) as count FROM ${this.schema}.work_items`);
+            const total = parseInt(totalResult.rows[0].count, 10);
+            // By status
+            const statusResult = await client.query(`
+        SELECT status, COUNT(*) as count FROM ${this.schema}.work_items GROUP BY status
+      `);
+            const byStatus = {};
+            for (const row of statusResult.rows) {
+                byStatus[row.status] = parseInt(row.count, 10);
+            }
+            // By priority
+            const priorityResult = await client.query(`
+        SELECT priority, COUNT(*) as count FROM ${this.schema}.work_items GROUP BY priority
+      `);
+            const byPriority = {};
+            for (const row of priorityResult.rows) {
+                byPriority[row.priority] = parseInt(row.count, 10);
+            }
+            // By project
+            const projectResult = await client.query(`
+        SELECT project_id, COUNT(*) as count FROM ${this.schema}.work_items GROUP BY project_id
+      `);
+            const byProject = {};
+            for (const row of projectResult.rows) {
+                byProject[row.project_id] = parseInt(row.count, 10);
+            }
+            // Recently created (7 days)
+            const createdResult = await client.query(`
+        SELECT COUNT(*) as count FROM ${this.schema}.work_items
+        WHERE created_at > NOW() - INTERVAL '7 days'
+      `);
+            const recentlyCreated = parseInt(createdResult.rows[0].count, 10);
+            // Recently closed (7 days)
+            const closedResult = await client.query(`
+        SELECT COUNT(*) as count FROM ${this.schema}.work_items
+        WHERE closed_at > NOW() - INTERVAL '7 days'
+      `);
+            const recentlyClosed = parseInt(closedResult.rows[0].count, 10);
+            return {
+                total,
+                byStatus,
+                byPriority,
+                byProject,
+                recentlyCreated,
+                recentlyClosed,
+            };
+        }
+        finally {
+            client.release();
+        }
+    }
+    // ============ AzDO mirror payload (sync stubs — not yet wired to pool) ============
+    async setPayloadJson(workItemId, json) {
+        await this.pool.query(`UPDATE ${this.schema}.work_items SET payload_json = $1::jsonb WHERE id = $2`, [json, workItemId]);
+    }
+    async getPayloadJson(workItemId) {
+        const result = await this.pool.query(`SELECT payload_json FROM ${this.schema}.work_items WHERE id = $1`, [workItemId]);
+        if (result.rows.length === 0)
+            return null;
+        const value = result.rows[0].payload_json;
+        return value == null ? null : JSON.stringify(value);
+    }
+    async updateOperatorSessionId(workItemId, sessionId) {
+        await this.pool.query(`UPDATE ${this.schema}.work_items SET operator_session_id = $1, updated_at = NOW() WHERE id = $2`, [sessionId, workItemId]);
+    }
+    async pruneOrphans(source, keepIds) {
+        const result = await this.pool.query(`SELECT id FROM ${this.schema}.work_items WHERE source = $1`, [source]);
+        const ids = result.rows.map((row) => row.id);
+        const toDelete = ids.filter((id) => !keepIds.has(id));
+        if (toDelete.length === 0)
+            return 0;
+        await this.pool.query(`DELETE FROM ${this.schema}.work_items WHERE id = ANY($1::text[])`, [toDelete]);
+        return toDelete.length;
+    }
+    // ============ Sync watermarks ============
+    async getSyncMeta(key) {
+        const result = await this.pool.query(`SELECT value FROM ${this.schema}.sync_meta WHERE key = $1`, [key]);
+        return result.rows[0]?.value ?? null;
+    }
+    async setSyncMeta(key, value) {
+        await this.pool.query(`INSERT INTO ${this.schema}.sync_meta (key, value)
+       VALUES ($1, $2)
+       ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = NOW()`, [key, value]);
+    }
+    async getProjectConfigs() {
+        const result = await this.pool.query(`SELECT name, path, heartbeat_ms, azdo_label, enabled, paused, operators
+         FROM ${this.schema}.projects
+        ORDER BY name ASC`);
+        return result.rows.map((row) => ({
+            name: String(row.name),
+            path: String(row.path),
+            heartbeatMs: Number(row.heartbeat_ms),
+            azdoLabel: row.azdo_label ? String(row.azdo_label) : undefined,
+            enabled: Boolean(row.enabled),
+            paused: Boolean(row.paused),
+            operators: Array.isArray(row.operators)
+                ? row.operators.map((value) => String(value))
+                : [],
+        }));
+    }
+    async seedProjectConfigsIfEmpty(projects) {
+        if (projects.length === 0) {
+            return this.getProjectConfigs();
+        }
+        const client = await this.pool.connect();
+        try {
+            await client.query('BEGIN');
+            const countResult = await client.query(`SELECT COUNT(*)::int AS count FROM ${this.schema}.projects`);
+            const count = Number(countResult.rows[0]?.count ?? 0);
+            if (count === 0) {
+                for (const project of projects) {
+                    await client.query(`INSERT INTO ${this.schema}.projects
+              (name, path, heartbeat_ms, azdo_label, enabled, paused, operators)
+             VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb)`, [
+                        project.name,
+                        project.path,
+                        project.heartbeatMs,
+                        project.azdoLabel ?? null,
+                        project.enabled,
+                        project.paused,
+                        JSON.stringify(project.operators ?? []),
+                    ]);
+                }
+            }
+            await client.query('COMMIT');
+        }
+        catch (error) {
+            await client.query('ROLLBACK');
+            throw error;
+        }
+        finally {
+            client.release();
+        }
+        return this.getProjectConfigs();
+    }
+    // ============ Sync interface (compatibility) ============
+    // These methods ensure interface compatibility but log warnings
+    async syncListWorkItems(filter) {
+        return this.listWorkItemsAsync(filter);
+    }
+    async syncGetStats() {
+        return this.getStatsAsync();
+    }
+}
+// Factory function to create appropriate store based on config
+export function createWorkItemStore(config) {
+    if (config.type === 'postgres') {
+        return new PostgresWorkItemStore(config.postgres ?? {});
+    }
+    // Return SQLite store via the config-aware index, not sqliteStore directly
+    throw new Error('Use openSqliteWorkItemStore() from sqliteStore.js for SQLite directly, or getWorkItemStore() from workItems/index.js');
+}
+//# sourceMappingURL=postgresStore.js.map