@aquex/cmos-mcp 1.0.0

package/dist/intelligence/agentic-controller.js

@@ -0,0 +1,1376 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgenticController = exports.__test__ = exports.MissionStateManager = void 0;
+const events_1 = require("events");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const cmos_detector_1 = require("./cmos-detector");
+const context_propagator_v3_1 = require("./context-propagator-v3");
+const mission_history_1 = require("./mission-history");
+const cmos_sync_1 = require("./cmos-sync");
+const rsip_loop_1 = require("./rsip-loop");
+const telemetry_1 = require("./telemetry");
+const agentic_observability_1 = require("./agentic-observability");
+const boomerang_workflow_1 = require("./boomerang-workflow");
+const fs_2 = require("../utils/fs");
+const workspace_io_1 = require("../utils/workspace-io");
+const DEFAULT_STATE_PATH = 'agentic_state.json';
+const DEFAULT_SESSIONS_PATH = 'SESSIONS.jsonl';
+const DEFAULT_BOOMERANG_RUNTIME_ROOT = 'runtime/boomerang';
+const DEFAULT_BOOMERANG_RETENTION_DAYS = 7;
+const DEFAULT_BOOMERANG_MAX_RETRIES = 2;
+const DEFAULT_OBSERVABILITY_LOG_FILE = 'agentic-events.jsonl';
+const DEFAULT_GOVERNANCE_TELEMETRY_SOURCE = 'AgenticGovernance';
+const DEFAULT_CMOS_TELEMETRY_SOURCE = 'AgenticCMOS';
+const DEFAULT_CMOS_SYNC_TELEMETRY_SOURCE = 'AgenticCMOSSync';
+const DEFAULT_CMOS_SYNC_TRIGGERS = [
+    'mission_start',
+    'mission_complete',
+];
+function createMissionState(missionId, now) {
+    return {
+        missionId,
+        phase: 'idle',
+        status: 'queued',
+        activeSubMissions: [],
+        updatedAt: now,
+        history: [],
+        subMissions: [],
+    };
+}
+function cloneState(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function ensureUnique(list, value) {
+    return list.includes(value) ? list : [...list, value];
+}
+function removeValue(list, value) {
+    return list.filter((item) => item !== value);
+}
+function normalizeRSIPMetrics(metrics, fallbackTimestamp) {
+    if (!metrics) {
+        return undefined;
+    }
+    const safeRuns = typeof metrics.runs === 'number' && Number.isFinite(metrics.runs) && metrics.runs >= 0
+        ? Math.floor(metrics.runs)
+        : 0;
+    const safeIterations = typeof metrics.totalIterations === 'number' &&
+        Number.isFinite(metrics.totalIterations) &&
+        metrics.totalIterations >= 0
+        ? Math.floor(metrics.totalIterations)
+        : 0;
+    let lastRun;
+    if (metrics.lastRun) {
+        const persisted = metrics.lastRun;
+        const normalizeReason = (reason) => {
+            if (reason === 'disabled' || reason === 'converged' || reason === 'max_iterations') {
+                return reason;
+            }
+            if (reason === 'error') {
+                return 'error';
+            }
+            return 'max_iterations';
+        };
+        const iterations = Array.isArray(persisted.iterations)
+            ? persisted.iterations.map((entry, index) => ({
+                index: typeof entry?.index === 'number' && Number.isFinite(entry.index)
+                    ? Math.max(1, Math.floor(entry.index))
+                    : index + 1,
+                improvementScore: typeof entry?.improvementScore === 'number' ? entry.improvementScore : 0,
+                summary: typeof entry?.summary === 'string' ? entry.summary : undefined,
+            }))
+            : [];
+        lastRun = {
+            startedAt: typeof persisted.startedAt === 'string' && persisted.startedAt.length > 0
+                ? persisted.startedAt
+                : fallbackTimestamp,
+            completedAt: typeof persisted.completedAt === 'string' && persisted.completedAt.length > 0
+                ? persisted.completedAt
+                : fallbackTimestamp,
+            converged: typeof persisted.converged === 'boolean' ? persisted.converged : false,
+            reason: normalizeReason(persisted.reason),
+            iterations,
+        };
+    }
+    return {
+        runs: safeRuns,
+        totalIterations: safeIterations,
+        lastRun,
+    };
+}
+function normalizeBoomerangMetrics(metrics) {
+    if (!metrics) {
+        return undefined;
+    }
+    const safeRuns = typeof metrics.runs === 'number' && Number.isFinite(metrics.runs) && metrics.runs >= 0
+        ? Math.floor(metrics.runs)
+        : 0;
+    const lastRun = metrics.lastRun
+        ? cloneState(metrics.lastRun)
+        : undefined;
+    return {
+        runs: safeRuns,
+        lastRun,
+    };
+}
+class MissionStateManager {
+    constructor(options = {}) {
+        this.cachedState = null;
+        this.statePath = options.statePath ?? DEFAULT_STATE_PATH;
+        this.clock = options.clock ?? (() => new Date());
+    }
+    async getState() {
+        const state = await this.ensureState();
+        return cloneState(state);
+    }
+    async getMission(missionId) {
+        const state = await this.ensureState();
+        const mission = state.missions[missionId];
+        return mission ? cloneState(mission) : undefined;
+    }
+    async update(mutator) {
+        const state = await this.ensureState();
+        mutator(state);
+        state.lastUpdated = this.nowIso();
+        await this.persist(state);
+        return cloneState(state);
+    }
+    async ensureState() {
+        if (this.cachedState) {
+            return this.cachedState;
+        }
+        this.cachedState = await this.loadFromDisk();
+        return this.cachedState;
+    }
+    async loadFromDisk() {
+        try {
+            const raw = await fs_1.promises.readFile(this.statePath, 'utf-8');
+            if (raw.trim().length === 0) {
+                const emptyState = this.createEmptyState();
+                await this.persist(emptyState);
+                return emptyState;
+            }
+            const parsed = JSON.parse(raw);
+            return this.normalize(parsed);
+        }
+        catch (error) {
+            const err = error;
+            if (err && err.code !== 'ENOENT') {
+                throw error;
+            }
+            const emptyState = this.createEmptyState();
+            await this.persist(emptyState);
+            return emptyState;
+        }
+    }
+    normalize(state) {
+        const now = this.nowIso();
+        const workflow = {
+            activeMission: state.workflow?.activeMission,
+            queue: state.workflow?.queue ? [...state.workflow.queue] : [],
+            completed: state.workflow?.completed ? [...state.workflow.completed] : [],
+            paused: state.workflow?.paused ? [...state.workflow.paused] : [],
+        };
+        const missions = {};
+        for (const [missionId, mission] of Object.entries(state.missions ?? {})) {
+            const rawActiveSubMissions = Array.isArray(mission.activeSubMissions)
+                ? (mission.activeSubMissions ?? [])
+                : [];
+            const activeSubMissions = [];
+            for (const entry of rawActiveSubMissions) {
+                if (!entry || typeof entry.id !== 'string' || entry.id.length === 0) {
+                    continue;
+                }
+                activeSubMissions.push({
+                    id: entry.id,
+                    startedAt: typeof entry.startedAt === 'string' && entry.startedAt.length > 0
+                        ? entry.startedAt
+                        : now,
+                    parent: typeof entry.parent === 'string' && entry.parent.length > 0 ? entry.parent : undefined,
+                    objective: typeof entry.objective === 'string' && entry.objective.length > 0
+                        ? entry.objective
+                        : undefined,
+                    metadata: entry.metadata ? { ...entry.metadata } : undefined,
+                    previousContext: entry.previousContext
+                        ? cloneState(entry.previousContext)
+                        : undefined,
+                });
+            }
+            missions[missionId] = {
+                missionId,
+                phase: mission.phase ?? 'idle',
+                status: mission.status ?? 'queued',
+                objective: mission.objective,
+                currentSubMission: mission.currentSubMission,
+                activeSubMissions,
+                startedAt: mission.startedAt,
+                updatedAt: mission.updatedAt ?? now,
+                completedAt: mission.completedAt,
+                notes: mission.notes,
+                tags: mission.tags ? [...mission.tags] : undefined,
+                lastContext: mission.lastContext
+                    ? cloneState(mission.lastContext)
+                    : undefined,
+                lastDynamicQuery: mission.lastDynamicQuery,
+                history: Array.isArray(mission.history)
+                    ? mission.history.map((entry) => ({ ...entry }))
+                    : [],
+                subMissions: Array.isArray(mission.subMissions)
+                    ? mission.subMissions.map((entry) => ({ ...entry }))
+                    : [],
+                metadata: mission.metadata ? { ...mission.metadata } : undefined,
+                rsipMetrics: normalizeRSIPMetrics(mission.rsipMetrics, now),
+                boomerangMetrics: normalizeBoomerangMetrics(mission.boomerangMetrics),
+            };
+        }
+        return {
+            version: state.version ?? 1,
+            lastUpdated: state.lastUpdated ?? now,
+            missions,
+            workflow,
+        };
+    }
+    createEmptyState() {
+        const now = this.nowIso();
+        return {
+            version: 1,
+            lastUpdated: now,
+            missions: {},
+            workflow: {
+                queue: [],
+                completed: [],
+                paused: [],
+            },
+        };
+    }
+    async persist(state) {
+        const directory = (0, path_1.dirname)(this.statePath);
+        await fs_1.promises.mkdir(directory, { recursive: true });
+        const tempPath = `${this.statePath}.${process.pid}.${Date.now()}.tmp`;
+        const payload = JSON.stringify(state, null, 2);
+        await fs_1.promises.writeFile(tempPath, payload, 'utf-8');
+        await fs_1.promises.rename(tempPath, this.statePath);
+    }
+    nowIso() {
+        return this.clock().toISOString();
+    }
+}
+exports.MissionStateManager = MissionStateManager;
+exports.__test__ = {
+    createMissionState,
+    ensureUnique,
+    removeValue,
+    normalizeRSIPMetrics,
+    normalizeBoomerangMetrics,
+};
+class AgenticController {
+    constructor(options = {}) {
+        this.emitter = new events_1.EventEmitter();
+        this.cmosDetectionPromise = null;
+        this.cmosDetectionResult = null;
+        this.clock = options.clock ?? (() => new Date());
+        const resolvedStatePath = options.statePath ?? DEFAULT_STATE_PATH;
+        this.stateManager = new MissionStateManager({
+            statePath: resolvedStatePath,
+            clock: this.clock,
+        });
+        const sessionsPath = options.sessionsPath ?? DEFAULT_SESSIONS_PATH;
+        this.sessionsPath = sessionsPath;
+        this.historyAnalyzer =
+            options.historyAnalyzer ??
+                new mission_history_1.MissionHistoryAnalyzer({
+                    sessionsPath,
+                });
+        this.propagator =
+            options.propagator ??
+                new context_propagator_v3_1.ContextPropagatorV3(options.contextConfig ?? { maxContextTokens: 4096, strategy: 'map-reduce' }, this.historyAnalyzer);
+        this.historyLimit = options.historyLimit ?? 5;
+        this.autoPropagationPhases = new Set(options.autoPropagationPhases ?? ['execution', 'review']);
+        const guardrails = options.delegationGuardrails ?? {};
+        const requestedLimit = typeof guardrails.maxActiveSubMissions === 'number' &&
+            Number.isFinite(guardrails.maxActiveSubMissions)
+            ? Math.floor(guardrails.maxActiveSubMissions)
+            : NaN;
+        this.maxActiveSubMissions =
+            Number.isFinite(requestedLimit) && requestedLimit > 0
+                ? requestedLimit
+                : AgenticController.DEFAULT_MAX_ACTIVE_SUBMISSIONS;
+        this.delegationTelemetrySource =
+            guardrails.telemetrySource ?? AgenticController.DEFAULT_TELEMETRY_SOURCE;
+        const boomerang = options.boomerang ?? {};
+        const requestedRetries = typeof boomerang.maxRetries === 'number' && Number.isFinite(boomerang.maxRetries)
+            ? Math.floor(boomerang.maxRetries)
+            : NaN;
+        this.boomerangRuntimeRoot = boomerang.runtimeRoot ?? DEFAULT_BOOMERANG_RUNTIME_ROOT;
+        this.boomerangRetentionDays =
+            typeof boomerang.retentionDays === 'number' && Number.isFinite(boomerang.retentionDays)
+                ? boomerang.retentionDays
+                : DEFAULT_BOOMERANG_RETENTION_DAYS;
+        this.boomerangMaxRetries =
+            Number.isFinite(requestedRetries) && requestedRetries >= 0
+                ? requestedRetries
+                : DEFAULT_BOOMERANG_MAX_RETRIES;
+        const defaultObservabilityPath = (0, path_1.join)((0, path_1.dirname)(resolvedStatePath), DEFAULT_OBSERVABILITY_LOG_FILE);
+        const observabilityOption = options.observability;
+        if (observabilityOption instanceof agentic_observability_1.AgenticObservability) {
+            this.observability = observabilityOption;
+        }
+        else {
+            const observabilityOptions = observabilityOption && typeof observabilityOption === 'object'
+                ? observabilityOption
+                : {};
+            const logPath = observabilityOptions.logPath !== undefined
+                ? observabilityOptions.logPath
+                : defaultObservabilityPath;
+            this.observability = new agentic_observability_1.AgenticObservability({
+                ...observabilityOptions,
+                logPath,
+                clock: observabilityOptions.clock ?? this.clock,
+            });
+        }
+        this.governanceTelemetrySource =
+            options.governanceTelemetrySource ?? DEFAULT_GOVERNANCE_TELEMETRY_SOURCE;
+        const cmosOptions = options.cmos ?? {};
+        this.cmosIntegrationEnabled = cmosOptions.enabled !== false;
+        this.cmosProjectRoot = cmosOptions.projectRoot ?? process.cwd();
+        this.cmosDetector = cmosOptions.detector;
+        this.cmosDetectionOptions = cmosOptions.detectionOptions
+            ? { ...cmosOptions.detectionOptions }
+            : undefined;
+        this.cmosTelemetrySource = cmosOptions.telemetrySource ?? DEFAULT_CMOS_TELEMETRY_SOURCE;
+        const syncOptions = this.cmosIntegrationEnabled ? cmosOptions.sync : undefined;
+        this.cmosSyncTelemetrySource =
+            syncOptions?.telemetrySource ?? DEFAULT_CMOS_SYNC_TELEMETRY_SOURCE;
+        if (this.cmosIntegrationEnabled && syncOptions && syncOptions.enabled === true) {
+            const { service, automation, telemetrySource: _ignored, ...serviceOptions } = syncOptions;
+            const resolvedOptions = {
+                ...serviceOptions,
+                projectRoot: serviceOptions.projectRoot ?? this.cmosProjectRoot,
+                sessionsPath: serviceOptions.sessionsPath ?? sessionsPath,
+                detector: serviceOptions.detector ?? cmos_detector_1.CmosDetector.getInstance(),
+            };
+            this.cmosSyncService = service ?? new cmos_sync_1.CmosSyncService(resolvedOptions);
+            this.cmosSyncAutomation = this.normalizeSyncAutomationOptions(automation);
+        }
+        if (this.cmosIntegrationEnabled) {
+            this.runCmosDetection(cmosOptions.detectionOptions?.forceRefresh === true);
+        }
+    }
+    on(event, listener) {
+        this.emitter.on(event, listener);
+        return this;
+    }
+    off(event, listener) {
+        this.emitter.off(event, listener);
+        return this;
+    }
+    once(event, listener) {
+        this.emitter.once(event, listener);
+        return this;
+    }
+    async getState() {
+        return this.stateManager.getState();
+    }
+    async getCmosDetection(options = {}) {
+        if (!this.cmosIntegrationEnabled) {
+            return null;
+        }
+        if (options.forceRefresh) {
+            return this.runCmosDetection(true);
+        }
+        if (this.cmosDetectionResult) {
+            return this.cmosDetectionResult;
+        }
+        if (!this.cmosDetectionPromise) {
+            return this.runCmosDetection(false);
+        }
+        return this.cmosDetectionPromise;
+    }
+    async getMissionState(missionId) {
+        return this.stateManager.getMission(missionId);
+    }
+    async registerWorkflow(missionIds, options = {}) {
+        const now = this.nowIso();
+        const uniqueIds = Array.from(new Set(missionIds.filter(Boolean)));
+        const state = await this.stateManager.update((snapshot) => {
+            if (options.resetQueue) {
+                snapshot.workflow.queue = [...uniqueIds];
+            }
+            else {
+                for (const missionId of uniqueIds) {
+                    if (missionId !== snapshot.workflow.activeMission &&
+                        !snapshot.workflow.queue.includes(missionId)) {
+                        snapshot.workflow.queue.push(missionId);
+                    }
+                }
+            }
+            for (const missionId of uniqueIds) {
+                if (!snapshot.missions[missionId]) {
+                    snapshot.missions[missionId] = createMissionState(missionId, now);
+                }
+            }
+        });
+        this.emit('stateChanged', state);
+        return state;
+    }
+    async advanceWorkflow() {
+        const now = this.nowIso();
+        const currentState = await this.stateManager.getState();
+        const activeMissionId = currentState.workflow.activeMission;
+        if (activeMissionId) {
+            const activeMission = currentState.missions[activeMissionId];
+            if (activeMission &&
+                activeMission.status !== 'completed' &&
+                activeMission.status !== 'blocked') {
+                return currentState;
+            }
+        }
+        const state = await this.stateManager.update((snapshot) => {
+            const previousActive = snapshot.workflow.activeMission;
+            if (previousActive) {
+                snapshot.workflow.activeMission = undefined;
+                snapshot.workflow.completed = ensureUnique(snapshot.workflow.completed, previousActive);
+            }
+            const nextMissionId = snapshot.workflow.queue.shift();
+            if (!nextMissionId) {
+                return;
+            }
+            const mission = snapshot.missions[nextMissionId] ?? createMissionState(nextMissionId, now);
+            const priorPhase = mission.phase;
+            if (mission.phase === 'idle') {
+                mission.phase = 'planning';
+            }
+            if (mission.status === 'queued') {
+                mission.status = 'current';
+            }
+            mission.updatedAt = now;
+            mission.history.push(this.buildMissionEvent('workflow_routed', now, {
+                from: priorPhase,
+                to: mission.phase,
+            }));
+            snapshot.missions[nextMissionId] = mission;
+            snapshot.workflow.activeMission = nextMissionId;
+        });
+        if (state.workflow.activeMission) {
+            this.emit('workflowAdvanced', { missionId: state.workflow.activeMission, ts: now });
+        }
+        this.emit('stateChanged', state);
+        return state;
+    }
+    async startMission(missionId, options = {}) {
+        const now = this.nowIso();
+        const previous = await this.stateManager.getMission(missionId);
+        const previousPhase = previous?.phase ?? 'idle';
+        const state = await this.stateManager.update((snapshot) => {
+            const mission = snapshot.missions[missionId] ?? createMissionState(missionId, now);
+            const fromPhase = mission.phase;
+            const toPhase = options.phase ?? 'execution';
+            const phaseChanged = fromPhase !== toPhase;
+            mission.phase = toPhase;
+            mission.status = 'in_progress';
+            mission.objective = options.objective ?? mission.objective;
+            mission.currentSubMission = options.currentSubMission ?? mission.currentSubMission;
+            mission.notes = options.notes ?? mission.notes;
+            mission.tags = options.tags ?? mission.tags;
+            mission.metadata = options.metadata ?? mission.metadata;
+            mission.startedAt = mission.startedAt ?? now;
+            mission.updatedAt = now;
+            mission.history.push(this.buildMissionEvent('mission_started', now, {
+                currentSubMission: mission.currentSubMission,
+            }));
+            if (phaseChanged) {
+                mission.history.push(this.buildMissionEvent('phase_transition', now, {
+                    from: fromPhase,
+                    to: toPhase,
+                    reason: 'mission_start',
+                }));
+            }
+            snapshot.missions[missionId] = mission;
+            snapshot.workflow.activeMission = missionId;
+            snapshot.workflow.queue = removeValue(snapshot.workflow.queue, missionId);
+            snapshot.workflow.paused = removeValue(snapshot.workflow.paused, missionId);
+        });
+        const currentPhase = state.missions[missionId]?.phase ?? previousPhase;
+        if (currentPhase !== previousPhase) {
+            this.emit('phaseTransition', {
+                missionId,
+                from: previousPhase,
+                to: currentPhase,
+                ts: now,
+                reason: 'mission_start',
+            });
+        }
+        this.emit('stateChanged', state);
+        const missionState = state.missions[missionId];
+        if (missionState) {
+            await this.observability.recordEvent({
+                missionId,
+                category: 'mission',
+                type: 'mission_started',
+                status: missionState.status,
+                data: {
+                    phase: missionState.phase,
+                    objective: missionState.objective,
+                    tags: missionState.tags,
+                    currentSubMission: missionState.currentSubMission,
+                },
+            });
+        }
+        await this.recordMissionSessionEvent('mission_start', {
+            ts: now,
+            mission: missionId,
+            action: 'start',
+            status: missionState?.status ?? 'in_progress',
+            agent: options.agent,
+            summary: options.summary ?? missionState?.objective,
+        });
+        return state;
+    }
+    async updatePhase(missionId, phase, options = {}) {
+        const now = this.nowIso();
+        const previous = await this.stateManager.getMission(missionId);
+        const previousPhase = previous?.phase ?? 'idle';
+        const state = await this.stateManager.update((snapshot) => {
+            const mission = snapshot.missions[missionId] ?? createMissionState(missionId, now);
+            const fromPhase = mission.phase;
+            mission.phase = phase;
+            mission.currentSubMission = options.currentSubMission ?? mission.currentSubMission;
+            mission.updatedAt = now;
+            if (fromPhase !== phase) {
+                mission.history.push(this.buildMissionEvent('phase_transition', now, {
+                    from: fromPhase,
+                    to: phase,
+                    reason: options.reason,
+                }));
+            }
+            snapshot.missions[missionId] = mission;
+        });
+        if (phase !== previousPhase) {
+            this.emit('phaseTransition', {
+                missionId,
+                from: previousPhase,
+                to: phase,
+                ts: now,
+                reason: options.reason,
+            });
+        }
+        this.emit('stateChanged', state);
+        if (phase !== previousPhase) {
+            const missionState = state.missions[missionId];
+            if (missionState) {
+                await this.observability.recordEvent({
+                    missionId,
+                    category: 'mission',
+                    type: 'phase_transition',
+                    status: missionState.status,
+                    data: {
+                        from: previousPhase,
+                        to: missionState.phase,
+                        reason: options.reason,
+                    },
+                });
+            }
+        }
+        const shouldPropagate = options.autoPropagate ?? this.autoPropagationPhases.has(phase);
+        if (shouldPropagate) {
+            await this.triggerContextPropagation(missionId);
+        }
+        return state;
+    }
+    async beginSubMission(missionId, subMissionId, options = {}) {
+        const now = this.nowIso();
+        let telemetryContext;
+        const guardrailLimit = this.maxActiveSubMissions;
+        const state = await this.stateManager.update((snapshot) => {
+            const mission = snapshot.missions[missionId] ?? createMissionState(missionId, now);
+            const stack = mission.activeSubMissions ?? (mission.activeSubMissions = []);
+            const alreadyActive = stack.some((entry) => entry.id === subMissionId);
+            if (alreadyActive) {
+                throw new Error(`Sub-mission ${subMissionId} is already active for mission ${missionId}`);
+            }
+            if (guardrailLimit !== null && stack.length >= guardrailLimit) {
+                (0, telemetry_1.emitTelemetryWarning)(this.delegationTelemetrySource, 'sub_mission_guardrail_triggered', {
+                    missionId,
+                    attemptedSubMission: subMissionId,
+                    activeCount: stack.length,
+                    limit: guardrailLimit,
+                });
+                throw new Error(`Cannot begin sub-mission ${subMissionId} for mission ${missionId}: active sub-mission limit (${guardrailLimit}) reached.`);
+            }
+            const parent = mission.currentSubMission;
+            const contextSnapshot = mission.lastContext ? cloneState(mission.lastContext) : undefined;
+            stack.push({
+                id: subMissionId,
+                startedAt: now,
+                parent: parent ?? undefined,
+                objective: options.objective,
+                metadata: options.metadata ? { ...options.metadata } : undefined,
+                previousContext: contextSnapshot,
+            });
+            mission.currentSubMission = subMissionId;
+            mission.updatedAt = now;
+            mission.history.push(this.buildMissionEvent('sub_mission_started', now, {
+                subMissionId,
+                parent,
+            }));
+            telemetryContext = {
+                missionId,
+                subMissionId,
+                parent,
+                activeCount: stack.length,
+                guardrailLimit,
+            };
+            snapshot.missions[missionId] = mission;
+        });
+        this.emit('stateChanged', state);
+        if (telemetryContext) {
+            (0, telemetry_1.emitTelemetryInfo)(this.delegationTelemetrySource, 'sub_mission_started', telemetryContext);
+        }
+        const missionState = state.missions[missionId];
+        if (missionState) {
+            await this.observability.recordEvent({
+                missionId,
+                category: 'sub_mission',
+                type: 'sub_mission_started',
+                status: missionState.status,
+                data: {
+                    subMissionId,
+                    parent: telemetryContext?.parent,
+                    activeCount: missionState.activeSubMissions?.length ?? 0,
+                },
+            });
+        }
+        return state;
+    }
+    async recordSubMissionResult(missionId, result, options = {}) {
+        const now = this.nowIso();
+        const stored = {
+            missionId: result.missionId,
+            input: result.input,
+            output: result.output,
+            status: result.status,
+            timestamp: result.timestamp.toISOString(),
+            metadata: result.metadata,
+        };
+        const state = await this.stateManager.update((snapshot) => {
+            const mission = snapshot.missions[missionId] ?? createMissionState(missionId, now);
+            const shouldDedupe = options.dedupe !== false;
+            if (shouldDedupe) {
+                const exists = mission.subMissions.some((entry) => entry.missionId === stored.missionId && entry.timestamp === stored.timestamp);
+                if (!exists) {
+                    mission.subMissions.push(stored);
+                }
+            }
+            else {
+                mission.subMissions.push(stored);
+            }
+            mission.history.push(this.buildMissionEvent('sub_mission_recorded', now, {
+                subMissionId: stored.missionId,
+                status: stored.status,
+            }));
+            mission.updatedAt = now;
+            snapshot.missions[missionId] = mission;
+        });
+        this.emit('stateChanged', state);
+        if (options.autoPropagate) {
+            await this.triggerContextPropagation(missionId);
+        }
+        return state;
+    }
+    async completeSubMission(missionId, subMissionId, options) {
+        const timestampDate = options.timestamp ?? this.clock();
+        const timestamp = timestampDate.toISOString();
+        const autoPropagate = options.autoPropagate !== false;
+        let completionContext;
+        const state = await this.stateManager.update((snapshot) => {
+            const mission = snapshot.missions[missionId] ?? createMissionState(missionId, timestamp);
+            const stack = mission.activeSubMissions ?? (mission.activeSubMissions = []);
+            const active = stack[stack.length - 1];
+            if (!active || active.id !== subMissionId) {
+                (0, telemetry_1.emitTelemetryError)(this.delegationTelemetrySource, 'sub_mission_mismatch', {
+                    missionId,
+                    subMissionId,
+                    activeSubMission: active?.id,
+                });
+                throw new Error(`Sub-mission ${subMissionId} is not active for mission ${missionId}`);
+            }
+            const stored = {
+                missionId: subMissionId,
+                input: options.input,
+                output: options.output,
+                status: options.status,
+                timestamp,
+                metadata: options.metadata ? { ...options.metadata } : undefined,
+            };
+            mission.subMissions.push(stored);
+            stack.pop();
+            mission.currentSubMission = active.parent;
+            mission.updatedAt = timestamp;
+            mission.history.push(this.buildMissionEvent('sub_mission_recorded', timestamp, {
+                subMissionId,
+                status: options.status,
+            }));
+            mission.history.push(this.buildMissionEvent('sub_mission_committed', timestamp, {
+                subMissionId,
+                status: options.status,
+            }));
+            const startedMs = Date.parse(active.startedAt);
+            const durationMs = Number.isNaN(startedMs)
+                ? undefined
+                : Math.max(0, Date.parse(timestamp) - startedMs);
+            completionContext = {
+                missionId,
+                subMissionId,
+                status: options.status,
+                recordedAt: timestamp,
+                durationMs,
+                remainingActive: stack.length,
+            };
+            snapshot.missions[missionId] = mission;
+        });
+        this.emit('stateChanged', state);
+        if (completionContext) {
+            (0, telemetry_1.emitTelemetryInfo)(this.delegationTelemetrySource, 'sub_mission_completed', completionContext);
+        }
+        const missionState = state.missions[missionId];
+        if (missionState) {
+            await this.observability.recordEvent({
+                missionId,
+                category: 'sub_mission',
+                type: 'sub_mission_completed',
+                status: options.status,
+                data: {
+                    subMissionId,
+                    status: options.status,
+                    durationMs: completionContext?.durationMs,
+                    remainingActive: missionState.activeSubMissions?.length ?? 0,
+                },
+            });
+        }
+        if (autoPropagate) {
+            await this.triggerContextPropagation(missionId);
+            return this.stateManager.getState();
+        }
+        return state;
+    }
+    async rollbackSubMission(missionId, subMissionId, options = {}) {
+        const now = this.nowIso();
+        const restoreContext = options.restoreContext !== false;
+        let rollbackContext;
+        const state = await this.stateManager.update((snapshot) => {
+            const mission = snapshot.missions[missionId] ?? createMissionState(missionId, now);
+            const stack = mission.activeSubMissions ?? (mission.activeSubMissions = []);
+            const active = stack[stack.length - 1];
+            if (!active || active.id !== subMissionId) {
+                (0, telemetry_1.emitTelemetryError)(this.delegationTelemetrySource, 'sub_mission_mismatch', {
+                    missionId,
+                    subMissionId,
+                    activeSubMission: active?.id,
+                    phase: 'rollback',
+                });
+                throw new Error(`Sub-mission ${subMissionId} is not active for mission ${missionId}`);
+            }
+            stack.pop();
+            mission.currentSubMission = active.parent;
+            if (restoreContext && active.previousContext) {
+                mission.lastContext = cloneState(active.previousContext);
+            }
+            mission.updatedAt = now;
+            mission.history.push(this.buildMissionEvent('sub_mission_rolled_back', now, {
+                subMissionId,
+                reason: options.reason,
+            }));
+            rollbackContext = {
+                missionId,
+                subMissionId,
+                reason: options.reason,
+                restoredContext: restoreContext && Boolean(active.previousContext),
+                remainingActive: stack.length,
+            };
+            snapshot.missions[missionId] = mission;
+        });
+        this.emit('stateChanged', state);
+        if (rollbackContext) {
+            (0, telemetry_1.emitTelemetryWarning)(this.delegationTelemetrySource, 'sub_mission_rolled_back', rollbackContext);
+        }
+        const missionState = state.missions[missionId];
+        if (missionState) {
+            await this.observability.recordEvent({
+                missionId,
+                category: 'sub_mission',
+                type: 'sub_mission_rolled_back',
+                status: missionState.status,
+                data: {
+                    subMissionId,
+                    reason: options.reason,
+                    remainingActive: missionState.activeSubMissions?.length ?? 0,
+                },
+            });
+        }
+        return state;
+    }
+    async completeMission(missionId, options = {}) {
+        const now = this.nowIso();
+        const previous = await this.stateManager.getMission(missionId);
+        const previousPhase = previous?.phase ?? 'idle';
+        const previousStatus = previous?.status ?? 'in_progress';
+        const activeSubMissions = previous?.activeSubMissions ?? [];
+        if (activeSubMissions.length > 0) {
+            await this.logMissionCompletionBlocked(missionId, previousStatus, activeSubMissions.map((entry) => entry.id));
+            throw new Error(`Mission ${missionId} cannot be completed while sub-missions remain active.`);
+        }
+        let state;
+        try {
+            state = await this.stateManager.update((snapshot) => {
+                const mission = snapshot.missions[missionId] ?? createMissionState(missionId, now);
+                const fromPhase = mission.phase;
+                const remainingActive = mission.activeSubMissions ?? [];
+                if (remainingActive.length > 0) {
+                    throw new Error(`Mission ${missionId} cannot be completed while sub-missions remain active.`);
+                }
+                mission.phase = 'completed';
+                mission.status = 'completed';
+                mission.completedAt = now;
+                mission.updatedAt = now;
+                mission.notes = options.notes ?? mission.notes;
+                mission.metadata = options.metadata ?? mission.metadata;
+                mission.activeSubMissions = [];
+                mission.currentSubMission = undefined;
+                mission.history.push(this.buildMissionEvent('mission_completed', now, {
+                    summary: options.summary,
+                }));
+                if (fromPhase !== 'completed') {
+                    mission.history.push(this.buildMissionEvent('phase_transition', now, {
+                        from: fromPhase,
+                        to: 'completed',
+                        reason: 'mission_completed',
+                    }));
+                }
+                snapshot.missions[missionId] = mission;
+                if (snapshot.workflow.activeMission === missionId) {
+                    snapshot.workflow.activeMission = undefined;
+                }
+                snapshot.workflow.completed = ensureUnique(snapshot.workflow.completed, missionId);
+            });
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('sub-missions remain active')) {
+                const latest = await this.stateManager.getMission(missionId);
+                const latestIds = latest?.activeSubMissions?.map((entry) => entry.id) ?? [];
+                if (latestIds.length > 0) {
+                    await this.logMissionCompletionBlocked(missionId, latest?.status ?? previousStatus, latestIds);
+                }
+            }
+            throw error;
+        }
+        const currentPhase = state.missions[missionId]?.phase ?? previousPhase;
+        if (currentPhase !== previousPhase) {
+            this.emit('phaseTransition', {
+                missionId,
+                from: previousPhase,
+                to: currentPhase,
+                ts: now,
+                reason: 'mission_completed',
+            });
+        }
+        this.emit('stateChanged', state);
+        const missionState = state.missions[missionId];
+        if (missionState) {
+            await this.observability.recordEvent({
+                missionId,
+                category: 'mission',
+                type: 'mission_completed',
+                status: missionState.status,
+                data: {
+                    summary: options.summary,
+                },
+            });
+            await this.observability.recordQualityGate({
+                missionId,
+                gate: 'mission_completion',
+                status: 'passed',
+                detail: 'Mission completed successfully.',
+                data: {
+                    summary: options.summary,
+                },
+            });
+        }
+        await this.recordMissionSessionEvent('mission_complete', {
+            ts: now,
+            mission: missionId,
+            action: 'complete',
+            status: missionState?.status ?? 'completed',
+            agent: options.agent,
+            summary: options.summary,
+            next_hint: options.nextHint,
+        });
+        return state;
+    }
+    async pauseMission(missionId, options = {}) {
+        const current = await this.stateManager.getMission(missionId);
+        if (!current || current.status === 'paused') {
+            return this.stateManager.getState();
+        }
+        const now = this.nowIso();
+        const state = await this.stateManager.update((snapshot) => {
+            const mission = snapshot.missions[missionId];
+            /* istanbul ignore if -- mission presence guaranteed by pre-check */
+            if (!mission) {
+                return;
+            }
+            mission.status = 'paused';
+            mission.updatedAt = now;
+            mission.history.push(this.buildMissionEvent('mission_paused', now, {
+                note: options.note,
+            }));
+            snapshot.workflow.paused = ensureUnique(snapshot.workflow.paused, missionId);
+            if (snapshot.workflow.activeMission === missionId) {
+                snapshot.workflow.activeMission = undefined;
+            }
+        });
+        this.emit('missionPaused', { missionId, ts: now, note: options.note });
+        this.emit('stateChanged', state);
+        return state;
+    }
+    async resumeMission(missionId) {
+        const current = await this.stateManager.getMission(missionId);
+        if (!current || current.status !== 'paused') {
+            return this.stateManager.getState();
+        }
+        const now = this.nowIso();
+        const state = await this.stateManager.update((snapshot) => {
+            const mission = snapshot.missions[missionId];
+            /* istanbul ignore if -- mission presence guaranteed by pre-check */
+            if (!mission) {
+                return;
+            }
+            mission.status = 'in_progress';
+            if (mission.phase === 'idle') {
+                mission.phase = 'execution';
+            }
+            mission.updatedAt = now;
+            mission.history.push(this.buildMissionEvent('mission_resumed', now));
+            snapshot.workflow.activeMission = missionId;
+            snapshot.workflow.paused = removeValue(snapshot.workflow.paused, missionId);
+        });
+        this.emit('missionResumed', { missionId, ts: now });
+        this.emit('stateChanged', state);
+        return state;
+    }
+    async logMissionCompletionBlocked(missionId, status, activeSubMissions) {
+        await this.observability.recordEvent({
+            missionId,
+            category: 'mission',
+            type: 'mission_completion_blocked',
+            status,
+            data: {
+                activeSubMissions: activeSubMissions.slice(),
+            },
+        });
+        await this.observability.recordQualityGate({
+            missionId,
+            gate: 'mission_completion',
+            status: 'failed',
+            detail: 'Active sub-missions must be completed before mission completion.',
+            data: {
+                activeSubMissions: activeSubMissions.slice(),
+            },
+        });
+        (0, telemetry_1.emitTelemetryError)(this.governanceTelemetrySource, 'mission_completion_blocked', {
+            missionId,
+            activeSubMissions,
+        });
+    }
+    async runBoomerangWorkflow(missionId, steps, options = {}) {
+        if (!steps || steps.length === 0) {
+            throw new Error('Boomerang workflow requires at least one step');
+        }
+        const workflow = new boomerang_workflow_1.BoomerangWorkflow({
+            missionId,
+            steps,
+            runtimeRoot: options.runtimeRoot ?? this.boomerangRuntimeRoot,
+            retentionDays: options.retentionDays ?? this.boomerangRetentionDays,
+            maxRetries: options.maxRetries ?? this.boomerangMaxRetries,
+            telemetrySource: options.telemetrySource ?? `Boomerang:${missionId}`,
+            clock: options.clock ?? this.clock,
+        });
+        const summary = await workflow.execute(options.initialPayload);
+        const state = await this.stateManager.update((snapshot) => {
+            const mission = snapshot.missions[missionId] ?? createMissionState(missionId, summary.startedAt);
+            const previousRuns = mission.boomerangMetrics?.runs ?? 0;
+            mission.boomerangMetrics = {
+                runs: previousRuns + 1,
+                lastRun: {
+                    startedAt: summary.startedAt,
+                    completedAt: summary.completedAt,
+                    status: summary.status,
+                    completedSteps: [...summary.completedSteps],
+                    failedStep: summary.failedStep,
+                    fallbackReason: summary.fallbackReason,
+                    diagnostics: { ...summary.diagnostics },
+                    lastOutput: summary.lastOutput,
+                },
+            };
+            mission.history.push(this.buildMissionEvent('boomerang_run_completed', summary.completedAt, {
+                status: summary.status,
+                completedSteps: summary.completedSteps,
+                failedStep: summary.failedStep,
+                fallbackReason: summary.fallbackReason,
+                retainedCheckpoints: summary.diagnostics.retainedCheckpoints,
+            }));
+            if (summary.status === 'fallback') {
+                mission.history.push(this.buildMissionEvent('boomerang_fallback_triggered', summary.completedAt, {
+                    failedStep: summary.failedStep,
+                    fallbackReason: summary.fallbackReason,
+                    attempts: summary.diagnostics.attempts,
+                }));
+            }
+            mission.updatedAt = summary.completedAt;
+            snapshot.missions[missionId] = mission;
+        });
+        this.emit('stateChanged', state);
+        await this.observability.recordEvent({
+            missionId,
+            category: 'workflow',
+            type: 'boomerang_run_completed',
+            status: summary.status,
+            data: {
+                completedSteps: summary.completedSteps,
+                failedStep: summary.failedStep,
+                fallbackReason: summary.fallbackReason,
+                retainedCheckpoints: summary.diagnostics.retainedCheckpoints,
+            },
+        });
+        const gateStatus = summary.status === 'success' ? 'passed' : 'failed';
+        const gateDetail = summary.status === 'success'
+            ? 'Boomerang workflow completed successfully.'
+            : summary.status === 'fallback'
+                ? 'Boomerang workflow fallback triggered.'
+                : 'Boomerang workflow failed.';
+        await this.observability.recordQualityGate({
+            missionId,
+            gate: 'boomerang_run_status',
+            status: gateStatus,
+            detail: gateDetail,
+            data: {
+                status: summary.status,
+                failedStep: summary.failedStep,
+                fallbackReason: summary.fallbackReason,
+            },
+        });
+        return summary;
+    }
+    async runSelfImprovementLoop(missionId, handlers, options) {
+        const mergedOptions = {
+            ...(options ?? {}),
+            telemetrySource: options?.telemetrySource ?? `RSIP:${missionId}`,
+            clock: options?.clock ?? this.clock,
+        };
+        const loopSummary = await (0, rsip_loop_1.runRSIPLoop)(handlers, mergedOptions);
+        const state = await this.stateManager.update((snapshot) => {
+            const mission = snapshot.missions[missionId] ?? createMissionState(missionId, loopSummary.startedAt);
+            const previous = mission.rsipMetrics ?? { runs: 0, totalIterations: 0 };
+            mission.rsipMetrics = {
+                runs: previous.runs + 1,
+                totalIterations: previous.totalIterations + loopSummary.iterations.length,
+                lastRun: {
+                    startedAt: loopSummary.startedAt,
+                    completedAt: loopSummary.completedAt,
+                    converged: loopSummary.converged,
+                    reason: loopSummary.reason,
+                    iterations: loopSummary.iterations.map((iteration, index) => ({
+                        index: index + 1,
+                        improvementScore: iteration.improvementScore,
+                        summary: iteration.summary,
+                    })),
+                },
+            };
+            mission.history.push(this.buildMissionEvent('self_improvement_run', loopSummary.completedAt, {
+                iterations: loopSummary.iterations.length,
+                converged: loopSummary.converged,
+                reason: loopSummary.reason,
+            }));
+            mission.updatedAt = loopSummary.completedAt;
+            snapshot.missions[missionId] = mission;
+        });
+        const mission = state.missions[missionId];
+        if (mission?.rsipMetrics?.lastRun) {
+            this.emit('selfImprovementRun', { missionId, summary: mission.rsipMetrics.lastRun });
+        }
+        this.emit('stateChanged', state);
+        await this.observability.recordEvent({
+            missionId,
+            category: 'workflow',
+            type: 'self_improvement_run',
+            status: loopSummary.converged ? 'converged' : (loopSummary.reason ?? 'stopped'),
+            data: {
+                iterations: loopSummary.iterations.length,
+                converged: loopSummary.converged,
+                reason: loopSummary.reason,
+            },
+        });
+        await this.observability.recordQualityGate({
+            missionId,
+            gate: 'self_improvement_convergence',
+            status: loopSummary.converged ? 'passed' : 'warning',
+            detail: loopSummary.converged
+                ? 'RSIP loop converged successfully.'
+                : `RSIP loop ended without convergence (${loopSummary.reason ?? 'unknown'}).`,
+            data: {
+                iterations: loopSummary.iterations.length,
+                converged: loopSummary.converged,
+                reason: loopSummary.reason,
+            },
+        });
+        return loopSummary;
+    }
+    async buildDynamicQuery(missionId, baseQuery, options = {}) {
+        const historyLimit = options.historyLimit ?? this.historyLimit;
+        const events = await this.historyAnalyzer.loadEvents();
+        const relevantEvents = events
+            .filter((event) => event.mission === missionId)
+            .slice(-historyLimit);
+        const state = await this.stateManager.getState();
+        const mission = state.missions[missionId] ?? createMissionState(missionId, this.nowIso());
+        const lines = [];
+        lines.push(`Mission ${missionId} Agentic Query`);
+        if (mission.objective) {
+            lines.push(`Objective: ${mission.objective}`);
+        }
+        lines.push(`Status: ${mission.status}`);
+        lines.push(`Phase: ${mission.phase}`);
+        if (mission.currentSubMission) {
+            lines.push(`Active Sub-Mission: ${mission.currentSubMission}`);
+        }
+        const includeSummary = options.includeContextSummary ?? true;
+        if (includeSummary && mission.lastContext) {
+            lines.push(`Latest Context Summary (${mission.lastContext.generatedAt}):`);
+            lines.push(mission.lastContext.summary.summary);
+        }
+        if ((!includeSummary || !mission.lastContext) && options.supplementalContext) {
+            lines.push('Supplemental Context:');
+            lines.push(options.supplementalContext);
+        }
+        if (relevantEvents.length > 0) {
+            lines.push('Recent Mission History:');
+            for (const event of relevantEvents) {
+                const parts = [`[${event.ts}]`, event.action.toUpperCase()];
+                if (event.status) {
+                    parts.push(`(${event.status})`);
+                }
+                if (event.summary) {
+                    parts.push(`→ ${event.summary}`);
+                }
+                if (event.next_hint) {
+                    parts.push(`next: ${event.next_hint}`);
+                }
+                lines.push(parts.join(' '));
+            }
+        }
+        lines.push('Primary Prompt:');
+        lines.push(baseQuery.trim());
+        const query = lines.join('\n');
+        const generatedAt = this.nowIso();
+        const snapshot = {
+            generatedAt,
+            query,
+            baseQuery,
+            historyEvents: relevantEvents,
+        };
+        const updatedState = await this.stateManager.update((mutable) => {
+            const target = mutable.missions[missionId] ?? createMissionState(missionId, generatedAt);
+            target.lastDynamicQuery = snapshot;
+            target.history.push(this.buildMissionEvent('query_built', generatedAt, {
+                historyCount: relevantEvents.length,
+            }));
+            target.updatedAt = generatedAt;
+            mutable.missions[missionId] = target;
+        });
+        this.emit('queryReady', { missionId, query, baseQuery, generatedAt });
+        this.emit('stateChanged', updatedState);
+        return query;
+    }
+    async triggerContextPropagation(missionId) {
+        const state = await this.stateManager.getState();
+        const mission = state.missions[missionId];
+        /* istanbul ignore if -- mission existence ensured before propagation */
+        if (!mission) {
+            return;
+        }
+        const completedResults = mission.subMissions.map((entry) => ({
+            missionId: entry.missionId,
+            input: entry.input,
+            output: entry.output,
+            status: entry.status,
+            timestamp: new Date(entry.timestamp),
+            metadata: entry.metadata,
+        }));
+        const relatedMissionIds = this.collectRelatedMissionIds(state, missionId);
+        const summary = await this.propagator.propagateContext(mission.objective ?? missionId, completedResults, mission.currentSubMission ?? missionId, {
+            includeHistory: true,
+            relatedMissionIds,
+        });
+        const generatedAt = this.nowIso();
+        const contextSnapshot = {
+            generatedAt,
+            summary,
+        };
+        const updatedState = await this.stateManager.update((mutable) => {
+            const target = mutable.missions[missionId] ?? createMissionState(missionId, generatedAt);
+            target.lastContext = contextSnapshot;
+            target.history.push(this.buildMissionEvent('context_propagated', generatedAt, {
+                strategy: summary.strategy,
+                tokenCount: summary.tokenCount,
+                retrievedChunks: summary.retrievedChunks.length,
+            }));
+            target.updatedAt = generatedAt;
+            mutable.missions[missionId] = target;
+        });
+        this.emit('contextUpdated', { missionId, context: contextSnapshot });
+        this.emit('stateChanged', updatedState);
+    }
+    collectRelatedMissionIds(state, missionId) {
+        const related = [
+            ...state.workflow.completed.slice(-3),
+            ...state.workflow.queue.slice(0, 2),
+        ].filter((id) => id && id !== missionId);
+        return Array.from(new Set(related));
+    }
+    normalizeSyncAutomationOptions(automation) {
+        const triggers = automation?.triggers && automation.triggers.length > 0
+            ? Array.from(new Set(automation.triggers))
+            : [...DEFAULT_CMOS_SYNC_TRIGGERS];
+        return {
+            includeContexts: automation?.includeContexts ?? false,
+            includeSessionEvents: automation?.includeSessionEvents ?? true,
+            direction: automation?.direction,
+            force: automation?.force,
+            triggers,
+        };
+    }
+    buildMissionEvent(type, ts, payload) {
+        return {
+            ts,
+            type,
+            payload,
+        };
+    }
+    async recordMissionSessionEvent(trigger, event) {
+        await this.appendSessionEvent(event);
+        await this.runCmosAutoSync(trigger);
+    }
+    async appendSessionEvent(event) {
+        const targetPath = await (0, workspace_io_1.resolveWorkspacePath)(this.sessionsPath, {
+            allowRelative: true,
+            baseDir: this.cmosProjectRoot,
+        });
+        await (0, fs_2.ensureDir)((0, path_1.dirname)(targetPath));
+        await fs_1.promises.appendFile(targetPath, `${JSON.stringify(event)}\n`, 'utf-8');
+    }
+    async runCmosAutoSync(trigger) {
+        if (!this.cmosSyncService || !this.cmosSyncAutomation) {
+            return;
+        }
+        const triggers = this.cmosSyncAutomation.triggers ?? DEFAULT_CMOS_SYNC_TRIGGERS;
+        if (triggers.length > 0 && !triggers.includes(trigger)) {
+            return;
+        }
+        const includeContexts = this.cmosSyncAutomation.includeContexts ?? false;
+        const includeSessionEvents = this.cmosSyncAutomation.includeSessionEvents ?? true;
+        if (!includeContexts && !includeSessionEvents) {
+            return;
+        }
+        const request = {
+            direction: this.cmosSyncAutomation.direction,
+            force: this.cmosSyncAutomation.force,
+            includeContexts,
+            includeSessionEvents,
+        };
+        try {
+            const result = await this.cmosSyncService.syncAll(request);
+            this.reportCmosSyncResult(trigger, result);
+        }
+        catch (error) {
+            (0, telemetry_1.emitTelemetryWarning)(this.cmosSyncTelemetrySource, 'cmos_sync_failed', {
+                trigger,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    reportCmosSyncResult(trigger, result) {
+        const context = {
+            trigger,
+            status: result.status,
+            ok: result.ok,
+            direction: result.direction,
+            durationMs: result.durationMs,
+            sessionEventsInserted: result.sessionEvents.inserted,
+            sessionEventsSkipped: result.sessionEvents.skipped,
+            warnings: result.warnings,
+            errors: result.errors,
+        };
+        if (result.ok) {
+            (0, telemetry_1.emitTelemetryInfo)(this.cmosSyncTelemetrySource, 'cmos_sync_completed', context);
+        }
+        else {
+            (0, telemetry_1.emitTelemetryWarning)(this.cmosSyncTelemetrySource, 'cmos_sync_partial', context);
+        }
+    }
+    emit(event, payload) {
+        this.emitter.emit(event, payload);
+    }
+    runCmosDetection(forceRefresh) {
+        if (!this.cmosIntegrationEnabled) {
+            return Promise.resolve(null);
+        }
+        const execution = this.executeCmosDetection(forceRefresh);
+        const trackedPromise = execution.finally(() => {
+            if (this.cmosDetectionPromise === trackedPromise) {
+                this.cmosDetectionPromise = null;
+            }
+        });
+        this.cmosDetectionPromise = trackedPromise;
+        return trackedPromise;
+    }
+    async executeCmosDetection(forceRefresh) {
+        try {
+            const detector = this.cmosDetector ?? cmos_detector_1.CmosDetector.getInstance();
+            const detectionOptions = this.buildCmosDetectionOptions(forceRefresh);
+            const result = await detector.detect(this.cmosProjectRoot, detectionOptions);
+            this.cmosDetectionResult = result;
+            (0, telemetry_1.emitTelemetryInfo)(this.cmosTelemetrySource, 'cmos_detection_status', {
+                projectRoot: result.projectRoot,
+                cmosDirectory: result.cmosDirectory,
+                hasCmosDirectory: result.hasCmosDirectory,
+                hasDatabase: result.hasDatabase,
+                databasePath: result.databasePath,
+                checkedAt: result.checkedAt,
+            });
+            return result;
+        }
+        catch (error) {
+            this.cmosDetectionResult = null;
+            (0, telemetry_1.emitTelemetryWarning)(this.cmosTelemetrySource, 'cmos_detection_failed', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return null;
+        }
+    }
+    buildCmosDetectionOptions(forceRefresh) {
+        const baseOptions = this.cmosDetectionOptions;
+        if (forceRefresh || baseOptions?.forceRefresh) {
+            return {
+                ...(baseOptions ?? {}),
+                forceRefresh: true,
+            };
+        }
+        return baseOptions;
+    }
+    nowIso() {
+        return this.clock().toISOString();
+    }
+}
+exports.AgenticController = AgenticController;
+AgenticController.DEFAULT_MAX_ACTIVE_SUBMISSIONS = 8;
+AgenticController.DEFAULT_TELEMETRY_SOURCE = 'AgenticDelegation';
+//# sourceMappingURL=agentic-controller.js.map