@aquex/cmos-mcp 1.0.0

package/dist/tools/cmos/cmos-db-backfill.js

@@ -0,0 +1,889 @@
+"use strict";
+// ABOUTME: cmos_db backfill action — replays CMOS state as sync events to the dashboard PG mirror.
+// ABOUTME: Includes large-delta guard, per-request timeout, overall wall-clock timeout, and progress logging.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LARGE_DELTA_THRESHOLD = void 0;
+exports.cmosDbBackfill = cmosDbBackfill;
+exports.cmosDbReconcile = cmosDbReconcile;
+exports.formatReconciliationForLLM = formatReconciliationForLLM;
+exports.identifyPgOrphans = identifyPgOrphans;
+exports.formatPgOrphanReportForLLM = formatPgOrphanReportForLLM;
+exports.cmosDbPurge = cmosDbPurge;
+exports.formatPurgeForLLM = formatPurgeForLLM;
+exports.formatBackfillForLLM = formatBackfillForLLM;
+/**
+ * cmos_db backfill action
+ *
+ * Replays existing CMOS state (sprints, missions, sessions, decisions)
+ * as sync events so the dashboard has the full project picture.
+ *
+ * Idempotency: Tracks a `backfill_cursor` in the metadata table.
+ * Re-running only pushes events with timestamps after the cursor.
+ * Use `force: true` to replay everything regardless of cursor.
+ *
+ * Reliability:
+ * - Large-delta guard: skips push when any table exceeds LARGE_DELTA_THRESHOLD (50) records.
+ *   Instructs the user to re-upload the SQLite file instead.
+ * - Per-request timeout: each HTTP push aborts after PER_REQUEST_TIMEOUT_MS (30s).
+ * - Overall timeout: the push loop aborts after OVERALL_TIMEOUT_MS (120s) wall-clock time.
+ * - Progress logging: reports pushed/failed/remaining to stderr every PROGRESS_LOG_INTERVAL events.
+ *
+ * @module tools/cmos/cmos-db-backfill
+ */
+const path = __importStar(require("path"));
+const client_1 = require("./client");
+const dashboard_client_1 = require("./dashboard-client");
+const errors_1 = require("./errors");
+const schema_migrations_1 = require("./schema-migrations");
+// ─── Types ───────────────────────────────────────────────────────────────────
+// ─── Constants ───────────────────────────────────────────────────────────────
+/**
+ * Maximum per-table event delta before skipping push and recommending SQLite re-upload.
+ * Exported so tests can reference the boundary without magic numbers.
+ */
+exports.LARGE_DELTA_THRESHOLD = 50;
+/** Per-request HTTP timeout for sync event pushes (ms). */
+const PER_REQUEST_TIMEOUT_MS = 30000;
+/** Maximum wall-clock time for a full backfill run (ms). */
+const OVERALL_TIMEOUT_MS = 120000;
+/** Log a progress line every N events pushed/failed. */
+const PROGRESS_LOG_INTERVAL = 10;
+/** Build a sync envelope for the dashboard push API */
+function buildSyncEnvelope(identity, eventType, timestamp, data) {
+    return {
+        projectId: identity.projectId,
+        projectName: identity.projectName,
+        eventType,
+        timestamp,
+        data,
+    };
+}
+// ─── Implementation ──────────────────────────────────────────────────────────
+async function cmosDbBackfill(params) {
+    // Validate dashboard is configured; honour per-request timeout override
+    const clientResult = dashboard_client_1.DashboardClient.fromEnv({
+        timeoutMs: params.perRequestTimeoutMs ?? PER_REQUEST_TIMEOUT_MS,
+    });
+    if (!clientResult.success || !clientResult.data) {
+        return (0, errors_1.createError)(errors_1.CmosErrors.dashboardNotConfigured());
+    }
+    const dashboardClient = clientResult.data;
+    return (0, client_1.withClientAsync)(async (db) => {
+        const identity = getProjectIdentity(db);
+        const previousCursor = getCursor(db);
+        // force=true bypasses the large-delta guard but still resumes from the cursor.
+        // Starting from scratch on every force run means the timeout always hits the same
+        // early events and the cursor can never advance past them (or worse, regresses).
+        // True "replay from scratch" can be achieved by clearing the cursor first.
+        const since = previousCursor;
+        // File-based sync: if the project is registered (has a dashboard_slug), use
+        // POST /api/sync/sqlite-backfill instead of event-replay. One HTTP call handles
+        // any number of records without timeout or cursor issues.
+        if (!params.dryRun) {
+            const slugResult = db.getOne(`SELECT value FROM metadata WHERE key = 'dashboard_slug'`);
+            const slug = (slugResult.success && slugResult.data?.value) || null;
+            if (slug) {
+                const fileResult = await dashboardClient.syncSqliteFile(db.path, slug, deriveProjectSlug(identity.projectName));
+                if (fileResult.success && fileResult.data) {
+                    const d = fileResult.data;
+                    const counts = d.counts ?? {};
+                    const total = Object.values(counts).reduce((a, b) => a + b, 0);
+                    return (0, errors_1.createSuccess)({
+                        mode: 'backfill',
+                        dryRun: false,
+                        totalEvents: total,
+                        pushed: total,
+                        failed: d.errors.length,
+                        skipped: 0,
+                        deduped: 0,
+                        breakdown: {
+                            sprints: counts['sprints'] ?? 0,
+                            missions: counts['missions'] ?? 0,
+                            sessions: counts['sessions'] ?? 0,
+                            decisions: counts['decisions'] ?? 0,
+                            learnings: counts['learnings'] ?? 0,
+                            dependencies: counts['dependencies'] ?? 0,
+                        },
+                        cursor: null,
+                        previousCursor,
+                        message: `File-based sync complete (${d.durationMs}ms): ${total} record(s) synced` +
+                            (d.errors.length > 0 ? `, ${d.errors.length} error(s)` : '') +
+                            `. Sprints: ${counts['sprints'] ?? 0}, missions: ${counts['missions'] ?? 0}, sessions: ${counts['sessions'] ?? 0}, decisions: ${counts['decisions'] ?? 0}, learnings: ${counts['learnings'] ?? 0}.`,
+                    });
+                }
+                // File sync failed — fall through to event-replay as fallback
+                console.error(`[backfill] File-based sync failed (slug: ${slug}), falling back to event-replay: ${fileResult.error?.message ?? 'unknown'}`);
+            }
+        }
+        // Ensure content_hash columns exist and are populated
+        (0, schema_migrations_1.migrateContentHash)(db);
+        const warnings = [];
+        if (identity.repaired) {
+            warnings.push(`Project metadata was empty — repaired from ${identity.repairSource} (id: ${identity.projectId}, name: ${identity.projectName})`);
+        }
+        else if (identity.projectId === 'unknown') {
+            warnings.push('Project identity is still "unknown" after repair attempts. ' +
+                'Run cmos_project(action="register", projectRoot="<path>", name="<name>") to set identity.');
+        }
+        const events = [];
+        const breakdown = {
+            sprints: 0,
+            missions: 0,
+            sessions: 0,
+            decisions: 0,
+            learnings: 0,
+            dependencies: 0,
+        };
+        // 1. Sprints
+        const sprintsResult = db.getMany(`SELECT * FROM sprints ORDER BY id`);
+        if (sprintsResult.success && sprintsResult.data) {
+            for (const sprint of sprintsResult.data) {
+                const ts = sprint.start_date ?? sprint.end_date ?? new Date().toISOString();
+                if (since && ts <= since)
+                    continue;
+                events.push({
+                    type: 'sprint_added',
+                    timestamp: ts,
+                    data: { sprintId: sprint.id, title: sprint.title },
+                });
+                breakdown.sprints++;
+                if (sprint.status === 'Completed' && sprint.end_date) {
+                    events.push({
+                        type: 'sprint_completed',
+                        timestamp: sprint.end_date,
+                        data: {
+                            sprintId: sprint.id,
+                            previousStatus: 'Active',
+                            completedAt: sprint.end_date,
+                            lifecycle: {
+                                kpis: {
+                                    totalMissions: sprint.total_missions,
+                                    completedMissions: sprint.completed_missions,
+                                },
+                            },
+                        },
+                    });
+                    breakdown.sprints++;
+                }
+            }
+        }
+        // 2. Missions
+        const missionsResult = db.getMany(`SELECT * FROM missions ORDER BY COALESCE(created_at, started_at, completed_at, id)`);
+        if (missionsResult.success && missionsResult.data) {
+            for (const mission of missionsResult.data) {
+                const createdTs = mission.created_at ?? mission.started_at ?? new Date().toISOString();
+                if (since && createdTs <= since)
+                    continue;
+                // Always emit mission_added so every mission gets a PG row
+                events.push({
+                    type: 'mission_added',
+                    timestamp: createdTs,
+                    data: {
+                        missionId: mission.id,
+                        name: mission.name,
+                        sprintId: mission.sprint_id ?? '',
+                        status: mission.status,
+                        objective: mission.notes ?? null,
+                        successCriteria: null,
+                        deliverables: null,
+                        addedAt: createdTs,
+                    },
+                });
+                breakdown.missions++;
+                if (mission.started_at) {
+                    events.push({
+                        type: 'mission_started',
+                        timestamp: mission.started_at,
+                        data: {
+                            missionId: mission.id,
+                            previousStatus: 'Queued',
+                            currentStatus: 'In Progress',
+                            sprintId: mission.sprint_id,
+                            notes: null,
+                            transitionAt: mission.started_at,
+                        },
+                    });
+                    breakdown.missions++;
+                }
+                if (mission.status === 'Completed' && mission.completed_at) {
+                    events.push({
+                        type: 'mission_completed',
+                        timestamp: mission.completed_at,
+                        data: {
+                            missionId: mission.id,
+                            previousStatus: 'In Progress',
+                            currentStatus: 'Completed',
+                            completedAt: mission.completed_at,
+                        },
+                    });
+                    breakdown.missions++;
+                }
+                if (mission.status === 'Blocked') {
+                    events.push({
+                        type: 'mission_blocked',
+                        timestamp: createdTs,
+                        data: {
+                            missionId: mission.id,
+                            previousStatus: 'In Progress',
+                            currentStatus: 'Blocked',
+                            reason: mission.notes ?? 'Unknown',
+                        },
+                    });
+                    breakdown.missions++;
+                }
+            }
+        }
+        // 3. Sessions
+        const sessionsResult = db.getMany(`SELECT * FROM sessions ORDER BY started_at`);
+        if (sessionsResult.success && sessionsResult.data) {
+            for (const session of sessionsResult.data) {
+                if (since && session.started_at <= since)
+                    continue;
+                events.push({
+                    type: 'session_started',
+                    timestamp: session.started_at,
+                    data: {
+                        sessionId: session.id,
+                        type: session.type,
+                        title: session.title,
+                        startedAt: session.started_at,
+                        sprintId: session.sprint_id,
+                    },
+                });
+                breakdown.sessions++;
+                if (session.status === 'completed' && session.completed_at) {
+                    let captureCount = 0;
+                    let nextSteps = null;
+                    try {
+                        captureCount = JSON.parse(session.captures ?? '[]').length;
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                    try {
+                        nextSteps = session.next_steps ? JSON.parse(session.next_steps) : null;
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                    events.push({
+                        type: 'session_completed',
+                        timestamp: session.completed_at,
+                        data: {
+                            sessionId: session.id,
+                            completedAt: session.completed_at,
+                            summary: session.summary,
+                            captureCount,
+                            nextSteps,
+                        },
+                    });
+                    breakdown.sessions++;
+                }
+            }
+        }
+        // 4. Decisions (with content hash dedup)
+        const seenDecisionHashes = new Set();
+        let deduped = 0;
+        const decisionsResult = db.getMany(`SELECT * FROM strategic_decisions ORDER BY created_at`);
+        if (decisionsResult.success && decisionsResult.data) {
+            for (const decision of decisionsResult.data) {
+                if (since && decision.created_at <= since)
+                    continue;
+                // Compute or use stored content hash for dedup
+                const hash = decision.content_hash ??
+                    (0, schema_migrations_1.computeContentHash)(decision.decision_text, decision.project_domain ?? 'general');
+                if (seenDecisionHashes.has(hash)) {
+                    deduped++;
+                    continue;
+                }
+                seenDecisionHashes.add(hash);
+                events.push({
+                    type: 'decision_captured',
+                    timestamp: decision.created_at,
+                    data: {
+                        decisionId: decision.id,
+                        sessionId: decision.session_id ?? '',
+                        category: 'decision',
+                        content: decision.decision_text,
+                        contentHash: hash,
+                        missionId: decision.mission_id,
+                        sprintId: decision.sprint_id,
+                    },
+                });
+                breakdown.decisions++;
+            }
+        }
+        // 5. Learnings (with content hash dedup)
+        const seenLearningHashes = new Set();
+        const learningsResult = db.getMany(`SELECT * FROM learnings ORDER BY created_at`);
+        if (learningsResult.success && learningsResult.data) {
+            for (const learning of learningsResult.data) {
+                if (since && learning.created_at <= since)
+                    continue;
+                // Compute or use stored content hash for dedup
+                const hash = learning.content_hash ?? (0, schema_migrations_1.computeContentHash)(learning.content, learning.category ?? '');
+                if (seenLearningHashes.has(hash)) {
+                    deduped++;
+                    continue;
+                }
+                seenLearningHashes.add(hash);
+                events.push({
+                    type: 'learning_captured',
+                    timestamp: learning.created_at,
+                    data: {
+                        learningId: learning.id,
+                        content: learning.content,
+                        contentHash: hash,
+                        sessionId: learning.session_id ?? '',
+                        sprintId: learning.sprint_id,
+                        missionId: learning.mission_id,
+                        capturedAt: learning.created_at,
+                    },
+                });
+                breakdown.learnings++;
+            }
+        }
+        // 6. Dependencies (join with missions to get a timestamp)
+        const dependenciesResult = db.getMany(`SELECT d.from_id, d.to_id, d.type, m.created_at AS from_created_at
+         FROM mission_dependencies d
+         LEFT JOIN missions m ON d.from_id = m.id
+         ORDER BY COALESCE(m.created_at, d.from_id)`);
+        if (dependenciesResult.success && dependenciesResult.data) {
+            for (const dep of dependenciesResult.data) {
+                const ts = dep.from_created_at ?? new Date().toISOString();
+                if (since && ts <= since)
+                    continue;
+                events.push({
+                    type: 'dependency_added',
+                    timestamp: ts,
+                    data: {
+                        fromId: dep.from_id,
+                        toId: dep.to_id,
+                        type: dep.type,
+                    },
+                });
+                breakdown.dependencies++;
+            }
+        }
+        // Sort chronologically
+        events.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+        const totalEvents = events.length;
+        // Large-delta guard: skip push when any entity type exceeds threshold.
+        // Directs the user to re-upload the SQLite file instead.
+        // Bypassed when force=true — upserts are idempotent, large-batch replays are safe.
+        if (!params.dryRun && !params.force) {
+            const tableNames = Object.keys(breakdown);
+            for (const table of tableNames) {
+                if (breakdown[table] > exports.LARGE_DELTA_THRESHOLD) {
+                    const dashUrl = process.env['CMOS_DASHBOARD_URL'] ?? '';
+                    const slugResult = db.getOne(`SELECT value FROM metadata WHERE key = 'dashboard_slug'`);
+                    const slug = (slugResult.success && slugResult.data?.value) || 'your-project';
+                    const uploadPath = dashUrl ? `${dashUrl}/projects/${slug}` : 'your dashboard';
+                    const warningMsg = `Delta too large: ${breakdown[table]} ${table} records exceed threshold of ` +
+                        `${exports.LARGE_DELTA_THRESHOLD}. Re-upload your SQLite file at ${uploadPath} instead.`;
+                    console.error(`[backfill] ${warningMsg}`);
+                    return (0, errors_1.createSuccess)({
+                        mode: 'backfill',
+                        dryRun: false,
+                        totalEvents,
+                        pushed: 0,
+                        failed: 0,
+                        skipped: totalEvents,
+                        deduped,
+                        breakdown,
+                        cursor: previousCursor,
+                        previousCursor,
+                        message: `Delta too large (${breakdown[table]} ${table} records). Re-upload your SQLite file at ${uploadPath} instead.`,
+                        warnings: [warningMsg, ...(warnings.length > 0 ? warnings : [])],
+                    });
+                }
+            }
+        }
+        if (params.dryRun) {
+            return (0, errors_1.createSuccess)({
+                mode: 'backfill',
+                dryRun: true,
+                totalEvents,
+                pushed: 0,
+                failed: 0,
+                skipped: 0,
+                deduped,
+                breakdown,
+                cursor: previousCursor,
+                previousCursor,
+                message: `Dry run: ${totalEvents} events would be pushed (${breakdown.sprints} sprint, ${breakdown.missions} mission, ${breakdown.sessions} session, ${breakdown.decisions} decision, ${breakdown.learnings} learning, ${breakdown.dependencies} dependency events)${deduped > 0 ? `. ${deduped} duplicate(s) skipped by content hash.` : ''}.`,
+                warnings: warnings.length > 0 ? warnings : undefined,
+            });
+        }
+        // Push events sequentially with per-request and overall timeouts
+        const getNow = params._getNow ?? Date.now;
+        const effectiveOverallTimeout = params.overallTimeoutMs ?? OVERALL_TIMEOUT_MS;
+        const wallClockStart = getNow();
+        let pushed = 0;
+        let failed = 0;
+        let latestTimestamp = null;
+        let timedOut = false;
+        for (const event of events) {
+            // Check wall-clock overall timeout before each push
+            if (getNow() - wallClockStart > effectiveOverallTimeout) {
+                timedOut = true;
+                const remaining = totalEvents - pushed - failed;
+                console.error(`[backfill] Overall timeout (${effectiveOverallTimeout}ms) exceeded. ` +
+                    `Aborted: ${pushed} pushed, ${failed} failed, ${remaining} remaining.`);
+                break;
+            }
+            const envelope = buildSyncEnvelope(identity, event.type, event.timestamp, event.data);
+            const result = await dashboardClient.pushSyncEvent(envelope);
+            if (result.success) {
+                pushed++;
+                latestTimestamp = event.timestamp;
+            }
+            else {
+                failed++;
+                console.warn(`[backfill] Failed to push ${event.type}: ${result.error?.message}`);
+            }
+            // Progress logging every PROGRESS_LOG_INTERVAL events
+            const processed = pushed + failed;
+            if (processed % PROGRESS_LOG_INTERVAL === 0) {
+                const remaining = totalEvents - processed;
+                console.error(`[backfill] Progress: ${pushed} pushed, ${failed} failed, ${remaining} remaining`);
+            }
+        }
+        // Update cursor — only advance, never regress.
+        // A force=true run that times out early must not overwrite a previously-advanced
+        // cursor with an earlier timestamp, or the next run re-processes the same events.
+        if (latestTimestamp && (!previousCursor || latestTimestamp > previousCursor)) {
+            db.execute(`INSERT OR REPLACE INTO metadata (key, value) VALUES ('backfill_cursor', ?)`, [
+                latestTimestamp,
+            ]);
+        }
+        const finalWarnings = warnings.length > 0 ? [...warnings] : [];
+        if (timedOut) {
+            const remaining = totalEvents - pushed - failed;
+            finalWarnings.push(`Backfill timed out after ${effectiveOverallTimeout}ms. ` +
+                `${remaining} event(s) not pushed. Re-run to continue from cursor.`);
+        }
+        return (0, errors_1.createSuccess)({
+            mode: 'backfill',
+            dryRun: false,
+            totalEvents,
+            pushed,
+            failed,
+            skipped: 0,
+            deduped,
+            breakdown,
+            cursor: latestTimestamp ?? previousCursor,
+            previousCursor,
+            message: `Backfill complete: ${pushed}/${totalEvents} events pushed${failed > 0 ? ` (${failed} failed)` : ''}${deduped > 0 ? ` (${deduped} duplicates skipped)` : ''}. ${breakdown.sprints} sprint, ${breakdown.missions} mission, ${breakdown.sessions} session, ${breakdown.decisions} decision, ${breakdown.learnings} learning, ${breakdown.dependencies} dependency events.`,
+            warnings: finalWarnings.length > 0 ? finalWarnings : undefined,
+        });
+    }, { projectRoot: params.projectRoot });
+}
+function getProjectIdentity(db) {
+    const pidResult = db.getOne(`SELECT value FROM metadata WHERE key = 'project_id'`);
+    const pnameResult = db.getOne(`SELECT value FROM metadata WHERE key = 'project_name'`);
+    let projectId = (pidResult.success && pidResult.data?.value) || '';
+    let projectName = (pnameResult.success && pnameResult.data?.value) || '';
+    // If both are present, return as-is
+    if (projectId && projectName) {
+        return { projectId, projectName, repaired: false, repairSource: null };
+    }
+    // Attempt repair from directory name (db path: {root}/cmos/db/cmos.sqlite)
+    const dbPath = db.path;
+    const projectRoot = path.resolve(dbPath, '..', '..', '..');
+    const dirName = path.basename(projectRoot);
+    if (dirName && dirName !== '.' && dirName !== '/') {
+        if (!projectName) {
+            projectName = dirName
+                .split('-')
+                .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+                .join(' ');
+        }
+        if (!projectId) {
+            projectId = dirName.toLowerCase().replace(/\s+/g, '-');
+        }
+        // Persist the repair
+        db.execute(`INSERT OR REPLACE INTO metadata (key, value) VALUES ('project_id', ?)`, [
+            projectId,
+        ]);
+        db.execute(`INSERT OR REPLACE INTO metadata (key, value) VALUES ('project_name', ?)`, [
+            projectName,
+        ]);
+        return { projectId, projectName, repaired: true, repairSource: 'directory' };
+    }
+    // Attempt repair from master_context
+    const contextResult = db.getOne(`SELECT content FROM contexts WHERE id = 'master_context'`);
+    if (contextResult.success && contextResult.data?.content) {
+        try {
+            const content = JSON.parse(contextResult.data.content);
+            const ctxProject = content.project_identity || content.project || {};
+            const ctxName = ctxProject.name;
+            if (ctxName) {
+                if (!projectName)
+                    projectName = ctxName;
+                if (!projectId)
+                    projectId = ctxName.toLowerCase().replace(/\s+/g, '-');
+                db.execute(`INSERT OR REPLACE INTO metadata (key, value) VALUES ('project_id', ?)`, [
+                    projectId,
+                ]);
+                db.execute(`INSERT OR REPLACE INTO metadata (key, value) VALUES ('project_name', ?)`, [
+                    projectName,
+                ]);
+                return { projectId, projectName, repaired: true, repairSource: 'master_context' };
+            }
+        }
+        catch {
+            // JSON parse failure — fall through to fallback
+        }
+    }
+    // Fallback: still unknown
+    return {
+        projectId: projectId || 'unknown',
+        projectName: projectName || 'Unknown',
+        repaired: false,
+        repairSource: null,
+    };
+}
+function getCursor(db) {
+    const result = db.getOne(`SELECT value FROM metadata WHERE key = 'backfill_cursor'`);
+    return (result.success && result.data?.value) || null;
+}
+/** PG table → SQLite table name mapping (used by global reconciliation fallback) */
+const PG_TO_SQLITE_TABLE = {
+    cmos_sprints: 'sprints',
+    cmos_missions: 'missions',
+    cmos_sessions: 'sessions',
+    cmos_decisions: 'strategic_decisions',
+    cmos_learnings: 'learnings',
+    cmos_mission_dependencies: 'mission_dependencies',
+};
+/** Derive a dashboard-compatible slug from the project name */
+function deriveProjectSlug(projectName) {
+    return projectName.toLowerCase().replace(/\s+/g, '-');
+}
+async function cmosDbReconcile(params) {
+    const clientResult = dashboard_client_1.DashboardClient.fromEnv();
+    if (!clientResult.success || !clientResult.data) {
+        return (0, errors_1.createError)(errors_1.CmosErrors.dashboardNotConfigured());
+    }
+    const dashboardClient = clientResult.data;
+    return (0, client_1.withClientAsync)(async (db) => {
+        // Resolve project slug from metadata
+        const identity = getProjectIdentity(db);
+        const slug = deriveProjectSlug(identity.projectName);
+        // Use project-scoped status endpoint for accurate table counts
+        // (project-state endpoint caps entity arrays, e.g. sessions LIMIT 50)
+        const statusResult = await dashboardClient.getSyncStatus(slug);
+        if (!statusResult.success || !statusResult.data) {
+            // Fallback to global endpoint if project-scoped status fails
+            return reconcileWithGlobalEndpoint(db, dashboardClient);
+        }
+        const pgStatus = statusResult.data;
+        const tables = [];
+        for (const pgTable of pgStatus.tables) {
+            const sqliteTable = PG_TO_SQLITE_TABLE[pgTable.table];
+            if (!sqliteTable)
+                continue;
+            const countResult = db.getOne(`SELECT COUNT(*) AS cnt FROM ${sqliteTable}`);
+            const sqliteCount = countResult.success && countResult.data ? countResult.data.cnt : 0;
+            tables.push({
+                table: sqliteTable,
+                sqliteCount,
+                pgCount: pgTable.count,
+                match: sqliteCount === pgTable.count,
+                delta: sqliteCount - pgTable.count,
+            });
+        }
+        const totalSqlite = tables.reduce((sum, t) => sum + t.sqliteCount, 0);
+        const totalPg = tables.reduce((sum, t) => sum + t.pgCount, 0);
+        return (0, errors_1.createSuccess)({
+            tables,
+            allMatch: tables.every((t) => t.match),
+            totalSqlite,
+            totalPg,
+            projectScoped: true,
+            projectSlug: slug,
+            syncLogEntries: pgStatus.totalSyncLogEntries,
+            failedEntries: pgStatus.failedSyncLogEntries,
+            lastSyncAt: pgStatus.lastSyncAt,
+        });
+    }, { projectRoot: params.projectRoot });
+}
+/** Fallback: reconcile using global endpoint (pre-Sprint 34 behavior) */
+async function reconcileWithGlobalEndpoint(db, client) {
+    const statusResult = await client.getSyncStatus();
+    if (!statusResult.success || !statusResult.data) {
+        return (0, errors_1.createError)(statusResult.error ?? errors_1.CmosErrors.dashboardError('Failed to fetch sync status'));
+    }
+    const pgStatus = statusResult.data;
+    const tables = [];
+    for (const pgTable of pgStatus.tables) {
+        const sqliteTable = PG_TO_SQLITE_TABLE[pgTable.table];
+        if (!sqliteTable)
+            continue;
+        const countResult = db.getOne(`SELECT COUNT(*) AS cnt FROM ${sqliteTable}`);
+        const sqliteCount = countResult.success && countResult.data ? countResult.data.cnt : 0;
+        tables.push({
+            table: sqliteTable,
+            sqliteCount,
+            pgCount: pgTable.count,
+            match: sqliteCount === pgTable.count,
+            delta: sqliteCount - pgTable.count,
+        });
+    }
+    const totalSqlite = tables.reduce((sum, t) => sum + t.sqliteCount, 0);
+    const totalPg = tables.reduce((sum, t) => sum + t.pgCount, 0);
+    return (0, errors_1.createSuccess)({
+        tables,
+        allMatch: tables.every((t) => t.match),
+        totalSqlite,
+        totalPg,
+        projectScoped: false,
+        projectSlug: null,
+        syncLogEntries: pgStatus.totalSyncLogEntries,
+        failedEntries: pgStatus.failedSyncLogEntries,
+        lastSyncAt: pgStatus.lastSyncAt,
+    });
+}
+function formatReconciliationForLLM(result) {
+    if (!result.success) {
+        return `Reconciliation failed: ${result.error?.message ?? 'Unknown error'}`;
+    }
+    const d = result.data;
+    const scopeLabel = d.projectScoped
+        ? `Reconciliation (project-scoped: ${d.projectSlug}): `
+        : 'Reconciliation (global): ';
+    const lines = [
+        scopeLabel + (d.allMatch ? 'ALL MATCH' : 'MISMATCHES DETECTED'),
+        '',
+        'Table                    | SQLite | PG   | Match | Delta',
+        '-------------------------|--------|------|-------|------',
+    ];
+    for (const t of d.tables) {
+        const status = t.match ? 'YES' : 'NO';
+        const delta = t.delta === 0 ? '0' : t.delta > 0 ? `+${t.delta}` : `${t.delta}`;
+        lines.push(`${t.table.padEnd(25)}| ${String(t.sqliteCount).padEnd(7)}| ${String(t.pgCount).padEnd(5)}| ${status.padEnd(6)}| ${delta}`);
+    }
+    lines.push('');
+    lines.push(`Totals: SQLite=${d.totalSqlite}, PG=${d.totalPg}`);
+    lines.push(`Sync log: ${d.syncLogEntries} entries, ${d.failedEntries} failed`);
+    if (d.lastSyncAt) {
+        lines.push(`Last sync: ${d.lastSyncAt}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Identify PG-side orphan entity IDs that don't exist in SQLite.
+ * Compares entity IDs from the dashboard project state API against local SQLite.
+ *
+ * Note: The project state API may cap entity arrays for large tables.
+ * When caps are hit, orphan detection for that table is skipped.
+ */
+async function identifyPgOrphans(params) {
+    const clientResult = dashboard_client_1.DashboardClient.fromEnv();
+    if (!clientResult.success || !clientResult.data) {
+        return (0, errors_1.createError)(errors_1.CmosErrors.dashboardNotConfigured());
+    }
+    const dashboardClient = clientResult.data;
+    return (0, client_1.withClientAsync)(async (db) => {
+        const identity = getProjectIdentity(db);
+        const slug = deriveProjectSlug(identity.projectName);
+        // Get full PG state
+        const stateResult = await dashboardClient.getSyncProjectState(slug);
+        if (!stateResult.success || !stateResult.data) {
+            return (0, errors_1.createError)(stateResult.error ?? errors_1.CmosErrors.dashboardError('Failed to fetch PG project state'));
+        }
+        const pgState = stateResult.data;
+        const orphans = [];
+        const tablesChecked = [];
+        // Compare missions
+        if (pgState.missions && Array.isArray(pgState.missions)) {
+            tablesChecked.push('missions');
+            const sqliteIds = getSqliteIds(db, 'missions', 'id');
+            for (const pgMission of pgState.missions) {
+                const id = pgMission.missionId ??
+                    pgMission.id;
+                if (id && !sqliteIds.has(id)) {
+                    orphans.push({ table: 'missions', id });
+                }
+            }
+        }
+        // Compare sessions
+        if (pgState.sessions && Array.isArray(pgState.sessions)) {
+            tablesChecked.push('sessions');
+            const sqliteIds = getSqliteIds(db, 'sessions', 'id');
+            for (const pgSession of pgState.sessions) {
+                const id = pgSession.sessionId ??
+                    pgSession.id;
+                if (id && !sqliteIds.has(id)) {
+                    orphans.push({ table: 'sessions', id });
+                }
+            }
+        }
+        // Compare dependencies (composite key: from_id + to_id)
+        if (pgState.dependencies && Array.isArray(pgState.dependencies)) {
+            tablesChecked.push('mission_dependencies');
+            const sqliteDeps = getSqliteDependencyKeys(db);
+            for (const pgDep of pgState.dependencies) {
+                const dep = pgDep;
+                const fromId = (dep.fromId ?? dep.from_id);
+                const toId = (dep.toId ?? dep.to_id);
+                if (fromId && toId) {
+                    const key = `${fromId}|${toId}`;
+                    if (!sqliteDeps.has(key)) {
+                        orphans.push({ table: 'mission_dependencies', id: fromId, secondaryId: toId });
+                    }
+                }
+            }
+        }
+        return (0, errors_1.createSuccess)({
+            orphans,
+            totalOrphans: orphans.length,
+            tablesChecked,
+            projectSlug: slug,
+        });
+    }, { projectRoot: params.projectRoot });
+}
+/** Get all entity IDs from a SQLite table as a Set */
+function getSqliteIds(db, table, idColumn) {
+    const result = db.getMany(`SELECT ${idColumn} as id FROM ${table}`);
+    if (!result.success || !result.data)
+        return new Set();
+    return new Set(result.data.map((row) => row.id));
+}
+/** Get all dependency composite keys as a Set */
+function getSqliteDependencyKeys(db) {
+    const result = db.getMany(`SELECT from_id, to_id FROM mission_dependencies`);
+    if (!result.success || !result.data)
+        return new Set();
+    return new Set(result.data.map((row) => `${row.from_id}|${row.to_id}`));
+}
+function formatPgOrphanReportForLLM(result) {
+    if (!result.success) {
+        return `PG orphan identification failed: ${result.error?.message ?? 'Unknown error'}`;
+    }
+    const d = result.data;
+    if (d.totalOrphans === 0) {
+        return `PG Orphan Check (${d.projectSlug}): No orphans found across ${d.tablesChecked.length} tables.`;
+    }
+    const lines = [`PG Orphan Report (${d.projectSlug}): ${d.totalOrphans} orphan(s) found`, ''];
+    const byTable = new Map();
+    for (const orphan of d.orphans) {
+        const existing = byTable.get(orphan.table) ?? [];
+        existing.push(orphan);
+        byTable.set(orphan.table, existing);
+    }
+    for (const [table, entries] of byTable) {
+        lines.push(`${table} (${entries.length} orphan${entries.length > 1 ? 's' : ''}):`);
+        for (const entry of entries) {
+            if (entry.secondaryId) {
+                lines.push(`  - ${entry.id} → ${entry.secondaryId}`);
+            }
+            else {
+                lines.push(`  - ${entry.id}`);
+            }
+        }
+        lines.push('');
+    }
+    lines.push(`Tables checked: ${d.tablesChecked.join(', ')}`);
+    return lines.join('\n');
+}
+async function cmosDbPurge(params) {
+    if (!params.confirm) {
+        return (0, errors_1.createError)({
+            code: 'CONFIRMATION_REQUIRED',
+            message: 'Purge requires explicit confirmation. Pass confirm=true to proceed. ' +
+                'This will delete ALL mirrored data for this project from the PG mirror.',
+            suggestion: 'Call cmos_db(action="purge", confirm=true) to proceed.',
+        });
+    }
+    const clientResult = dashboard_client_1.DashboardClient.fromEnv();
+    if (!clientResult.success || !clientResult.data) {
+        return (0, errors_1.createError)(errors_1.CmosErrors.dashboardNotConfigured());
+    }
+    const dashboardClient = clientResult.data;
+    return (0, client_1.withClientAsync)(async (db) => {
+        const identity = getProjectIdentity(db);
+        const slug = deriveProjectSlug(identity.projectName);
+        const purgeResult = await dashboardClient.purgeMirror(slug, params.expectedSlug ?? undefined);
+        if (!purgeResult.success || !purgeResult.data) {
+            return (0, errors_1.createError)(purgeResult.error ?? errors_1.CmosErrors.dashboardError('Failed to purge mirror'));
+        }
+        return (0, errors_1.createSuccess)({
+            purgedProject: purgeResult.data.purgedProject,
+            tablesCleared: purgeResult.data.tablesCleared,
+            rowsDeleted: purgeResult.data.rowsDeleted,
+        });
+    }, { projectRoot: params.projectRoot });
+}
+function formatPurgeForLLM(result) {
+    if (!result.success) {
+        return `Purge failed: ${result.error?.message ?? 'Unknown error'}`;
+    }
+    const d = result.data;
+    const lines = [
+        `Purge Complete: ${d.purgedProject}`,
+        '',
+        `Tables cleared: ${d.tablesCleared.join(', ')}`,
+        `Rows deleted: ${d.rowsDeleted}`,
+        '',
+        'Run cmos_db(action="backfill", force=true) to re-sync all data.',
+    ];
+    return lines.join('\n');
+}
+// ─── LLM Formatter ───────────────────────────────────────────────────────────
+function formatBackfillForLLM(result) {
+    if (!result.success) {
+        return `Backfill failed: ${result.error?.message ?? 'Unknown error'}`;
+    }
+    const d = result.data;
+    const lines = [
+        d.dryRun ? 'Backfill Dry Run' : 'Backfill Complete',
+        '',
+        d.message,
+        '',
+        `Events: ${d.pushed} pushed, ${d.failed} failed`,
+        `Breakdown: ${d.breakdown.sprints} sprint, ${d.breakdown.missions} mission, ${d.breakdown.sessions} session, ${d.breakdown.decisions} decision, ${d.breakdown.learnings} learning, ${d.breakdown.dependencies} dependency`,
+    ];
+    if (d.previousCursor) {
+        lines.push(`Previous cursor: ${d.previousCursor}`);
+    }
+    if (d.cursor) {
+        lines.push(`Current cursor: ${d.cursor}`);
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=cmos-db-backfill.js.map