@jungjaehoon/mama-os 0.28.6 → 0.29.1

package/dist/agent/delegation-executor.js

@@ -1,692 +0,0 @@
-"use strict";
-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.DelegationExecutor = void 0;
-const fs_1 = require("fs");
-const os_1 = require("os");
-const path_1 = require("path");
-const debugLogger = __importStar(require("@jungjaehoon/mama-core/debug-logger"));
-const agent_store_js_1 = require("../db/agent-store.js");
-const { DebugLogger } = debugLogger;
-const securityLogger = new DebugLogger('SecurityAudit');
-const AGENT_TEST_WORKER_LIMIT = 3;
-const DELEGATE_MAX_RETRIES = 3;
-function summarizeActivityOutput(output) {
-    if (output === undefined || output === null) {
-        return undefined;
-    }
-    if (typeof output === 'string') {
-        return output.slice(0, 500);
-    }
-    try {
-        return JSON.stringify(output).slice(0, 500);
-    }
-    catch {
-        return String(output).slice(0, 500);
-    }
-}
-function resolveSkillPath(skillName) {
-    if (!/^[a-zA-Z0-9_-]+$/.test(skillName)) {
-        return null;
-    }
-    const skillsDir = (0, path_1.join)((0, os_1.homedir)(), '.mama', 'skills');
-    const resolved = (0, path_1.resolve)(skillsDir, `${skillName}.md`);
-    if (!resolved.startsWith(skillsDir)) {
-        return null;
-    }
-    return resolved;
-}
-function requireRoutingField(routing, field) {
-    const value = routing?.[field];
-    if (typeof value !== 'string' || value.trim() === '') {
-        throw new Error(`[delegation] missing routing.${field}`);
-    }
-    return value;
-}
-function requireRouting(routing) {
-    const input = routing;
-    return {
-        agentId: requireRoutingField(input, 'agentId'),
-        source: requireRoutingField(input, 'source'),
-        channelId: requireRoutingField(input, 'channelId'),
-    };
-}
-class DelegationExecutor {
-    deps;
-    testInFlight = new Map();
-    constructor(deps) {
-        this.deps = deps;
-    }
-    async runAgentTest(input, routing) {
-        const permError = this.deps.checkViewerOnly();
-        if (permError) {
-            return { success: false, error: permError };
-        }
-        const { agent_id } = input;
-        const sample_count = Number.parseInt(String(input.sample_count ?? 2), 10);
-        const resolvedAgentId = this.deps.resolveManagedAgentId(agent_id);
-        if (!Number.isFinite(sample_count) || sample_count < 1) {
-            securityLogger.warn('[Agent test] Invalid sample_count received', {
-                agent_id: resolvedAgentId,
-                sample_count: input.sample_count ?? null,
-            });
-            return {
-                success: false,
-                error: `Invalid sample_count for '${resolvedAgentId}': ${String(input.sample_count)}. Must be >= 1.`,
-            };
-        }
-        if (this.testInFlight.has(resolvedAgentId)) {
-            return { success: false, error: 'test_already_running' };
-        }
-        const promise = this.runAgentTestInternal(resolvedAgentId, sample_count, routing, input.test_data);
-        this.testInFlight.set(resolvedAgentId, promise);
-        try {
-            return await promise;
-        }
-        finally {
-            this.testInFlight.delete(resolvedAgentId);
-        }
-    }
-    async runDelegate(input, routing) {
-        return this.runDelegateInternal(input, routing);
-    }
-    cleanupValidationSessionOnTelemetryFailure(session, error, label) {
-        if (!session || !this.deps.validationService) {
-            return null;
-        }
-        const message = error instanceof Error ? error.message : String(error);
-        try {
-            this.deps.validationService.finalizeSession(session.id, {
-                execution_status: 'failed',
-                error_message: `${label}: ${message}`,
-            });
-        }
-        catch (cleanupErr) {
-            securityLogger.warn(`[Delegation telemetry] Failed to clean up validation session ${session.id}`, cleanupErr);
-        }
-        return null;
-    }
-    async runAgentTestInternal(agentId, sampleCount, routing, testData) {
-        const processManager = this.deps.agentProcessManager;
-        const delegationManager = this.deps.delegationManagerRef;
-        if (!processManager || !delegationManager) {
-            return {
-                success: false,
-                error: 'agent_timeout: multi-agent not configured',
-            };
-        }
-        const startTime = Date.now();
-        let items;
-        if (testData && testData.length > 0) {
-            const normalizedItems = [];
-            for (let index = 0; index < testData.length; index++) {
-                const rawItem = testData[index];
-                if (typeof rawItem.input !== 'string') {
-                    return {
-                        success: false,
-                        error: `Invalid test_data[${index}].input: expected string`,
-                    };
-                }
-                if (rawItem.expected !== undefined && typeof rawItem.expected !== 'string') {
-                    return {
-                        success: false,
-                        error: `Invalid test_data[${index}].expected: expected string`,
-                    };
-                }
-                normalizedItems.push({
-                    input: rawItem.input,
-                    ...(typeof rawItem.expected === 'string' ? { expected: rawItem.expected } : {}),
-                });
-            }
-            items = normalizedItems;
-        }
-        else if (this.deps.rawStore) {
-            const agentConfig = delegationManager.getAgentConfig(agentId);
-            const connectors = agentConfig?.connectors ?? [];
-            if (connectors.length === 0) {
-                return {
-                    success: false,
-                    error: 'connector_unavailable: no connectors configured',
-                };
-            }
-            const allItems = [];
-            const missingConnectors = [];
-            for (const conn of connectors) {
-                if (!this.deps.rawStore.hasConnector(conn)) {
-                    missingConnectors.push(conn);
-                    continue;
-                }
-                const recent = this.deps.rawStore.getRecent(conn, sampleCount);
-                for (const item of recent) {
-                    allItems.push({ input: `[${item.type}] ${item.content}` });
-                }
-                if (allItems.length >= sampleCount) {
-                    break;
-                }
-            }
-            if (allItems.length === 0) {
-                const detail = missingConnectors.length > 0
-                    ? `connector(s) not found: ${missingConnectors.join(', ')}`
-                    : 'no recent data';
-                return {
-                    success: false,
-                    error: `connector_unavailable: ${detail}`,
-                };
-            }
-            items = allItems.slice(0, sampleCount);
-        }
-        else {
-            return {
-                success: false,
-                error: 'connector_unavailable: rawStore not available',
-            };
-        }
-        const testVer = this.deps.sessionsDb ? (0, agent_store_js_1.getLatestVersion)(this.deps.sessionsDb, agentId) : null;
-        const testAgentVersion = testVer?.version ?? 0;
-        let testValSession = null;
-        try {
-            testValSession =
-                this.deps.validationService?.startSession(agentId, testAgentVersion, 'agent_test', {
-                    goal: `Test with ${items.length} items`,
-                    customBeforeSnapshot: JSON.stringify({
-                        schema_version: 1,
-                        test_input_summary: items.map((i) => i.input.slice(0, 80)).join('; '),
-                        sample_count: items.length,
-                    }),
-                }) ?? null;
-        }
-        catch (telemetryErr) {
-            securityLogger.warn('[Agent test telemetry] Failed to start validation session', {
-                agentId,
-                testAgentVersion,
-                error: telemetryErr instanceof Error ? telemetryErr.message : String(telemetryErr),
-            });
-        }
-        let testRunId = null;
-        if (this.deps.sessionsDb) {
-            try {
-                const row = (0, agent_store_js_1.logActivity)(this.deps.sessionsDb, {
-                    agent_id: agentId,
-                    agent_version: testAgentVersion,
-                    type: 'test_run',
-                    input_summary: `Testing with ${items.length} items`,
-                    run_id: testValSession?.id,
-                    execution_status: 'started',
-                    trigger_reason: 'agent_test',
-                });
-                testRunId = row.id;
-                if (testValSession && this.deps.validationService) {
-                    this.deps.validationService.recordRun(testValSession.id, { activityId: row.id });
-                }
-            }
-            catch (telemetryErr) {
-                securityLogger.warn('[Agent test telemetry] Failed to persist startup activity', {
-                    agentId,
-                    testValSessionId: testValSession?.id ?? null,
-                    error: telemetryErr instanceof Error ? telemetryErr.message : String(telemetryErr),
-                });
-                testValSession = this.cleanupValidationSessionOnTelemetryFailure(testValSession, telemetryErr, 'agent_test startup telemetry failed');
-                testRunId = null;
-            }
-        }
-        const results = [];
-        const workerCount = Math.min(AGENT_TEST_WORKER_LIMIT, items.length);
-        let nextIndex = 0;
-        const workers = Array.from({ length: workerCount }, async () => {
-            for (;;) {
-                const currentIndex = nextIndex;
-                nextIndex++;
-                if (currentIndex >= items.length) {
-                    return;
-                }
-                const item = items[currentIndex];
-                try {
-                    const r = await this.runDelegateInternal({
-                        agentId,
-                        task: `Process this data:\n${item.input}`,
-                    }, routing);
-                    const rAny = r;
-                    const output = r.success
-                        ? String(rAny.data?.response ?? '')
-                        : undefined;
-                    results[currentIndex] = {
-                        input: item.input,
-                        output,
-                        error: r.success ? undefined : String(rAny.error ?? 'unknown'),
-                    };
-                }
-                catch (err) {
-                    results[currentIndex] = { input: item.input, error: String(err) };
-                }
-            }
-        });
-        await Promise.all(workers);
-        const passed = results.filter((r, index) => {
-            if (r.error) {
-                return false;
-            }
-            const expected = items[index]?.expected;
-            if (expected === undefined) {
-                return true;
-            }
-            return (r.output ?? '').trim() === expected.trim();
-        }).length;
-        const failed = results.length - passed;
-        const autoScore = results.length > 0 ? Math.round((passed / results.length) * 100) : 0;
-        if (this.deps.sessionsDb && testRunId) {
-            try {
-                (0, agent_store_js_1.updateActivityScore)(this.deps.sessionsDb, testRunId, autoScore, {
-                    total: results.length,
-                    passed,
-                    failed,
-                    items: results.map((r, index) => ({
-                        input: r.input.slice(0, 100),
-                        result: r.error ||
-                            (items[index]?.expected !== undefined &&
-                                (r.output ?? '').trim() !== items[index].expected.trim())
-                            ? 'fail'
-                            : 'pass',
-                    })),
-                }, 'completed');
-            }
-            catch (telemetryErr) {
-                securityLogger.warn('[Agent test telemetry] Failed to persist test score', {
-                    agentId,
-                    testRunId,
-                    autoScore,
-                    totalResults: results.length,
-                    error: telemetryErr instanceof Error ? telemetryErr.message : String(telemetryErr),
-                });
-            }
-        }
-        const testDurationMs = Date.now() - startTime;
-        if (testValSession && this.deps.validationService) {
-            try {
-                this.deps.validationService.finalizeSession(testValSession.id, {
-                    execution_status: 'completed',
-                    metrics: {
-                        duration_ms: testDurationMs,
-                        completion_rate: results.length > 0 ? passed / results.length : 0,
-                        auto_score: autoScore,
-                    },
-                    test_input_summary: items.map((i) => i.input.slice(0, 80)).join('; '),
-                });
-            }
-            catch (telemetryErr) {
-                securityLogger.warn('[Agent test telemetry] Failed to finalize validation session', {
-                    agentId,
-                    testValSessionId: testValSession.id,
-                    autoScore,
-                    totalResults: results.length,
-                    error: telemetryErr instanceof Error ? telemetryErr.message : String(telemetryErr),
-                });
-            }
-        }
-        return {
-            success: true,
-            data: {
-                test_run_id: testRunId,
-                agent_id: agentId,
-                results,
-                auto_score: autoScore,
-                duration_ms: testDurationMs,
-                validation_session_id: testValSession?.id ?? null,
-                ...(testRunId === null ? { warning: 'score_not_persisted' } : {}),
-            },
-        };
-    }
-    async runDelegateInternal(input, routing) {
-        const { task, background } = input;
-        const agentId = this.deps.resolveManagedAgentId(input.agentId);
-        const processManager = this.deps.agentProcessManager;
-        const delegationManager = this.deps.delegationManagerRef;
-        if (!processManager || !delegationManager) {
-            return { success: false, error: 'Multi-agent not configured' };
-        }
-        const { agentId: sourceAgentId, source, channelId } = requireRouting(routing);
-        const check = delegationManager.isDelegationAllowed(sourceAgentId, agentId);
-        if (!check.allowed) {
-            return {
-                success: false,
-                error: `Delegation denied: ${check.reason}`,
-            };
-        }
-        if (background) {
-            let bgAgentVersion = 0;
-            let bgValSession = null;
-            try {
-                const bgVer = this.deps.sessionsDb ? (0, agent_store_js_1.getLatestVersion)(this.deps.sessionsDb, agentId) : null;
-                bgAgentVersion = bgVer?.version ?? 0;
-                bgValSession =
-                    this.deps.validationService?.startSession(agentId, bgAgentVersion, 'delegate_run') ??
-                        null;
-                if (this.deps.sessionsDb) {
-                    const row = (0, agent_store_js_1.logActivity)(this.deps.sessionsDb, {
-                        agent_id: agentId,
-                        agent_version: bgAgentVersion,
-                        type: 'task_start',
-                        input_summary: task?.slice(0, 200),
-                        run_id: bgValSession?.id,
-                        execution_status: 'started',
-                        trigger_reason: 'delegate_run',
-                    });
-                    if (bgValSession && this.deps.validationService) {
-                        this.deps.validationService.recordRun(bgValSession.id, { activityId: row.id });
-                    }
-                }
-            }
-            catch (telemetryErr) {
-                securityLogger.warn('[Delegation telemetry] Background bootstrap failed', telemetryErr);
-                bgAgentVersion = 0;
-                bgValSession = this.cleanupValidationSessionOnTelemetryFailure(bgValSession, telemetryErr, 'background delegate bootstrap failed');
-            }
-            const bgStartTime = Date.now();
-            void (async () => {
-                try {
-                    const result = await this.sendDelegationMessageWithRetry({
-                        processManager,
-                        delegationManager,
-                        source,
-                        channelId,
-                        agentId,
-                        sourceAgentId,
-                        task,
-                        skill: input.skill,
-                    });
-                    const durationMs = Date.now() - bgStartTime;
-                    try {
-                        if (this.deps.sessionsDb) {
-                            const row = (0, agent_store_js_1.logActivity)(this.deps.sessionsDb, {
-                                agent_id: agentId,
-                                agent_version: bgAgentVersion,
-                                type: 'task_complete',
-                                input_summary: task?.slice(0, 200),
-                                output_summary: summarizeActivityOutput(result?.response),
-                                duration_ms: durationMs,
-                                run_id: bgValSession?.id,
-                                execution_status: 'completed',
-                                trigger_reason: 'delegate_run',
-                            });
-                            if (bgValSession && this.deps.validationService) {
-                                this.deps.validationService.recordRun(bgValSession.id, {
-                                    activityId: row.id,
-                                    duration_ms: durationMs,
-                                });
-                            }
-                        }
-                    }
-                    catch (telemetryErr) {
-                        securityLogger.warn('[Delegation telemetry] Background completion activity failed', telemetryErr);
-                    }
-                    try {
-                        if (bgValSession && this.deps.validationService) {
-                            this.deps.validationService.finalizeSession(bgValSession.id, {
-                                execution_status: 'completed',
-                                metrics: { duration_ms: durationMs },
-                            });
-                        }
-                    }
-                    catch (telemetryErr) {
-                        securityLogger.warn('[Delegation telemetry] Background completion finalize failed', telemetryErr);
-                    }
-                }
-                catch (err) {
-                    const durationMs = Date.now() - bgStartTime;
-                    try {
-                        if (this.deps.sessionsDb) {
-                            const row = (0, agent_store_js_1.logActivity)(this.deps.sessionsDb, {
-                                agent_id: agentId,
-                                agent_version: bgAgentVersion,
-                                type: 'task_error',
-                                input_summary: task?.slice(0, 200),
-                                error_message: String(err),
-                                duration_ms: durationMs,
-                                run_id: bgValSession?.id,
-                                execution_status: 'failed',
-                                trigger_reason: 'delegate_run',
-                            });
-                            if (bgValSession && this.deps.validationService) {
-                                this.deps.validationService.recordRun(bgValSession.id, {
-                                    activityId: row.id,
-                                    duration_ms: durationMs,
-                                });
-                            }
-                        }
-                    }
-                    catch (telemetryErr) {
-                        securityLogger.warn('[Delegation telemetry] Background failure activity failed', telemetryErr);
-                    }
-                    try {
-                        if (bgValSession && this.deps.validationService) {
-                            this.deps.validationService.finalizeSession(bgValSession.id, {
-                                execution_status: 'failed',
-                                error_message: String(err),
-                                metrics: { duration_ms: durationMs },
-                            });
-                        }
-                    }
-                    catch (telemetryErr) {
-                        securityLogger.warn('[Delegation telemetry] Background failure finalize failed', telemetryErr);
-                    }
-                }
-            })();
-            return {
-                success: true,
-                data: { agentId, background: true, message: 'Background task submitted' },
-            };
-        }
-        const startTime = Date.now();
-        let agentVersion = 0;
-        let valSession = null;
-        try {
-            const ver = this.deps.sessionsDb ? (0, agent_store_js_1.getLatestVersion)(this.deps.sessionsDb, agentId) : null;
-            agentVersion = ver?.version ?? 0;
-            valSession =
-                this.deps.validationService?.startSession(agentId, agentVersion, 'delegate_run') ?? null;
-            if (this.deps.sessionsDb) {
-                const row = (0, agent_store_js_1.logActivity)(this.deps.sessionsDb, {
-                    agent_id: agentId,
-                    agent_version: agentVersion,
-                    type: 'task_start',
-                    input_summary: task?.slice(0, 200),
-                    run_id: valSession?.id,
-                    execution_status: 'started',
-                    trigger_reason: 'delegate_run',
-                });
-                if (valSession && this.deps.validationService) {
-                    this.deps.validationService.recordRun(valSession.id, { activityId: row.id });
-                }
-            }
-        }
-        catch (telemetryErr) {
-            securityLogger.warn('[Delegation telemetry] Validation bootstrap failed', telemetryErr);
-            agentVersion = 0;
-            valSession = this.cleanupValidationSessionOnTelemetryFailure(valSession, telemetryErr, 'delegate bootstrap failed');
-        }
-        try {
-            const result = await this.sendDelegationMessageWithRetry({
-                processManager,
-                delegationManager,
-                source,
-                channelId,
-                agentId,
-                sourceAgentId,
-                task,
-                skill: input.skill,
-            });
-            const durationMs = Date.now() - startTime;
-            try {
-                if (this.deps.sessionsDb) {
-                    const row = (0, agent_store_js_1.logActivity)(this.deps.sessionsDb, {
-                        agent_id: agentId,
-                        agent_version: agentVersion,
-                        type: 'task_complete',
-                        input_summary: task?.slice(0, 200),
-                        output_summary: summarizeActivityOutput(result.response),
-                        duration_ms: durationMs,
-                        run_id: valSession?.id,
-                        execution_status: 'completed',
-                        trigger_reason: 'delegate_run',
-                    });
-                    if (valSession && this.deps.validationService) {
-                        this.deps.validationService.recordRun(valSession.id, {
-                            activityId: row.id,
-                            duration_ms: durationMs,
-                        });
-                    }
-                }
-            }
-            catch (telemetryErr) {
-                securityLogger.warn('[Delegation telemetry] Completion activity failed', telemetryErr);
-            }
-            try {
-                if (valSession && this.deps.validationService) {
-                    this.deps.validationService.finalizeSession(valSession.id, {
-                        execution_status: 'completed',
-                        metrics: { duration_ms: durationMs },
-                    });
-                }
-            }
-            catch (telemetryErr) {
-                securityLogger.warn('[Delegation telemetry] Completion finalize failed', telemetryErr);
-            }
-            return {
-                success: true,
-                data: { agentId, response: result.response, duration_ms: durationMs },
-            };
-        }
-        catch (err) {
-            const lastError = err instanceof Error ? err : new Error(String(err));
-            const failedDurationMs = Date.now() - startTime;
-            try {
-                if (this.deps.sessionsDb) {
-                    const row = (0, agent_store_js_1.logActivity)(this.deps.sessionsDb, {
-                        agent_id: agentId,
-                        agent_version: agentVersion,
-                        type: 'task_error',
-                        input_summary: task?.slice(0, 200),
-                        error_message: lastError.message,
-                        duration_ms: failedDurationMs,
-                        run_id: valSession?.id,
-                        execution_status: 'failed',
-                        trigger_reason: 'delegate_run',
-                    });
-                    if (valSession && this.deps.validationService) {
-                        this.deps.validationService.recordRun(valSession.id, {
-                            activityId: row.id,
-                            duration_ms: failedDurationMs,
-                        });
-                    }
-                }
-            }
-            catch (telemetryErr) {
-                securityLogger.warn('[Delegation telemetry] Failure activity failed', telemetryErr);
-            }
-            try {
-                if (valSession && this.deps.validationService) {
-                    this.deps.validationService.finalizeSession(valSession.id, {
-                        execution_status: 'failed',
-                        error_message: lastError.message,
-                        metrics: { duration_ms: failedDurationMs },
-                    });
-                }
-            }
-            catch (telemetryErr) {
-                securityLogger.warn('[Delegation telemetry] Failure finalize failed', telemetryErr);
-            }
-            return {
-                success: false,
-                error: `Delegation to ${agentId} failed after ${DELEGATE_MAX_RETRIES} attempts: ${lastError.message}`,
-            };
-        }
-    }
-    async sendDelegationMessageWithRetry(args) {
-        let lastError = null;
-        for (let attempt = 0; attempt < DELEGATE_MAX_RETRIES; attempt++) {
-            try {
-                const process = await args.processManager.getProcess(args.source, args.channelId, args.agentId);
-                let delegationPrompt = this.buildDelegationPrompt(args);
-                const sessionId = process.getSessionId?.();
-                if (!sessionId || attempt > 0) {
-                    delegationPrompt = await this.withChannelHistory(delegationPrompt, args.channelId, args.agentId);
-                }
-                return await process.sendMessage(delegationPrompt);
-            }
-            catch (err) {
-                lastError = err instanceof Error ? err : new Error(String(err));
-                const isBusy = lastError.message.includes('busy');
-                const isCrash = lastError.message.includes('exited with code');
-                if (isCrash) {
-                    args.processManager.stopProcess(args.source, args.channelId, args.agentId);
-                }
-                if (attempt < DELEGATE_MAX_RETRIES - 1 && (isBusy || isCrash)) {
-                    await new Promise((resolveDelay) => setTimeout(resolveDelay, this.deps.retryDelayMs * (attempt + 1)));
-                    continue;
-                }
-                break;
-            }
-        }
-        throw lastError ?? new Error('unknown delegation failure');
-    }
-    buildDelegationPrompt(args) {
-        let delegationPrompt = args.delegationManager.buildDelegationPrompt(args.sourceAgentId, args.task);
-        if (args.skill) {
-            const skillPath = resolveSkillPath(args.skill);
-            if (skillPath && (0, fs_1.existsSync)(skillPath)) {
-                const skillContent = (0, fs_1.readFileSync)(skillPath, 'utf-8');
-                delegationPrompt = skillContent + '\n\n---\n\n' + delegationPrompt;
-            }
-        }
-        return delegationPrompt;
-    }
-    async withChannelHistory(prompt, channelId, agentId) {
-        try {
-            const { getChannelHistory } = await import('../gateways/channel-history.js');
-            const channelHistory = getChannelHistory();
-            if (channelHistory) {
-                const historyContext = channelHistory.formatForContext(channelId, '', agentId);
-                if (historyContext) {
-                    return `${historyContext}\n\n${prompt}`;
-                }
-            }
-        }
-        catch {
-            // Channel history injection is best-effort.
-        }
-        return prompt;
-    }
-}
-exports.DelegationExecutor = DelegationExecutor;
-//# sourceMappingURL=delegation-executor.js.map