@aquex/cmos-mcp 1.0.0

package/dist/tools/cmos/cmos-sprint-complete.js

@@ -0,0 +1,768 @@
+"use strict";
+/**
+ * cmos_sprint_complete Tool
+ *
+ * MCP tool for closing out a sprint in one operation. It validates readiness,
+ * snapshots both contexts, clears stale sprint-linked next steps, optionally
+ * runs condensation, and returns a closeout receipt with size telemetry.
+ *
+ * @module tools/cmos/cmos-sprint-complete
+ */
+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.cmosSprintCompleteToolDefinition = exports.cmosSprintCompleteSchema = void 0;
+exports.cmosSprintComplete = cmosSprintComplete;
+exports.formatSprintCompleteForLLM = formatSprintCompleteForLLM;
+const crypto = __importStar(require("crypto"));
+const zod_1 = require("zod");
+const client_1 = require("./client");
+const errors_1 = require("./errors");
+const context_retention_1 = require("./context-retention");
+const cmos_context_condense_1 = require("./cmos-context-condense");
+const cmos_db_snapshot_1 = require("./cmos-db-snapshot");
+const schema_migrations_1 = require("./schema-migrations");
+/**
+ * Input parameters schema for cmos_sprint_complete.
+ */
+exports.cmosSprintCompleteSchema = zod_1.z.object({
+    sprintId: zod_1.z.string().min(1).describe('The sprint ID to close out (e.g., "sprint-22")'),
+    summary: zod_1.z
+        .string()
+        .min(1)
+        .max(2000)
+        .describe('Short closeout summary describing what the sprint delivered'),
+    condensation: zod_1.z
+        .enum(['none', 'conservative', 'auto', 'aggressive'])
+        .default('none')
+        .optional()
+        .describe('Optional context condensation strategy to run after snapshots and next-step cleanup'),
+    targetSizePercent: zod_1.z
+        .number()
+        .min(1)
+        .max(100)
+        .default(60)
+        .optional()
+        .describe('Target percentage of the context size limit when condensation is requested'),
+    projectRoot: zod_1.z
+        .string()
+        .optional()
+        .describe('Project root directory to search for CMOS database (defaults to cwd)'),
+});
+/**
+ * MCP Tool Definition for cmos_sprint_complete.
+ */
+exports.cmosSprintCompleteToolDefinition = {
+    name: 'cmos_sprint_complete',
+    description: 'Close out a sprint in one operation. Validates sprint readiness, marks the sprint Completed with endDate, snapshots both contexts, clears stale sprint-linked next steps, and optionally runs context condensation.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            sprintId: {
+                type: 'string',
+                description: 'The sprint ID to close out (e.g., "sprint-22")',
+            },
+            summary: {
+                type: 'string',
+                description: 'Short closeout summary describing what the sprint delivered',
+                minLength: 1,
+                maxLength: 2000,
+            },
+            condensation: {
+                type: 'string',
+                enum: ['none', 'conservative', 'auto', 'aggressive'],
+                default: 'none',
+                description: 'Optional context condensation strategy to run after snapshots and next-step cleanup',
+            },
+            targetSizePercent: {
+                type: 'number',
+                minimum: 1,
+                maximum: 100,
+                default: 60,
+                description: 'Target percentage of the context size limit when condensation is requested',
+            },
+            projectRoot: {
+                type: 'string',
+                description: 'Project root directory to search for CMOS database (defaults to cwd)',
+            },
+        },
+        required: ['sprintId', 'summary'],
+        additionalProperties: false,
+    },
+};
+/**
+ * Execute the cmos_sprint_complete tool.
+ */
+async function cmosSprintComplete(params) {
+    if (!params.sprintId || params.sprintId.trim() === '') {
+        return (0, errors_1.createError)(errors_1.CmosErrors.missingParameter('sprintId'));
+    }
+    if (!params.summary || params.summary.trim() === '') {
+        return (0, errors_1.createError)(errors_1.CmosErrors.missingParameter('summary'));
+    }
+    const sprintId = params.sprintId.trim();
+    const summary = params.summary.trim();
+    const condensation = params.condensation ?? 'none';
+    const targetSizePercent = params.targetSizePercent ?? 60;
+    return (0, client_1.withClientAsync)(async (client) => {
+        const warnings = [];
+        const beginResult = client.execute('BEGIN IMMEDIATE', []);
+        if (!beginResult.success) {
+            return (0, errors_1.createError)(beginResult.error ?? {
+                code: errors_1.CMOS_ERROR_CODES.DB_QUERY_FAILED,
+                message: `Failed to begin sprint closeout for '${sprintId}'`,
+                suggestion: 'Retry once the database becomes available.',
+            });
+        }
+        let transactionOpen = true;
+        const rollback = () => {
+            if (!transactionOpen) {
+                return;
+            }
+            client.execute('ROLLBACK', []);
+            transactionOpen = false;
+        };
+        const fail = (error) => {
+            rollback();
+            return (0, errors_1.createError)(error);
+        };
+        const sprintResult = client.getOne('SELECT id, title, focus, status, start_date, end_date, total_missions, completed_missions FROM sprints WHERE id = ?', [sprintId]);
+        if (!sprintResult.success) {
+            return fail(sprintResult.error ?? {
+                code: errors_1.CMOS_ERROR_CODES.DB_QUERY_FAILED,
+                message: `Failed to query sprint '${sprintId}'`,
+                suggestion: 'Check database connectivity and schema.',
+            });
+        }
+        if (!sprintResult.data) {
+            return fail(errors_1.CmosErrors.sprintNotFound(sprintId));
+        }
+        const sprint = sprintResult.data;
+        if (sprint.status === 'Completed') {
+            return fail({
+                code: errors_1.CMOS_ERROR_CODES.SPRINT_ALREADY_COMPLETED,
+                message: `Sprint '${sprintId}' is already Completed`,
+                currentState: sprint.status,
+                suggestion: 'Use cmos_sprint with action="show" to review the closed sprint. No further closeout is needed.',
+            });
+        }
+        const missionsResult = client.getMany('SELECT id, status, notes FROM missions WHERE sprint_id = ? ORDER BY id ASC', [sprintId]);
+        if (!missionsResult.success) {
+            return fail(missionsResult.error ?? {
+                code: errors_1.CMOS_ERROR_CODES.DB_QUERY_FAILED,
+                message: `Failed to query missions for sprint '${sprintId}'`,
+                suggestion: 'Check database connectivity and schema.',
+            });
+        }
+        const readiness = summarizeSprintReadiness(missionsResult.data ?? []);
+        if (readiness.openMissionIds.length > 0) {
+            return fail({
+                code: errors_1.CMOS_ERROR_CODES.SPRINT_NOT_READY,
+                message: `Sprint '${sprintId}' still has non-terminal missions: ${readiness.openMissionIds.join(', ')}`,
+                currentState: sprint.status ?? undefined,
+                suggestion: 'Complete, block, drop, or defer the remaining Queued/Current/In Progress missions before closing the sprint.',
+            });
+        }
+        if (readiness.blockedMissionIds.length > 0) {
+            warnings.push(`Sprint '${sprintId}' closed with blocked missions: ${readiness.blockedMissionIds.join(', ')}.`);
+        }
+        if (readiness.skippedMissionIds.length > 0) {
+            warnings.push(`Sprint '${sprintId}' includes skipped missions recorded in notes: ${readiness.skippedMissionIds.join(', ')}.`);
+        }
+        const masterContext = loadCloseoutContext(client, 'master_context');
+        if (!masterContext.success || !masterContext.data) {
+            return fail(masterContext.error ?? {
+                code: errors_1.CMOS_ERROR_CODES.CONTEXT_NOT_FOUND,
+                message: 'master_context is required for sprint closeout',
+                suggestion: 'Repair or recreate master_context before retrying sprint closeout.',
+            });
+        }
+        const projectContext = loadCloseoutContext(client, 'project_context');
+        if (!projectContext.success || !projectContext.data) {
+            return fail(projectContext.error ?? {
+                code: errors_1.CMOS_ERROR_CODES.CONTEXT_NOT_FOUND,
+                message: 'project_context is required for sprint closeout',
+                suggestion: 'Repair or recreate project_context before retrying sprint closeout.',
+            });
+        }
+        const completedAt = new Date().toISOString();
+        const snapshotSource = `sprint_complete:${sprintId}`;
+        const masterSnapshotId = createSnapshot(client, 'master_context', masterContext.data.rawContent, snapshotSource);
+        if (!masterSnapshotId.success) {
+            return fail({
+                code: errors_1.CMOS_ERROR_CODES.SNAPSHOT_CREATION_FAILED,
+                message: `Failed to snapshot master_context for sprint '${sprintId}'`,
+                suggestion: 'Check context_snapshots table integrity and retry closeout.',
+            });
+        }
+        const projectSnapshotId = createSnapshot(client, 'project_context', projectContext.data.rawContent, snapshotSource);
+        if (!projectSnapshotId.success) {
+            return fail({
+                code: errors_1.CMOS_ERROR_CODES.SNAPSHOT_CREATION_FAILED,
+                message: `Failed to snapshot project_context for sprint '${sprintId}'`,
+                suggestion: 'Check context_snapshots table integrity and retry closeout.',
+            });
+        }
+        const masterCleared = clearSprintLinkedNextSteps(masterContext.data.parsedContent, sprintId, readiness.completedMissionIds, readiness.blockedMissionIds);
+        const projectCleared = clearSprintLinkedNextSteps(projectContext.data.parsedContent, sprintId, readiness.completedMissionIds, readiness.blockedMissionIds);
+        // --- Lifecycle Trigger: Archive sprint-scoped decisions/learnings ---
+        const archiveResult = archiveSprintDecisionsAndLearnings(client, sprintId);
+        if (!archiveResult.success) {
+            warnings.push(`Decision/learning archival partially failed: ${archiveResult.error ?? 'unknown'}`);
+        }
+        // --- Lifecycle Trigger: Compute sprint KPIs ---
+        const kpis = computeSprintKPIs(client, sprintId, readiness);
+        // --- Lifecycle Trigger: Update project_context working_memory & current_sprint ---
+        clearProjectContextWorkingMemory(projectContext.data.parsedContent, sprintId);
+        const masterPersist = persistCloseoutContext(client, masterContext.data, completedAt);
+        if (!masterPersist.success || !masterPersist.data) {
+            return fail(masterPersist.error ?? {
+                code: errors_1.CMOS_ERROR_CODES.DB_QUERY_FAILED,
+                message: 'Failed to persist master_context sprint cleanup',
+                suggestion: 'Check database permissions and retry closeout.',
+            });
+        }
+        const projectPersist = persistCloseoutContext(client, projectContext.data, completedAt);
+        if (!projectPersist.success || !projectPersist.data) {
+            return fail(projectPersist.error ?? {
+                code: errors_1.CMOS_ERROR_CODES.DB_QUERY_FAILED,
+                message: 'Failed to persist project_context sprint cleanup',
+                suggestion: 'Check database permissions and retry closeout.',
+            });
+        }
+        const sprintUpdateResult = completeSprintRecord(client, sprintId, completedAt);
+        if (!sprintUpdateResult.success) {
+            return fail(sprintUpdateResult.error ?? {
+                code: errors_1.CMOS_ERROR_CODES.DB_QUERY_FAILED,
+                message: `Failed to update sprint '${sprintId}'`,
+                suggestion: 'Check database permissions and retry closeout.',
+            });
+        }
+        const commitResult = client.execute('COMMIT', []);
+        if (!commitResult.success) {
+            rollback();
+            return (0, errors_1.createError)(commitResult.error ?? {
+                code: errors_1.CMOS_ERROR_CODES.DB_QUERY_FAILED,
+                message: `Failed to commit sprint closeout for '${sprintId}'`,
+                suggestion: 'Retry once the database can commit the closeout transaction.',
+            });
+        }
+        transactionOpen = false;
+        const eventResult = client.execute(`INSERT INTO session_events (ts, agent, mission, action, status, summary, raw_event)
+         VALUES (?, 'mcp-tool', ?, 'sprint_complete', 'Completed', ?, ?)`, [
+            completedAt,
+            sprintId,
+            summary,
+            JSON.stringify({
+                tool: 'cmos_sprint_complete',
+                sprintId,
+                previousStatus: sprint.status,
+                summary,
+                condensation,
+                targetSizePercent,
+            }),
+        ]);
+        if (!eventResult.success) {
+            warnings.push('Sprint closeout event logging failed.');
+        }
+        // --- Lifecycle Trigger: Auto-snapshot the full database (non-critical) ---
+        let dbSnapshotId = null;
+        try {
+            const snapshotResult = await (0, cmos_db_snapshot_1.cmosDbSnapshot)({ projectRoot: params.projectRoot });
+            if (snapshotResult.success && snapshotResult.data?.createdSnapshot) {
+                dbSnapshotId = snapshotResult.data.createdSnapshot.id;
+            }
+            else {
+                warnings.push('Auto database snapshot after sprint completion failed.');
+            }
+        }
+        catch {
+            warnings.push('Auto database snapshot after sprint completion failed.');
+        }
+        const lifecycle = {
+            decisionsArchived: archiveResult.success ? archiveResult.decisionsArchived : 0,
+            learningsArchived: archiveResult.success ? archiveResult.learningsArchived : 0,
+            kpis,
+            dbSnapshotId,
+        };
+        const result = {
+            sprintId,
+            previousStatus: sprint.status,
+            currentStatus: 'Completed',
+            summary,
+            completedAt,
+            readiness,
+            contexts: {
+                masterContext: {
+                    snapshotId: masterSnapshotId.snapshotId ?? null,
+                    beforeSize: masterContext.data.beforeSize,
+                    afterSize: masterPersist.data.afterSize,
+                    nextStepsCleared: masterCleared,
+                },
+                projectContext: {
+                    snapshotId: projectSnapshotId.snapshotId ?? null,
+                    beforeSize: projectContext.data.beforeSize,
+                    afterSize: projectPersist.data.afterSize,
+                    nextStepsCleared: projectCleared,
+                },
+                totalBeforeSizeKb: roundNumber(masterContext.data.beforeSize.sizeKb + projectContext.data.beforeSize.sizeKb),
+                totalAfterSizeKb: roundNumber(masterPersist.data.afterSize.sizeKb + projectPersist.data.afterSize.sizeKb),
+            },
+            lifecycle,
+            message: buildCloseoutMessage(sprintId, condensation, readiness),
+        };
+        if (condensation !== 'none') {
+            await applyOptionalCondensation({
+                projectRoot: params.projectRoot,
+                strategy: condensation,
+                targetSizePercent,
+                warnings,
+                contexts: result.contexts,
+            });
+        }
+        result.contexts.totalAfterSizeKb = roundNumber(result.contexts.masterContext.afterSize.sizeKb +
+            result.contexts.projectContext.afterSize.sizeKb);
+        return (0, errors_1.createSuccess)(result, warnings);
+    }, { projectRoot: params.projectRoot });
+}
+function summarizeSprintReadiness(missions) {
+    const completedMissionIds = missions
+        .filter((mission) => mission.status === 'Completed')
+        .map((mission) => mission.id);
+    const blockedMissionIds = missions
+        .filter((mission) => mission.status === 'Blocked')
+        .map((mission) => mission.id);
+    const skippedMissionIds = missions
+        .filter((mission) => mission.status === 'Completed' && isSkippedMission(mission.notes))
+        .map((mission) => mission.id);
+    // Terminal states for sprint close: Completed, Blocked, Dropped, Deferred.
+    // Dropped = soft-parked and intentionally removed — sprint can close.
+    // Deferred = temporarily parked — sprint can close; mission carries to next sprint.
+    // Only Queued / Current / In Progress missions are truly blocking.
+    const TERMINAL_FOR_SPRINT_CLOSE = new Set(['Completed', 'Blocked', 'Dropped', 'Deferred']);
+    const openMissionIds = missions
+        .filter((mission) => !TERMINAL_FOR_SPRINT_CLOSE.has(mission.status))
+        .map((mission) => mission.id);
+    return {
+        totalMissions: missions.length,
+        completedMissions: completedMissionIds.length,
+        blockedMissions: blockedMissionIds.length,
+        skippedMissions: skippedMissionIds.length,
+        openMissions: openMissionIds.length,
+        completedMissionIds,
+        blockedMissionIds,
+        skippedMissionIds,
+        openMissionIds,
+    };
+}
+function isSkippedMission(notes) {
+    if (typeof notes !== 'string') {
+        return false;
+    }
+    return notes
+        .split(/\r?\n|\|/)
+        .map((segment) => segment.trim())
+        .some((segment) => /^\[(?:skip|skipped)\](?:\s|$)/i.test(segment) ||
+        /^skip(?:ped)?\s*[:-]/i.test(segment) ||
+        /^status\s*:\s*skipped\b/i.test(segment));
+}
+function loadCloseoutContext(client, contextType) {
+    const result = client.getOne('SELECT id, source_path, content, updated_at FROM contexts WHERE id = ?', [contextType]);
+    if (!result.success) {
+        return (0, errors_1.createError)(result.error ?? {
+            code: errors_1.CMOS_ERROR_CODES.DB_QUERY_FAILED,
+            message: `Failed to load ${contextType}`,
+            suggestion: 'Check database connectivity and schema.',
+        });
+    }
+    if (!result.data) {
+        return (0, errors_1.createError)(errors_1.CmosErrors.contextNotFound(contextType));
+    }
+    try {
+        const parsed = JSON.parse(result.data.content);
+        if (!isPlainObject(parsed)) {
+            return (0, errors_1.createError)({
+                code: errors_1.CMOS_ERROR_CODES.CONTEXT_PARSE_ERROR,
+                message: `${contextType} content must be a JSON object`,
+                suggestion: 'Repair the stored context JSON before retrying sprint closeout.',
+            });
+        }
+        const sizeSettings = (0, context_retention_1.resolveContextSizeSettings)(parsed);
+        return (0, errors_1.createSuccess)({
+            contextType,
+            rawContent: result.data.content,
+            parsedContent: parsed,
+            beforeSize: (0, context_retention_1.calculateContextSizeMetrics)(result.data.content, sizeSettings),
+        });
+    }
+    catch {
+        return (0, errors_1.createError)({
+            code: errors_1.CMOS_ERROR_CODES.CONTEXT_PARSE_ERROR,
+            message: `${contextType} content is not valid JSON`,
+            suggestion: 'Repair the stored context JSON before retrying sprint closeout.',
+        });
+    }
+}
+function createSnapshot(client, contextType, content, source) {
+    const contentHash = crypto.createHash('sha256').update(content).digest('hex').substring(0, 16);
+    const existing = client.getOne('SELECT id FROM context_snapshots WHERE context_id = ? AND content_hash = ?', [contextType, contentHash]);
+    if (existing.success && existing.data) {
+        return { success: true, snapshotId: existing.data.id };
+    }
+    const now = new Date().toISOString();
+    const insertResult = client.execute(`INSERT INTO context_snapshots (context_id, source, content_hash, content, created_at)
+     VALUES (?, ?, ?, ?, ?)`, [contextType, source, contentHash, content, now]);
+    if (!insertResult.success) {
+        return { success: false };
+    }
+    return { success: true, snapshotId: Number(insertResult.data?.lastInsertRowid) };
+}
+function clearSprintLinkedNextSteps(content, sprintId, completedMissionIds, blockedMissionIds) {
+    const paths = [
+        ['working_memory', 'next_steps'],
+        ['next_session_context', 'when_we_resume'],
+        ['next_steps'],
+    ];
+    let removed = 0;
+    for (const path of paths) {
+        removed += pruneStringArrayAtPath(content, [...path], (step) => shouldClearStep(step, sprintId, completedMissionIds, blockedMissionIds));
+    }
+    return removed;
+}
+function pruneStringArrayAtPath(content, path, shouldRemove) {
+    const parent = getParentObject(content, path.slice(0, -1));
+    const key = path[path.length - 1];
+    if (!parent || !Array.isArray(parent[key])) {
+        return 0;
+    }
+    let removed = 0;
+    parent[key] = parent[key].filter((entry) => {
+        if (typeof entry === 'string' && shouldRemove(entry)) {
+            removed += 1;
+            return false;
+        }
+        return true;
+    });
+    return removed;
+}
+function shouldClearStep(step, sprintId, completedMissionIds, blockedMissionIds) {
+    const normalized = step.toLowerCase();
+    if (blockedMissionIds.some((missionId) => normalized.includes(missionId.toLowerCase()))) {
+        return false;
+    }
+    if (completedMissionIds.some((missionId) => normalized.includes(missionId.toLowerCase()))) {
+        return true;
+    }
+    return buildSprintTokens(sprintId).some((token) => normalized.includes(token));
+}
+function buildSprintTokens(sprintId) {
+    const normalizedSprintId = sprintId.toLowerCase();
+    const tokens = [normalizedSprintId, normalizedSprintId.replace(/-/g, ' ')];
+    const numericMatch = normalizedSprintId.match(/^sprint-(\d+)$/);
+    if (numericMatch) {
+        const sprintNumber = String(Number.parseInt(numericMatch[1], 10));
+        tokens.push(`sprint ${sprintNumber}`);
+        tokens.push(`sprint-${numericMatch[1]}`);
+    }
+    return tokens;
+}
+function getParentObject(content, path) {
+    let current = content;
+    for (const segment of path) {
+        const next = current[segment];
+        if (!isPlainObject(next)) {
+            return null;
+        }
+        current = next;
+    }
+    return current;
+}
+function persistCloseoutContext(client, context, updatedAt) {
+    const serialized = JSON.stringify(context.parsedContent);
+    const afterSize = (0, context_retention_1.calculateContextSizeMetrics)(serialized, (0, context_retention_1.resolveContextSizeSettings)(context.parsedContent));
+    if (serialized === context.rawContent) {
+        return (0, errors_1.createSuccess)({ afterSize });
+    }
+    const updateResult = client.execute('UPDATE contexts SET content = ?, updated_at = ? WHERE id = ?', [serialized, updatedAt, context.contextType]);
+    if (!updateResult.success) {
+        return (0, errors_1.createError)(updateResult.error ?? {
+            code: errors_1.CMOS_ERROR_CODES.DB_QUERY_FAILED,
+            message: `Failed to update ${context.contextType}`,
+            suggestion: 'Check database permissions and retry sprint closeout.',
+        });
+    }
+    return (0, errors_1.createSuccess)({ afterSize });
+}
+function completeSprintRecord(client, sprintId, completedAt) {
+    const updateWithEndDate = client.execute(`UPDATE sprints
+        SET status = 'Completed',
+            end_date = COALESCE(end_date, ?)
+      WHERE id = ?`, [completedAt, sprintId]);
+    if (updateWithEndDate.success ||
+        updateWithEndDate.error?.code !== errors_1.CMOS_ERROR_CODES.DB_SCHEMA_MISMATCH ||
+        !updateWithEndDate.error?.message.includes('end_date')) {
+        return updateWithEndDate;
+    }
+    return client.execute(`UPDATE sprints SET status = 'Completed' WHERE id = ?`, [sprintId]);
+}
+async function applyOptionalCondensation(params) {
+    const mappings = [
+        ['masterContext', 'master_context'],
+        ['projectContext', 'project_context'],
+    ];
+    for (const [resultKey, contextType] of mappings) {
+        const condenseResult = await (0, cmos_context_condense_1.cmosContextCondense)({
+            contextType,
+            strategy: params.strategy,
+            targetSizePercent: params.targetSizePercent,
+            dryRun: false,
+            projectRoot: params.projectRoot,
+        });
+        if (!condenseResult.success || !condenseResult.data) {
+            params.warnings.push(`Optional ${contextType} condensation failed: ${condenseResult.error?.message ?? 'Unknown error'}.`);
+            continue;
+        }
+        params.contexts[resultKey].afterSize = condenseResult.data.afterSize;
+        params.contexts[resultKey].condensation = {
+            strategy: params.strategy,
+            snapshotId: condenseResult.data.snapshotId,
+            reductionPercent: condenseResult.data.reductionPercent,
+            targetMet: condenseResult.data.targetMet,
+            message: condenseResult.data.message,
+        };
+        for (const warning of condenseResult.warnings ?? []) {
+            params.warnings.push(`${contextType}: ${warning}`);
+        }
+    }
+}
+/**
+ * Archive sprint-scoped decisions and learnings.
+ * Sets status='archived' for all active decisions/learnings linked to the sprint
+ * (directly via sprint_id, or indirectly via mission/session sprint linkage).
+ * Decisions/learnings with status other than 'active' are left untouched.
+ */
+function archiveSprintDecisionsAndLearnings(client, sprintId) {
+    let decisionsArchived = 0;
+    let learningsArchived = 0;
+    // Sprint 52 m04: older DBs seeded before session_id was added will fail the archival
+    // UPDATE with `no such column: session_id`. Ensure the column exists first so the
+    // cross-session archival path actually runs instead of silently archiving zero rows.
+    (0, schema_migrations_1.ensureArchivalColumns)(client);
+    const decisionsSql = `UPDATE strategic_decisions SET status = 'archived'
+     WHERE status = 'active'
+       AND (sprint_id = ?
+         OR mission_id IN (SELECT id FROM missions WHERE sprint_id = ?)
+         OR session_id IN (SELECT id FROM sessions WHERE sprint_id = ?))`;
+    const decisionResult = client.execute(decisionsSql, [sprintId, sprintId, sprintId]);
+    if (decisionResult.success) {
+        decisionsArchived = decisionResult.data?.changes ?? 0;
+    }
+    else {
+        const msg = decisionResult.error?.message ?? 'Failed to archive decisions';
+        return {
+            success: false,
+            decisionsArchived: 0,
+            learningsArchived: 0,
+            error: `strategic_decisions: ${msg} — SQL: ${decisionsSql.replace(/\s+/g, ' ')}`,
+        };
+    }
+    const learningsSql = `UPDATE learnings SET status = 'archived'
+     WHERE status = 'active'
+       AND (sprint_id = ?
+         OR mission_id IN (SELECT id FROM missions WHERE sprint_id = ?)
+         OR session_id IN (SELECT id FROM sessions WHERE sprint_id = ?))`;
+    const learningResult = client.execute(learningsSql, [sprintId, sprintId, sprintId]);
+    if (learningResult.success) {
+        learningsArchived = learningResult.data?.changes ?? 0;
+    }
+    else {
+        const msg = learningResult.error?.message ?? 'Failed to archive learnings';
+        return {
+            success: false,
+            decisionsArchived,
+            learningsArchived: 0,
+            error: `learnings: ${msg} — SQL: ${learningsSql.replace(/\s+/g, ' ')}`,
+        };
+    }
+    return { success: true, decisionsArchived, learningsArchived };
+}
+/**
+ * Compute sprint summary KPIs from mission and decision data.
+ */
+function computeSprintKPIs(client, sprintId, readiness) {
+    const completionRate = readiness.totalMissions > 0
+        ? roundNumber(readiness.completedMissions / readiness.totalMissions)
+        : 0;
+    // Compute average cycle time from missions with both started_at and completed_at
+    let avgCycleTimeDays = null;
+    const missionRows = client.getMany('SELECT id, status, started_at, completed_at FROM missions WHERE sprint_id = ? AND status = ? AND started_at IS NOT NULL AND completed_at IS NOT NULL', [sprintId, 'Completed']);
+    if (missionRows.success && missionRows.data && missionRows.data.length > 0) {
+        let totalMs = 0;
+        let count = 0;
+        for (const row of missionRows.data) {
+            if (row.started_at && row.completed_at) {
+                const started = Date.parse(row.started_at);
+                const completed = Date.parse(row.completed_at);
+                if (!Number.isNaN(started) && !Number.isNaN(completed) && completed >= started) {
+                    totalMs += completed - started;
+                    count += 1;
+                }
+            }
+        }
+        if (count > 0) {
+            avgCycleTimeDays = roundNumber(totalMs / count / (1000 * 60 * 60 * 24));
+        }
+    }
+    // Count decisions for this sprint
+    let decisionCount = 0;
+    const decisionCountResult = client.getOne(`SELECT COUNT(*) AS count FROM strategic_decisions
+     WHERE sprint_id = ?
+       OR mission_id IN (SELECT id FROM missions WHERE sprint_id = ?)
+       OR session_id IN (SELECT id FROM sessions WHERE sprint_id = ?)`, [sprintId, sprintId, sprintId]);
+    if (decisionCountResult.success && decisionCountResult.data) {
+        decisionCount = decisionCountResult.data.count;
+    }
+    // Count learnings for this sprint
+    let learningCount = 0;
+    const learningCountResult = client.getOne(`SELECT COUNT(*) AS count FROM learnings
+     WHERE sprint_id = ?
+       OR mission_id IN (SELECT id FROM missions WHERE sprint_id = ?)
+       OR session_id IN (SELECT id FROM sessions WHERE sprint_id = ?)`, [sprintId, sprintId, sprintId]);
+    if (learningCountResult.success && learningCountResult.data) {
+        learningCount = learningCountResult.data.count;
+    }
+    return {
+        completionRate,
+        avgCycleTimeDays,
+        decisionCount,
+        learningCount,
+        blockedCount: readiness.blockedMissions,
+    };
+}
+/**
+ * Clear project_context sprint-specific working_memory fields and update current_sprint.
+ * Clears session_history and recent_sessions arrays (sprint-scoped ephemeral data).
+ * Does NOT clear next_steps — that's handled by clearSprintLinkedNextSteps which is selective.
+ * Mutates the parsed content in-place for subsequent persistence.
+ */
+function clearProjectContextWorkingMemory(content, _sprintId) {
+    if (isPlainObject(content.working_memory)) {
+        const wm = content.working_memory;
+        // Clear sprint-scoped ephemeral arrays but NOT next_steps (handled separately)
+        const ephemeralKeys = ['session_history', 'recent_sessions'];
+        for (const key of ephemeralKeys) {
+            if (Array.isArray(wm[key])) {
+                wm[key] = [];
+            }
+        }
+    }
+    // Set current_sprint to null to signal the sprint is closed
+    if ('current_sprint' in content) {
+        content.current_sprint = null;
+    }
+    // Also clear active_mission if present
+    if ('active_mission' in content) {
+        content.active_mission = null;
+    }
+}
+function buildCloseoutMessage(sprintId, condensation, readiness) {
+    const parts = [`Sprint '${sprintId}' closed successfully`];
+    if (readiness.blockedMissions > 0) {
+        parts.push(`with ${readiness.blockedMissions} blocked mission${readiness.blockedMissions === 1 ? '' : 's'} left as carryover`);
+    }
+    if (condensation !== 'none') {
+        parts.push(`using ${condensation} context condensation`);
+    }
+    return parts.join(' ');
+}
+function roundNumber(value) {
+    return Math.round(value * 100) / 100;
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Format sprint closeout results for LLM readability.
+ */
+function formatSprintCompleteForLLM(result) {
+    if (!result.success || !result.data) {
+        const error = result.error;
+        const lines = [
+            '❌ Failed to complete sprint',
+            '',
+            `Error: ${error?.message ?? 'Unknown error'}`,
+        ];
+        if (error?.suggestion) {
+            lines.push('');
+            lines.push(`Suggestion: ${error.suggestion}`);
+        }
+        return lines.join('\n');
+    }
+    const data = result.data;
+    const lines = [
+        `✓ Sprint '${data.sprintId}' completed`,
+        '',
+        `Status: ${data.previousStatus ?? 'Unknown'} → ${data.currentStatus}`,
+        `Completed at: ${data.completedAt}`,
+        `Summary: ${data.summary}`,
+        '',
+        `Readiness: ${data.readiness.completedMissions}/${data.readiness.totalMissions} completed, ${data.readiness.blockedMissions} blocked, ${data.readiness.openMissions} open`,
+        '',
+        `KPIs: completion rate ${(data.lifecycle.kpis.completionRate * 100).toFixed(0)}%, avg cycle time ${data.lifecycle.kpis.avgCycleTimeDays !== null ? `${data.lifecycle.kpis.avgCycleTimeDays}d` : 'N/A'}, ${data.lifecycle.kpis.decisionCount} decisions, ${data.lifecycle.kpis.learningCount} learnings`,
+        `Archived: ${data.lifecycle.decisionsArchived} decisions, ${data.lifecycle.learningsArchived} learnings`,
+        `DB snapshot: ${data.lifecycle.dbSnapshotId ?? 'failed'}`,
+        '',
+        `master_context: ${data.contexts.masterContext.beforeSize.sizeKb.toFixed(2)}KB → ${data.contexts.masterContext.afterSize.sizeKb.toFixed(2)}KB, cleared ${data.contexts.masterContext.nextStepsCleared} next step(s)`,
+        `project_context: ${data.contexts.projectContext.beforeSize.sizeKb.toFixed(2)}KB → ${data.contexts.projectContext.afterSize.sizeKb.toFixed(2)}KB, cleared ${data.contexts.projectContext.nextStepsCleared} next step(s)`,
+        `Total context size: ${data.contexts.totalBeforeSizeKb.toFixed(2)}KB → ${data.contexts.totalAfterSizeKb.toFixed(2)}KB`,
+    ];
+    if (data.contexts.masterContext.condensation || data.contexts.projectContext.condensation) {
+        lines.push('');
+        if (data.contexts.masterContext.condensation) {
+            lines.push(`master_context condensation: ${data.contexts.masterContext.condensation.message}`);
+        }
+        if (data.contexts.projectContext.condensation) {
+            lines.push(`project_context condensation: ${data.contexts.projectContext.condensation.message}`);
+        }
+    }
+    if (result.warnings && result.warnings.length > 0) {
+        lines.push('');
+        lines.push('Warnings:');
+        for (const warning of result.warnings) {
+            lines.push(`- ${warning}`);
+        }
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=cmos-sprint-complete.js.map