@proletariat/cli 0.2.0 → 0.3.0

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

@@ -0,0 +1,355 @@
+/**
+ * Board view operations.
+ */
+import { PMO_TABLES } from '../schema.js';
+import { PMOError, } from '../types.js';
+import { slugify } from '../utils.js';
+import { getAcceptanceCriteriaSync } from './helpers.js';
+const T = PMO_TABLES;
+export class ViewStorage {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /**
+     * List board views.
+     */
+    async listBoardViews(filter) {
+        let sql = `SELECT * FROM ${T.board_views}`;
+        const conditions = [];
+        const params = [];
+        if (filter?.projectId) {
+            conditions.push('project_id = ?');
+            params.push(filter.projectId);
+        }
+        if (filter?.isDefault !== undefined) {
+            conditions.push('is_default = ?');
+            params.push(filter.isDefault ? 1 : 0);
+        }
+        if (filter?.search) {
+            conditions.push('(name LIKE ? OR description LIKE ?)');
+            const searchTerm = `%${filter.search}%`;
+            params.push(searchTerm, searchTerm);
+        }
+        if (conditions.length > 0) {
+            sql += ' WHERE ' + conditions.join(' AND ');
+        }
+        sql += ' ORDER BY is_default DESC, name ASC';
+        const rows = this.ctx.db.prepare(sql).all(...params);
+        return rows.map((row) => this.rowToBoardView(row));
+    }
+    /**
+     * Get a board view by ID.
+     */
+    async getBoardView(id) {
+        const row = this.ctx.db.prepare(`SELECT * FROM ${T.board_views} WHERE id = ?`).get(id);
+        if (!row)
+            return null;
+        return this.rowToBoardView(row);
+    }
+    /**
+     * Create a new board view.
+     */
+    async createBoardView(view) {
+        if (!view.projectId) {
+            throw new PMOError('INVALID', 'Project ID is required');
+        }
+        if (!view.name) {
+            throw new PMOError('INVALID', 'View name is required');
+        }
+        const id = view.id || slugify(view.name) + '-' + Date.now().toString(36);
+        const now = Date.now();
+        const filters = JSON.stringify(view.filters || {});
+        // If this is set as default, unset other defaults for this project
+        if (view.isDefault) {
+            this.ctx.db.prepare(`
+        UPDATE ${T.board_views} SET is_default = 0 WHERE project_id = ?
+      `).run(view.projectId);
+        }
+        this.ctx.db.prepare(`
+      INSERT INTO ${T.board_views} (id, project_id, name, description, is_default, filters, group_by, sort_by, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, view.projectId, view.name, view.description || null, view.isDefault ? 1 : 0, filters, view.groupBy || null, view.sortBy || null, now, now);
+        return (await this.getBoardView(id));
+    }
+    /**
+     * Update a board view.
+     */
+    async updateBoardView(id, changes) {
+        const existing = await this.getBoardView(id);
+        if (!existing) {
+            throw new PMOError('NOT_FOUND', `Board view not found: ${id}`);
+        }
+        const updates = ['updated_at = ?'];
+        const params = [Date.now()];
+        if (changes.name !== undefined) {
+            updates.push('name = ?');
+            params.push(changes.name);
+        }
+        if (changes.description !== undefined) {
+            updates.push('description = ?');
+            params.push(changes.description || null);
+        }
+        if (changes.isDefault !== undefined) {
+            // If setting as default, unset other defaults for this project
+            if (changes.isDefault) {
+                this.ctx.db.prepare(`
+          UPDATE ${T.board_views} SET is_default = 0 WHERE project_id = ?
+        `).run(existing.projectId);
+            }
+            updates.push('is_default = ?');
+            params.push(changes.isDefault ? 1 : 0);
+        }
+        if (changes.filters !== undefined) {
+            updates.push('filters = ?');
+            params.push(JSON.stringify(changes.filters));
+        }
+        if (changes.groupBy !== undefined) {
+            updates.push('group_by = ?');
+            params.push(changes.groupBy || null);
+        }
+        if (changes.sortBy !== undefined) {
+            updates.push('sort_by = ?');
+            params.push(changes.sortBy || null);
+        }
+        params.push(id);
+        this.ctx.db.prepare(`UPDATE ${T.board_views} SET ${updates.join(', ')} WHERE id = ?`).run(...params);
+        return (await this.getBoardView(id));
+    }
+    /**
+     * Delete a board view.
+     */
+    async deleteBoardView(id) {
+        const result = this.ctx.db.prepare(`DELETE FROM ${T.board_views} WHERE id = ?`).run(id);
+        if (result.changes === 0) {
+            throw new PMOError('NOT_FOUND', `Board view not found: ${id}`);
+        }
+    }
+    /**
+     * Get the default board view for a project.
+     */
+    async getDefaultBoardView(projectId) {
+        const row = this.ctx.db.prepare(`
+      SELECT * FROM ${T.board_views} WHERE project_id = ? AND is_default = 1
+    `).get(projectId);
+        if (!row)
+            return null;
+        return this.rowToBoardView(row);
+    }
+    /**
+     * Get board with optional filters applied.
+     */
+    async getBoardWithView(projectId, viewId, filters) {
+        let viewFilters = {};
+        let viewSortBy;
+        // Load view if specified
+        if (viewId) {
+            const view = await this.getBoardView(viewId);
+            if (view) {
+                viewFilters = view.filters;
+                viewSortBy = view.sortBy;
+            }
+        }
+        // Override with explicit filters if provided
+        const effectiveFilters = { ...viewFilters, ...filters };
+        // Get project metadata
+        const projectRow = this.ctx.db.prepare(`SELECT * FROM ${T.projects} WHERE id = ?`).get(projectId);
+        if (!projectRow) {
+            throw new PMOError('NOT_FOUND', `Project not found: ${projectId}. Run init() first.`);
+        }
+        // Get the project's workflow
+        const projectMeta = this.ctx.db.prepare(`
+      SELECT workflow_id FROM ${T.projects} WHERE id = ?
+    `).get(projectId);
+        const workflowId = projectMeta?.workflow_id || 'default';
+        // Get workflow statuses as columns
+        const columnRows = this.ctx.db.prepare(`
+      SELECT id, workflow_id, name, position
+      FROM ${T.workflow_statuses}
+      WHERE workflow_id = ?
+      ORDER BY position
+    `).all(workflowId);
+        // Filter columns if columnIds filter is set
+        const filteredColumnRows = effectiveFilters.columnIds?.length
+            ? columnRows.filter((col) => effectiveFilters.columnIds.includes(col.id))
+            : columnRows;
+        // Get tickets with filters applied
+        const columns = await Promise.all(filteredColumnRows.map(async (col) => {
+            const tickets = await this.getTicketsForColumnWithFilters(col.id, projectId, effectiveFilters);
+            // Apply sorting if specified
+            const sortedTickets = viewSortBy ? this.sortTickets(tickets, viewSortBy) : tickets;
+            return {
+                id: col.id,
+                name: col.name,
+                position: col.position,
+                tickets: sortedTickets,
+            };
+        }));
+        return {
+            id: projectRow.id,
+            name: projectRow.name,
+            columns,
+            updatedAt: new Date(projectRow.updated_at),
+        };
+    }
+    /**
+     * Get tickets for a column (workflow status) with filters applied.
+     */
+    async getTicketsForColumnWithFilters(columnId, projectId, filters) {
+        // columnId is now a workflow_status id
+        let sql = `
+      SELECT t.*,
+             ws.position as board_position,
+             ws.name as column_name,
+             ws.name as status_name,
+             ws.category as status_category
+      FROM ${T.tickets} t
+      LEFT JOIN ${T.workflow_statuses} ws ON t.status_id = ws.id
+      WHERE t.status_id = ? AND t.project_id = ?
+    `;
+        const params = [columnId, projectId];
+        // Apply filters
+        if (filters.assignee !== undefined) {
+            if (filters.assignee === 'unassigned') {
+                sql += ' AND (t.assignee IS NULL OR t.assignee = "")';
+            }
+            else {
+                sql += ' AND t.assignee = ?';
+                params.push(filters.assignee);
+            }
+        }
+        if (filters.owner !== undefined) {
+            sql += ' AND t.owner = ?';
+            params.push(filters.owner);
+        }
+        if (filters.priority !== undefined) {
+            sql += ' AND UPPER(t.priority) = UPPER(?)';
+            params.push(filters.priority);
+        }
+        if (filters.statusCategory !== undefined) {
+            sql += ' AND ws.category = ?';
+            params.push(filters.statusCategory);
+        }
+        if (filters.statusId !== undefined) {
+            sql += ' AND t.status_id = ?';
+            params.push(filters.statusId);
+        }
+        if (filters.epicId !== undefined) {
+            sql += ' AND t.epic_id = ?';
+            params.push(filters.epicId);
+        }
+        if (filters.search !== undefined) {
+            sql += ' AND (t.title LIKE ? OR t.description LIKE ?)';
+            const searchTerm = `%${filters.search}%`;
+            params.push(searchTerm, searchTerm);
+        }
+        // Order by priority then created_at
+        sql += ` ORDER BY
+      CASE t.priority
+        WHEN 'P0' THEN 0
+        WHEN 'P1' THEN 1
+        WHEN 'P2' THEN 2
+        WHEN 'P3' THEN 3
+        ELSE 4
+      END,
+      t.created_at ASC`;
+        const rows = this.ctx.db.prepare(sql).all(...params);
+        return Promise.all(rows.map((row) => this.rowToTicketWithColumn(row)));
+    }
+    async rowToTicketWithColumn(row) {
+        // Get subtasks
+        const subtaskRows = this.ctx.db.prepare(`
+      SELECT * FROM ${T.subtasks} WHERE ticket_id = ? ORDER BY position
+    `).all(row.id);
+        const subtasks = subtaskRows.map((s) => ({
+            id: s.id,
+            title: s.title,
+            done: s.done === 1,
+        }));
+        // Get metadata
+        const metadataRows = this.ctx.db.prepare(`
+      SELECT key, value FROM ${T.ticket_metadata} WHERE ticket_id = ?
+    `).all(row.id);
+        const metadata = {};
+        for (const m of metadataRows) {
+            metadata[m.key] = m.value;
+        }
+        // Parse labels from JSON
+        let labels = [];
+        try {
+            labels = row.labels ? JSON.parse(row.labels) : [];
+        }
+        catch {
+            labels = [];
+        }
+        return {
+            id: row.id,
+            title: row.title,
+            description: row.description || undefined,
+            priority: row.priority || undefined,
+            category: row.category || undefined,
+            statusId: row.status_id || '',
+            statusName: row.status_name || undefined,
+            statusCategory: row.status_category,
+            status: row.status,
+            owner: row.owner || undefined,
+            assignee: row.assignee || undefined,
+            branch: row.branch || undefined,
+            specId: row.spec_id || undefined,
+            epicId: row.epic_id || undefined,
+            subtasks,
+            labels,
+            metadata,
+            acceptanceCriteria: getAcceptanceCriteriaSync(this.ctx.db, row.id),
+            createdAt: new Date(row.created_at),
+            updatedAt: new Date(row.updated_at),
+            lastSyncedFromSpec: row.last_synced_from_spec
+                ? new Date(row.last_synced_from_spec)
+                : undefined,
+            lastSyncedFromBoard: row.last_synced_from_board
+                ? new Date(row.last_synced_from_board)
+                : undefined,
+        };
+    }
+    sortTickets(tickets, sortBy) {
+        const sorted = [...tickets];
+        switch (sortBy) {
+            case 'priority': {
+                const priorityOrder = { HIGH: 0, MEDIUM: 1, LOW: 2 };
+                sorted.sort((a, b) => {
+                    const aOrder = priorityOrder[(a.priority || 'MEDIUM').toUpperCase()] ?? 3;
+                    const bOrder = priorityOrder[(b.priority || 'MEDIUM').toUpperCase()] ?? 3;
+                    return aOrder - bOrder;
+                });
+                break;
+            }
+            case 'created':
+                sorted.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+                break;
+            case 'updated':
+                sorted.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+                break;
+            case 'title':
+                sorted.sort((a, b) => a.title.localeCompare(b.title));
+                break;
+            case 'assignee':
+                sorted.sort((a, b) => (a.assignee || '').localeCompare(b.assignee || ''));
+                break;
+        }
+        return sorted;
+    }
+    rowToBoardView(row) {
+        return {
+            id: row.id,
+            projectId: row.project_id,
+            name: row.name,
+            description: row.description || undefined,
+            isDefault: row.is_default === 1,
+            filters: row.filters ? JSON.parse(row.filters) : {},
+            groupBy: row.group_by,
+            sortBy: row.sort_by,
+            createdAt: new Date(row.created_at),
+            updatedAt: new Date(row.updated_at),
+        };
+    }
+}

package/dist/lib/pmo/storage-sqlite.d.ts

@@ -0,0 +1,7 @@
+/**
+ * SQLite Storage Implementation for PMO
+ *
+ * This file re-exports from the storage/ module for backward compatibility.
+ * The implementation has been split into domain-specific modules.
+ */
+export { SQLiteStorage } from './storage/index.js';

package/dist/lib/pmo/storage-sqlite.js

@@ -0,0 +1,7 @@
+/**
+ * SQLite Storage Implementation for PMO
+ *
+ * This file re-exports from the storage/ module for backward compatibility.
+ * The implementation has been split into domain-specific modules.
+ */
+export { SQLiteStorage } from './storage/index.js';

package/dist/lib/pmo/sync-manager.d.ts

@@ -0,0 +1,92 @@
+/**
+ * PMO Sync Manager
+ *
+ * Handles automatic bi-directional sync between SQLite database and board.md:
+ * - Auto-sync from board.md before read operations (if file is newer)
+ * - Auto-export to board.md after write operations
+ *
+ * Uses hybrid mtime + content-based sync detection:
+ * 1. Check mtime first (fast) - if unchanged, skip
+ * 2. If mtime changed, compare content - if same, just update stored mtime
+ * 3. If content differs, perform full sync
+ *
+ * Multi-project support:
+ * - Default project: pmo/board.md
+ * - Other projects: pmo/board-{projectId}.md
+ *
+ * Clock source: Uses filesystem mtime which comes from the OS system clock
+ * (computer/VM clock depending on where the filesystem resides)
+ */
+import { SQLiteStorage } from './storage-sqlite.js';
+/**
+ * Get the board path for a project
+ * Standard: pmo/projects/{projectId}/kanban.md
+ * Falls back to legacy paths for backwards compatibility
+ */
+export declare function getBoardPath(pmoPath: string, projectId: string): string;
+export interface SyncMetadata {
+    lastSyncAt: number;
+    lastBoardMtime: number;
+    lastDbWriteAt: number;
+    contentHash?: string;
+}
+export interface PMOContext {
+    pmoPath: string;
+    storage: SQLiteStorage;
+    storageType: 'sqlite' | 'git';
+}
+/**
+ * Get sync metadata from database
+ */
+export declare function getSyncMetadata(storage: SQLiteStorage): SyncMetadata | null;
+/**
+ * Update sync metadata after a sync operation
+ */
+export declare function updateSyncMetadata(storage: SQLiteStorage, boardMtime: number, contentHash?: string): void;
+/**
+ * Check if board.md mtime has changed (fast check)
+ */
+export declare function boardMtimeChanged(pmoPath: string, storage: SQLiteStorage, projectId?: string): boolean;
+/**
+ * Check if board.md content has actually changed (slower, content-based check)
+ * Only called when mtime indicates a potential change
+ */
+export declare function boardContentChanged(pmoPath: string, storage: SQLiteStorage, content: string): boolean;
+/**
+ * Auto-sync from board.md if it has changes
+ * Uses hybrid mtime + content approach:
+ * 1. If mtime unchanged -> skip (fast path)
+ * 2. If mtime changed -> check content hash
+ * 3. If content same -> just update mtime, skip sync
+ * 4. If content different -> perform sync
+ *
+ * Returns: true if sync performed, false otherwise
+ */
+export declare function autoSyncFromBoard(pmoPath: string, storage: SQLiteStorage, logger?: (msg: string) => void, projectId?: string): boolean;
+/**
+ * Auto-export database to board.md after write operations
+ *
+ * DISABLED: Markdown sync is disabled. DB is the sole source of truth.
+ * To re-enable, uncomment the function body below.
+ */
+export declare function autoExportToBoard(_pmoPath: string, _storage: SQLiteStorage, _logger?: (msg: string) => void, _projectId?: string): Promise<void>;
+/**
+ * Get the workspace.db path from a PMO path
+ * PMO can be at <workspace>/pmo or <workspace>/repos/<repo>/pmo
+ * workspace.db is always at <workspace>/.proletariat/workspace.db
+ */
+export declare function getWorkspaceDbPath(pmoPath: string): string;
+/**
+ * Get storage with auto-sync from board.md (for read operations)
+ * Use this when you need to READ from the database
+ *
+ * Note: storageType parameter controls sync strategy, not storage engine.
+ * - All modes use SQLite (workspace.db) for storage
+ * - 'git' mode enables multi-machine sync via git push/pull
+ * - 'sqlite' mode is local-only (no multi-machine sync)
+ */
+export declare function getStorageWithAutoSync(pmoPath: string, storageType: 'sqlite' | 'git', logger?: (msg: string) => void): SQLiteStorage;
+/**
+ * Wrapper for write operations that auto-exports to board.md after
+ */
+export declare function withAutoExport<T>(pmoPath: string, storage: SQLiteStorage, operation: () => Promise<T>, logger?: (msg: string) => void): Promise<T>;

package/dist/lib/pmo/sync-manager.js

@@ -0,0 +1,229 @@
+/**
+ * PMO Sync Manager
+ *
+ * Handles automatic bi-directional sync between SQLite database and board.md:
+ * - Auto-sync from board.md before read operations (if file is newer)
+ * - Auto-export to board.md after write operations
+ *
+ * Uses hybrid mtime + content-based sync detection:
+ * 1. Check mtime first (fast) - if unchanged, skip
+ * 2. If mtime changed, compare content - if same, just update stored mtime
+ * 3. If content differs, perform full sync
+ *
+ * Multi-project support:
+ * - Default project: pmo/board.md
+ * - Other projects: pmo/board-{projectId}.md
+ *
+ * Clock source: Uses filesystem mtime which comes from the OS system clock
+ * (computer/VM clock depending on where the filesystem resides)
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+import { SQLiteStorage } from './storage-sqlite.js';
+import { parseBoard } from './markdown.js';
+/**
+ * Get the board path for a project
+ * Standard: pmo/projects/{projectId}/kanban.md
+ * Falls back to legacy paths for backwards compatibility
+ */
+export function getBoardPath(pmoPath, projectId) {
+    const kanbanPath = path.join(pmoPath, 'projects', projectId, 'kanban.md');
+    const legacyBoardPath = path.join(pmoPath, 'projects', projectId, 'board.md');
+    const legacyProjectKanbanPath = path.join(pmoPath, 'projects', projectId, `${projectId}-kanban.md`);
+    const legacyProjectPath = path.join(pmoPath, 'projects', projectId, `${projectId}.md`);
+    // Check paths in order of preference
+    if (fs.existsSync(kanbanPath)) {
+        return kanbanPath;
+    }
+    if (fs.existsSync(legacyBoardPath)) {
+        return legacyBoardPath;
+    }
+    if (fs.existsSync(legacyProjectKanbanPath)) {
+        return legacyProjectKanbanPath;
+    }
+    if (fs.existsSync(legacyProjectPath)) {
+        return legacyProjectPath;
+    }
+    // Default to standard kanban.md for new projects
+    return kanbanPath;
+}
+/**
+ * Compute SHA-256 hash of content
+ */
+function computeHash(content) {
+    return crypto.createHash('sha256').update(content).digest('hex');
+}
+/**
+ * Get sync metadata from database
+ */
+export function getSyncMetadata(storage) {
+    const meta = storage.getCacheMetadata();
+    if (!meta)
+        return null;
+    return {
+        lastSyncAt: meta.cacheBuiltAt,
+        lastBoardMtime: meta.boardMtime,
+        lastDbWriteAt: meta.cacheBuiltAt,
+        contentHash: meta.contentHash,
+    };
+}
+/**
+ * Update sync metadata after a sync operation
+ */
+export function updateSyncMetadata(storage, boardMtime, contentHash) {
+    storage.setCacheMetadata({
+        boardMtime,
+        cacheBuiltAt: Date.now(),
+        contentHash,
+    });
+}
+/**
+ * Check if board.md mtime has changed (fast check)
+ */
+export function boardMtimeChanged(pmoPath, storage, projectId = 'default') {
+    const boardPath = getBoardPath(pmoPath, projectId);
+    if (!fs.existsSync(boardPath)) {
+        return false;
+    }
+    const stats = fs.statSync(boardPath);
+    const meta = getSyncMetadata(storage);
+    if (!meta) {
+        // No sync metadata - board.md exists but never synced
+        return true;
+    }
+    // board.md mtime differs from last sync
+    return stats.mtimeMs !== meta.lastBoardMtime;
+}
+/**
+ * Check if board.md content has actually changed (slower, content-based check)
+ * Only called when mtime indicates a potential change
+ */
+export function boardContentChanged(pmoPath, storage, content) {
+    const meta = getSyncMetadata(storage);
+    if (!meta || !meta.contentHash) {
+        // No content hash stored - assume changed
+        return true;
+    }
+    const currentHash = computeHash(content);
+    return currentHash !== meta.contentHash;
+}
+/**
+ * Auto-sync from board.md if it has changes
+ * Uses hybrid mtime + content approach:
+ * 1. If mtime unchanged -> skip (fast path)
+ * 2. If mtime changed -> check content hash
+ * 3. If content same -> just update mtime, skip sync
+ * 4. If content different -> perform sync
+ *
+ * Returns: true if sync performed, false otherwise
+ */
+export function autoSyncFromBoard(pmoPath, storage, logger, projectId = 'default') {
+    const boardPath = getBoardPath(pmoPath, projectId);
+    if (!fs.existsSync(boardPath)) {
+        return false;
+    }
+    // Fast path: mtime unchanged
+    if (!boardMtimeChanged(pmoPath, storage, projectId)) {
+        return false;
+    }
+    // Mtime changed - read content and check hash
+    const markdown = fs.readFileSync(boardPath, 'utf-8');
+    const stats = fs.statSync(boardPath);
+    const contentHash = computeHash(markdown);
+    // Check if content actually changed
+    if (!boardContentChanged(pmoPath, storage, markdown)) {
+        // Content same, just update mtime (file was touched but not modified)
+        updateSyncMetadata(storage, stats.mtimeMs, contentHash);
+        if (logger) {
+            logger(`📋 ${path.basename(boardPath)} touched but unchanged, updated mtime`);
+        }
+        return false;
+    }
+    // Content changed - perform full sync
+    const board = parseBoard(markdown, projectId);
+    storage.rebuildFromBoard(board);
+    // Update sync metadata with new mtime and hash
+    updateSyncMetadata(storage, stats.mtimeMs, contentHash);
+    if (logger) {
+        logger(`📥 Auto-synced from ${path.basename(boardPath)}`);
+    }
+    return true;
+}
+/**
+ * Auto-export database to board.md after write operations
+ *
+ * DISABLED: Markdown sync is disabled. DB is the sole source of truth.
+ * To re-enable, uncomment the function body below.
+ */
+export async function autoExportToBoard(_pmoPath, _storage, _logger, _projectId) {
+    // DISABLED: Markdown export disabled - DB is source of truth
+    // Uncomment below to re-enable:
+    /*
+    const pid = _projectId ?? _storage.getCurrentProjectId();
+    const boardPath = getBoardPath(_pmoPath, pid);
+  
+    // Generate markdown from current database state
+    const markdown = await _storage.getBoardMarkdown();
+  
+    // Write to board.md
+    fs.writeFileSync(boardPath, markdown);
+  
+    // Update sync metadata with new mtime and content hash
+    const stats = fs.statSync(boardPath);
+    const contentHash = computeHash(markdown);
+    updateSyncMetadata(_storage, stats.mtimeMs, contentHash);
+  
+    if (_logger) {
+      _logger(`📤 Auto-exported to ${path.basename(boardPath)}`);
+    }
+    */
+}
+/**
+ * Get the workspace.db path from a PMO path
+ * PMO can be at <workspace>/pmo or <workspace>/repos/<repo>/pmo
+ * workspace.db is always at <workspace>/.proletariat/workspace.db
+ */
+export function getWorkspaceDbPath(pmoPath) {
+    // Search upward from PMO path to find .proletariat/workspace.db
+    let currentDir = path.dirname(pmoPath); // Start from parent of pmo/
+    while (currentDir !== '/') {
+        const dbPath = path.join(currentDir, '.proletariat', 'workspace.db');
+        if (fs.existsSync(dbPath)) {
+            return dbPath;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    // Fallback to old behavior if not found
+    const workspacePath = path.dirname(pmoPath);
+    return path.join(workspacePath, '.proletariat', 'workspace.db');
+}
+/**
+ * Get storage with auto-sync from board.md (for read operations)
+ * Use this when you need to READ from the database
+ *
+ * Note: storageType parameter controls sync strategy, not storage engine.
+ * - All modes use SQLite (workspace.db) for storage
+ * - 'git' mode enables multi-machine sync via git push/pull
+ * - 'sqlite' mode is local-only (no multi-machine sync)
+ */
+export function getStorageWithAutoSync(pmoPath, storageType, logger) {
+    // Storage is always workspace.db (unified PMO tables with foreign keys to agents)
+    const dbPath = getWorkspaceDbPath(pmoPath);
+    if (!fs.existsSync(dbPath)) {
+        throw new Error(`Database not found at ${dbPath}. Run 'prlt init' first.`);
+    }
+    // Note: Storage no longer holds project context - projectId is passed explicitly to operations
+    const storage = new SQLiteStorage(dbPath);
+    return storage;
+}
+/**
+ * Wrapper for write operations that auto-exports to board.md after
+ */
+export async function withAutoExport(pmoPath, storage, operation, logger) {
+    // Run the operation
+    const result = await operation();
+    // Auto-export to board.md
+    await autoExportToBoard(pmoPath, storage, logger);
+    return result;
+}