@cleocode/cleo 2026.2.5

package/dist/mcp/domains/research.js

@@ -0,0 +1,698 @@
+/**
+ * Research Domain Handler
+ *
+ * Implements all 10 research operations for CLEO MCP server:
+ * - Query (5): list, stats, validate, search, export
+ * - Mutate (5): link, unlink, import, aggregate, report
+ *
+ * Maps to cleo research CLI commands with proper parameter validation.
+ *
+ * @task T2931
+ */
+import { createGatewayMeta } from '../lib/gateway-meta.js';
+import { ManifestReader } from '../lib/manifest.js';
+import { validateEntry, serializeEntry } from '../lib/manifest-parser.js';
+import { appendFile, writeFile } from 'fs/promises';
+import { canRunNatively } from '../engine/capability-matrix.js';
+import { getManifestPath as getCentralManifestPath, getManifestArchivePath } from '../../core/paths.js';
+import { researchShow as nativeResearchShow, researchList as nativeResearchList, researchQuery as nativeResearchQuery, researchPending as nativeResearchPending, researchStats as nativeResearchStats, researchManifestRead as nativeResearchManifestRead, researchLink as nativeResearchLink, researchManifestAppend as nativeResearchManifestAppend, researchManifestArchive as nativeResearchManifestArchive, researchContradictions as nativeResearchContradictions, researchSuperseded as nativeResearchSuperseded, researchInject as nativeResearchInject, researchCompact as nativeResearchCompact, researchValidateOp as nativeResearchValidate, } from '../engine/index.js';
+import { getProjectRoot } from '../../core/paths.js';
+/**
+ * Research domain handler implementation
+ */
+export class ResearchHandler {
+    executor;
+    manifestReader;
+    executionMode;
+    projectRoot;
+    constructor(executor, manifestPath, executionMode = 'cli') {
+        this.executor = executor;
+        this.manifestReader = new ManifestReader(manifestPath ?? getCentralManifestPath());
+        this.executionMode = executionMode;
+        this.projectRoot = getProjectRoot();
+    }
+    /**
+     * Check if we should use native engine for this operation
+     */
+    useNative(operation, gateway) {
+        if (this.executionMode === 'cli' && this.executor.isAvailable()) {
+            return false;
+        }
+        return canRunNatively('research', operation, gateway);
+    }
+    /**
+     * Wrap a native engine result in DomainResponse format
+     */
+    wrapNativeResult(result, gateway, operation, startTime) {
+        if (result.success) {
+            return {
+                _meta: createGatewayMeta(gateway, 'research', operation, startTime),
+                success: true,
+                data: result.data,
+            };
+        }
+        return {
+            _meta: createGatewayMeta(gateway, 'research', operation, startTime),
+            success: false,
+            error: { code: result.error?.code || 'E_UNKNOWN', message: result.error?.message || 'Unknown error' },
+        };
+    }
+    /**
+     * Query operations (read-only)
+     */
+    async query(operation, params) {
+        const startTime = Date.now();
+        // Native engine routing for supported operations
+        if (this.useNative(operation, 'query')) {
+            try {
+                return this.queryNative(operation, params, startTime);
+            }
+            catch (error) {
+                return this.handleError('cleo_query', 'research', operation, error, startTime);
+            }
+        }
+        // CLI-only operations: check CLI availability
+        if (!this.executor.isAvailable()) {
+            return this.createErrorResponse('cleo_query', 'research', operation, 'E_CLI_REQUIRED', `Operation 'research.${operation}' requires the CLEO CLI (bash). Install with: ./install.sh`, startTime);
+        }
+        try {
+            switch (operation) {
+                case 'list':
+                    return await this.queryList(params);
+                case 'stats':
+                    return await this.queryStats(params);
+                case 'validate':
+                    return await this.queryValidate(params);
+                case 'find':
+                    return await this.querySearch(params);
+                case 'export':
+                    return await this.queryExport(params);
+                case 'manifest.read':
+                    return await this.queryManifestRead(params);
+                case 'manifest.validate':
+                    return await this.queryManifestValidate();
+                case 'manifest.summary':
+                    return await this.queryManifestSummary();
+                case 'show':
+                    return await this.queryShow(params);
+                case 'pending':
+                    return await this.queryPending(params);
+                case 'contradictions':
+                    return this.wrapNativeResult(nativeResearchContradictions(this.projectRoot, params), 'cleo_query', operation, startTime);
+                case 'superseded':
+                    return this.wrapNativeResult(nativeResearchSuperseded(this.projectRoot, params), 'cleo_query', operation, startTime);
+                default:
+                    return this.createErrorResponse('cleo_query', 'research', operation, 'E_INVALID_OPERATION', `Unknown query operation: ${operation}`, startTime);
+            }
+        }
+        catch (error) {
+            return this.handleError('cleo_query', 'research', operation, error, startTime);
+        }
+    }
+    /**
+     * Native query dispatch
+     */
+    queryNative(operation, params, startTime) {
+        switch (operation) {
+            case 'show':
+                return this.wrapNativeResult(nativeResearchShow(params?.researchId, this.projectRoot), 'cleo_query', operation, startTime);
+            case 'list':
+                return this.wrapNativeResult(nativeResearchList(params, this.projectRoot), 'cleo_query', operation, startTime);
+            case 'find':
+                return this.wrapNativeResult(nativeResearchQuery(params?.query, { confidence: params?.confidence, limit: params?.limit }, this.projectRoot), 'cleo_query', operation, startTime);
+            case 'pending':
+                return this.wrapNativeResult(nativeResearchPending(params?.epicId, this.projectRoot), 'cleo_query', operation, startTime);
+            case 'stats':
+                return this.wrapNativeResult(nativeResearchStats(params?.epicId, this.projectRoot), 'cleo_query', operation, startTime);
+            case 'manifest.read':
+                return this.wrapNativeResult(nativeResearchManifestRead(params, this.projectRoot), 'cleo_query', operation, startTime);
+            case 'contradictions':
+                return this.wrapNativeResult(nativeResearchContradictions(this.projectRoot, params), 'cleo_query', operation, startTime);
+            case 'superseded':
+                return this.wrapNativeResult(nativeResearchSuperseded(this.projectRoot, params), 'cleo_query', operation, startTime);
+            default:
+                return this.createErrorResponse('cleo_query', 'research', operation, 'E_INVALID_OPERATION', `Unknown native query operation: ${operation}`, startTime);
+        }
+    }
+    /**
+     * Native mutate dispatch
+     */
+    mutateNative(operation, params, startTime) {
+        switch (operation) {
+            case 'link':
+                return this.wrapNativeResult(nativeResearchLink(params?.taskId, params?.researchId, params?.notes, this.projectRoot), 'cleo_mutate', operation, startTime);
+            case 'manifest.append':
+                return this.wrapNativeResult(nativeResearchManifestAppend(params?.entry, this.projectRoot), 'cleo_mutate', operation, startTime);
+            case 'manifest.archive':
+                return this.wrapNativeResult(nativeResearchManifestArchive(params?.beforeDate, this.projectRoot), 'cleo_mutate', operation, startTime);
+            case 'inject':
+                return this.wrapNativeResult(nativeResearchInject(params?.protocolType, params, this.projectRoot), 'cleo_mutate', operation, startTime);
+            case 'compact':
+                return this.wrapNativeResult(nativeResearchCompact(this.projectRoot), 'cleo_mutate', operation, startTime);
+            case 'validate':
+                return this.wrapNativeResult(nativeResearchValidate(params?.taskId, this.projectRoot), 'cleo_mutate', operation, startTime);
+            default:
+                return this.createErrorResponse('cleo_mutate', 'research', operation, 'E_INVALID_OPERATION', `Unknown native mutate operation: ${operation}`, startTime);
+        }
+    }
+    /**
+     * Mutate operations (write)
+     */
+    async mutate(operation, params) {
+        const startTime = Date.now();
+        // Native engine routing for supported operations
+        if (this.useNative(operation, 'mutate')) {
+            try {
+                return this.mutateNative(operation, params, startTime);
+            }
+            catch (error) {
+                return this.handleError('cleo_mutate', 'research', operation, error, startTime);
+            }
+        }
+        // CLI-only operations: check CLI availability
+        if (!this.executor.isAvailable()) {
+            return this.createErrorResponse('cleo_mutate', 'research', operation, 'E_CLI_REQUIRED', `Operation 'research.${operation}' requires the CLEO CLI (bash). Install with: ./install.sh`, startTime);
+        }
+        try {
+            switch (operation) {
+                case 'link':
+                    return await this.mutateLink(params);
+                case 'unlink':
+                    return await this.mutateUnlink(params);
+                case 'import':
+                    return await this.mutateImport(params);
+                case 'aggregate':
+                    return await this.mutateAggregate(params);
+                case 'report':
+                    return await this.mutateReport(params);
+                case 'inject':
+                    return await this.mutateInject(params);
+                case 'manifest.append':
+                    return await this.mutateManifestAppend(params);
+                case 'manifest.archive':
+                    return await this.mutateManifestArchive(params);
+                case 'compact':
+                    return this.mutateNative('compact', params, startTime);
+                case 'validate':
+                    return this.mutateNative('validate', params, startTime);
+                default:
+                    return this.createErrorResponse('cleo_mutate', 'research', operation, 'E_INVALID_OPERATION', `Unknown mutate operation: ${operation}`, startTime);
+            }
+        }
+        catch (error) {
+            return this.handleError('cleo_mutate', 'research', operation, error, startTime);
+        }
+    }
+    /**
+     * Get supported operations
+     */
+    getSupportedOperations() {
+        return {
+            query: ['list', 'stats', 'validate', 'find', 'export', 'manifest.read', 'manifest.validate', 'manifest.summary', 'show', 'pending', 'contradictions', 'superseded'],
+            mutate: ['link', 'unlink', 'import', 'aggregate', 'report', 'inject', 'manifest.append', 'manifest.archive', 'compact', 'validate'],
+        };
+    }
+    // ===== Query Operations =====
+    /**
+     * list - List research entries
+     * Uses ManifestReader directly for reliable parsing (CLI has jq issues with malformed lines)
+     */
+    async queryList(params) {
+        const startTime = Date.now();
+        try {
+            const entries = await this.manifestReader.readManifest();
+            // Build filter from params
+            const filter = {};
+            if (params?.taskId)
+                filter.taskId = params.taskId;
+            if (params?.status)
+                filter.status = params.status;
+            if (params?.type)
+                filter.agent_type = params.type;
+            if (params?.topic)
+                filter.topic = params.topic;
+            if (params?.limit)
+                filter.limit = params.limit;
+            if (params?.actionable !== undefined)
+                filter.actionable = params.actionable;
+            const filtered = this.manifestReader.filterEntries(entries, filter);
+            return {
+                _meta: createGatewayMeta('cleo_query', 'research', 'list', startTime),
+                success: true,
+                data: {
+                    entries: filtered,
+                    total: filtered.length,
+                },
+            };
+        }
+        catch (error) {
+            return this.createErrorResponse('cleo_query', 'research', 'list', 'E_MANIFEST_READ_FAILED', error instanceof Error ? error.message : String(error), startTime);
+        }
+    }
+    /**
+     * stats - Research statistics
+     * Uses ManifestReader directly for reliable parsing (CLI has jq issues with malformed lines)
+     */
+    async queryStats(params) {
+        const startTime = Date.now();
+        try {
+            const entries = await this.manifestReader.readManifest();
+            // If epicId filter is provided, filter entries first
+            let filteredEntries = entries;
+            if (params?.epicId) {
+                filteredEntries = entries.filter((e) => e.id.startsWith(params.epicId) ||
+                    e.linked_tasks?.includes(params.epicId));
+            }
+            // Compute stats from entries
+            const byStatus = {};
+            const byType = {};
+            let actionable = 0;
+            let needsFollowup = 0;
+            let totalFindings = 0;
+            for (const entry of filteredEntries) {
+                byStatus[entry.status] = (byStatus[entry.status] || 0) + 1;
+                byType[entry.agent_type] = (byType[entry.agent_type] || 0) + 1;
+                if (entry.actionable)
+                    actionable++;
+                if (entry.needs_followup && entry.needs_followup.length > 0)
+                    needsFollowup++;
+                if (entry.key_findings)
+                    totalFindings += entry.key_findings.length;
+            }
+            const stats = {
+                total: filteredEntries.length,
+                byStatus,
+                byType,
+                actionable,
+                needsFollowup,
+                averageFindings: filteredEntries.length > 0
+                    ? Math.round((totalFindings / filteredEntries.length) * 10) / 10
+                    : 0,
+            };
+            return {
+                _meta: createGatewayMeta('cleo_query', 'research', 'stats', startTime),
+                success: true,
+                data: stats,
+            };
+        }
+        catch (error) {
+            return this.createErrorResponse('cleo_query', 'research', 'stats', 'E_MANIFEST_READ_FAILED', error instanceof Error ? error.message : String(error), startTime);
+        }
+    }
+    /**
+     * validate - Validate research links
+     * CLI: cleo research validate <taskId>
+     */
+    async queryValidate(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_query', 'research', 'validate', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const result = await this.executor.execute({
+            domain: 'research',
+            operation: 'validate',
+            args: [params.taskId],
+            flags: { json: true },
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'research', 'validate', startTime);
+    }
+    /**
+     * search - Search research entries
+     * CLI: cleo research show <query> [--confidence <n>] [--limit <n>]
+     */
+    async querySearch(params) {
+        const startTime = Date.now();
+        if (!params?.query) {
+            return this.createErrorResponse('cleo_query', 'research', 'find', 'E_INVALID_INPUT', 'query is required', startTime);
+        }
+        const flags = { json: true };
+        if (params?.confidence !== undefined)
+            flags.confidence = params.confidence;
+        if (params?.limit)
+            flags.limit = params.limit;
+        const result = await this.executor.execute({
+            domain: 'research',
+            operation: 'show',
+            args: [params.query],
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'research', 'find', startTime);
+    }
+    /**
+     * export - Export research data
+     * CLI: cleo research export [--format <fmt>] [--status <status>] [--type <type>]
+     */
+    async queryExport(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        if (params?.format)
+            flags.format = params.format;
+        if (params?.filter?.status)
+            flags.status = params.filter.status;
+        if (params?.filter?.type)
+            flags.type = params.filter.type;
+        const result = await this.executor.execute({
+            domain: 'research',
+            operation: 'export',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'research', 'export', startTime);
+    }
+    /**
+     * manifest.read - Read manifest entries
+     * Direct: ManifestReader (not CLI)
+     */
+    async queryManifestRead(params) {
+        const startTime = Date.now();
+        try {
+            const entries = await this.manifestReader.readManifest();
+            const filtered = params
+                ? this.manifestReader.filterEntries(entries, params)
+                : entries;
+            return {
+                _meta: createGatewayMeta('cleo_query', 'research', 'manifest.read', startTime),
+                success: true,
+                data: {
+                    entries: filtered,
+                    total: filtered.length,
+                    filter: params || {},
+                },
+            };
+        }
+        catch (error) {
+            return this.createErrorResponse('cleo_query', 'research', 'manifest.read', 'E_MANIFEST_READ_FAILED', error instanceof Error ? error.message : String(error), startTime);
+        }
+    }
+    /**
+     * manifest.validate - Validate manifest integrity
+     * Direct: ManifestReader (not CLI)
+     */
+    async queryManifestValidate() {
+        const startTime = Date.now();
+        try {
+            const validation = await this.manifestReader.validateManifest();
+            return {
+                _meta: createGatewayMeta('cleo_query', 'research', 'manifest.validate', startTime),
+                success: true,
+                data: validation,
+            };
+        }
+        catch (error) {
+            return this.createErrorResponse('cleo_query', 'research', 'manifest.validate', 'E_MANIFEST_VALIDATION_FAILED', error instanceof Error ? error.message : String(error), startTime);
+        }
+    }
+    /**
+     * manifest.summary - Get manifest statistics
+     * Direct: ManifestReader (not CLI)
+     */
+    async queryManifestSummary() {
+        const startTime = Date.now();
+        try {
+            const summary = await this.manifestReader.getSummary();
+            return {
+                _meta: createGatewayMeta('cleo_query', 'research', 'manifest.summary', startTime),
+                success: true,
+                data: summary,
+            };
+        }
+        catch (error) {
+            return this.createErrorResponse('cleo_query', 'research', 'manifest.summary', 'E_MANIFEST_SUMMARY_FAILED', error instanceof Error ? error.message : String(error), startTime);
+        }
+    }
+    // ===== Mutate Operations =====
+    /**
+     * link - Link research to task
+     * CLI: cleo research link <taskId> <researchId> [--notes <text>]
+     */
+    async mutateLink(params) {
+        const startTime = Date.now();
+        if (!params?.taskId || !params?.researchId) {
+            return this.createErrorResponse('cleo_mutate', 'research', 'link', 'E_INVALID_INPUT', 'taskId and researchId are required', startTime);
+        }
+        const flags = { json: true };
+        if (params?.notes)
+            flags.notes = params.notes;
+        const result = await this.executor.execute({
+            domain: 'research',
+            operation: 'link',
+            args: [params.taskId, params.researchId],
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'research', 'link', startTime);
+    }
+    /**
+     * unlink - Unlink research from task
+     * CLI: cleo research unlink <taskId> <researchId>
+     */
+    async mutateUnlink(params) {
+        const startTime = Date.now();
+        if (!params?.taskId || !params?.researchId) {
+            return this.createErrorResponse('cleo_mutate', 'research', 'unlink', 'E_INVALID_INPUT', 'taskId and researchId are required', startTime);
+        }
+        const result = await this.executor.execute({
+            domain: 'research',
+            operation: 'unlink',
+            args: [params.taskId, params.researchId],
+            flags: { json: true },
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'research', 'unlink', startTime);
+    }
+    /**
+     * import - Import research data
+     * CLI: cleo research import <source> [--overwrite]
+     */
+    async mutateImport(params) {
+        const startTime = Date.now();
+        if (!params?.source) {
+            return this.createErrorResponse('cleo_mutate', 'research', 'import', 'E_INVALID_INPUT', 'source is required', startTime);
+        }
+        const flags = { json: true };
+        if (params?.overwrite)
+            flags.overwrite = true;
+        const result = await this.executor.execute({
+            domain: 'research',
+            operation: 'import',
+            args: [params.source],
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'research', 'import', startTime);
+    }
+    /**
+     * aggregate - Aggregate research findings
+     * CLI: cleo research aggregate <id1> <id2> ... [--output <file>]
+     */
+    async mutateAggregate(params) {
+        const startTime = Date.now();
+        if (!params?.taskIds || params.taskIds.length === 0) {
+            return this.createErrorResponse('cleo_mutate', 'research', 'aggregate', 'E_INVALID_INPUT', 'taskIds array is required', startTime);
+        }
+        const flags = { json: true };
+        if (params?.outputFile)
+            flags.output = params.outputFile;
+        const result = await this.executor.execute({
+            domain: 'research',
+            operation: 'aggregate',
+            args: params.taskIds,
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'research', 'aggregate', startTime);
+    }
+    /**
+     * report - Generate research report
+     * CLI: cleo research report [--epic <id>] [--format <fmt>] [--include-links]
+     */
+    async mutateReport(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        if (params?.epicId)
+            flags.epic = params.epicId;
+        if (params?.format)
+            flags.format = params.format;
+        if (params?.includeLinks)
+            flags['include-links'] = true;
+        const result = await this.executor.execute({
+            domain: 'research',
+            operation: 'report',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'research', 'report', startTime);
+    }
+    /**
+     * show - Get research entry details
+     * CLI: cleo research show <researchId>
+     */
+    async queryShow(params) {
+        const startTime = Date.now();
+        if (!params?.researchId) {
+            return this.createErrorResponse('cleo_query', 'research', 'show', 'E_INVALID_INPUT', 'researchId is required', startTime);
+        }
+        const result = await this.executor.execute({
+            domain: 'research',
+            operation: 'show',
+            args: [params.researchId],
+            flags: { json: true },
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'research', 'show', startTime);
+    }
+    /**
+     * pending - Get pending research items
+     * CLI: cleo research pending [--epicId <id>]
+     */
+    async queryPending(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        if (params?.epicId)
+            flags.epic = params.epicId;
+        const result = await this.executor.execute({
+            domain: 'research',
+            operation: 'pending',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'research', 'pending', startTime);
+    }
+    /**
+     * inject - Get protocol injection content
+     * CLI: cleo research inject <protocolType> [--taskId <id>] [--variant <variant>]
+     */
+    async mutateInject(params) {
+        const startTime = Date.now();
+        if (!params?.protocolType) {
+            return this.createErrorResponse('cleo_mutate', 'research', 'inject', 'E_INVALID_INPUT', 'protocolType is required', startTime);
+        }
+        const flags = { json: true };
+        if (params?.taskId)
+            flags.task = params.taskId;
+        if (params?.variant)
+            flags.variant = params.variant;
+        const result = await this.executor.execute({
+            domain: 'research',
+            operation: 'inject',
+            args: [params.protocolType],
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'research', 'inject', startTime);
+    }
+    /**
+     * manifest.append - Append entry to MANIFEST.jsonl
+     * Direct: Validates and appends to manifest file
+     */
+    async mutateManifestAppend(params) {
+        const startTime = Date.now();
+        if (!params?.entry) {
+            return this.createErrorResponse('cleo_mutate', 'research', 'manifest.append', 'E_INVALID_INPUT', 'entry is required', startTime);
+        }
+        try {
+            // Validate the entry
+            const validation = validateEntry(params.entry);
+            if (!validation.valid) {
+                const errorMessages = validation.errors
+                    .filter((e) => e.severity === 'error')
+                    .map((e) => `${e.field}: ${e.message}`)
+                    .join(', ');
+                return this.createErrorResponse('cleo_mutate', 'research', 'manifest.append', 'E_VALIDATION_FAILED', `Invalid manifest entry: ${errorMessages}`, startTime);
+            }
+            // Serialize and append
+            const serialized = serializeEntry(params.entry);
+            const manifestPath = getCentralManifestPath();
+            await appendFile(manifestPath, serialized + '\n', 'utf-8');
+            return {
+                _meta: createGatewayMeta('cleo_mutate', 'research', 'manifest.append', startTime),
+                success: true,
+                data: {
+                    appended: true,
+                    entryId: params.entry.id,
+                    file: manifestPath,
+                },
+            };
+        }
+        catch (error) {
+            return this.createErrorResponse('cleo_mutate', 'research', 'manifest.append', 'E_MANIFEST_APPEND_FAILED', error instanceof Error ? error.message : String(error), startTime);
+        }
+    }
+    /**
+     * manifest.archive - Archive old manifest entries
+     * Direct: Reads manifest, filters by date, writes archived entries
+     */
+    async mutateManifestArchive(params) {
+        const startTime = Date.now();
+        if (!params?.beforeDate) {
+            return this.createErrorResponse('cleo_mutate', 'research', 'manifest.archive', 'E_INVALID_INPUT', 'beforeDate is required (ISO-8601 format: YYYY-MM-DD)', startTime);
+        }
+        try {
+            const entries = await this.manifestReader.readManifest();
+            const toArchive = entries.filter((e) => e.date < params.beforeDate);
+            const toKeep = entries.filter((e) => e.date >= params.beforeDate);
+            if (toArchive.length === 0) {
+                return {
+                    _meta: createGatewayMeta('cleo_mutate', 'research', 'manifest.archive', startTime),
+                    success: true,
+                    data: {
+                        archived: 0,
+                        remaining: entries.length,
+                        message: 'No entries found before the specified date',
+                    },
+                };
+            }
+            // Write archived entries to archive file
+            const archivePath = getManifestArchivePath();
+            const archiveContent = toArchive.map((e) => JSON.stringify(e)).join('\n') + '\n';
+            await appendFile(archivePath, archiveContent, 'utf-8');
+            // Rewrite main manifest with remaining entries
+            const manifestPath = getCentralManifestPath();
+            const remainingContent = toKeep.length > 0
+                ? toKeep.map((e) => JSON.stringify(e)).join('\n') + '\n'
+                : '';
+            await writeFile(manifestPath, remainingContent, 'utf-8');
+            return {
+                _meta: createGatewayMeta('cleo_mutate', 'research', 'manifest.archive', startTime),
+                success: true,
+                data: {
+                    archived: toArchive.length,
+                    remaining: toKeep.length,
+                    archiveFile: archivePath,
+                },
+            };
+        }
+        catch (error) {
+            return this.createErrorResponse('cleo_mutate', 'research', 'manifest.archive', 'E_MANIFEST_ARCHIVE_FAILED', error instanceof Error ? error.message : String(error), startTime);
+        }
+    }
+    // ===== Helper Methods =====
+    /**
+     * Wrap executor result in DomainResponse format
+     */
+    wrapExecutorResult(result, gateway, domain, operation, startTime) {
+        if (result.success) {
+            return {
+                _meta: createGatewayMeta(gateway, domain, operation, startTime),
+                success: true,
+                data: result.data,
+            };
+        }
+        return {
+            _meta: createGatewayMeta(gateway, domain, operation, startTime),
+            success: false,
+            error: result.error,
+        };
+    }
+    /**
+     * Create error response
+     */
+    createErrorResponse(gateway, domain, operation, code, message, startTime) {
+        return {
+            _meta: createGatewayMeta(gateway, domain, operation, startTime),
+            success: false,
+            error: {
+                code,
+                message,
+            },
+        };
+    }
+    /**
+     * Handle unexpected errors
+     */
+    handleError(gateway, domain, operation, error, startTime) {
+        return this.createErrorResponse(gateway, domain, operation, 'E_INTERNAL_ERROR', error instanceof Error ? error.message : String(error), startTime);
+    }
+}
+//# sourceMappingURL=research.js.map