@ouro.bot/cli 0.1.0-alpha.14 → 0.1.0-alpha.141

package/dist/heart/cross-chat-delivery.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deliverCrossChatMessage = deliverCrossChatMessage;
+const types_1 = require("../mind/friends/types");
+const runtime_1 = require("../nerves/runtime");
+function buildPendingEnvelope(request, agentName, now) {
+    return {
+        from: agentName,
+        friendId: request.friendId,
+        channel: request.channel,
+        key: request.key,
+        content: request.content,
+        timestamp: now,
+    };
+}
+function queueForLater(request, deps, detail) {
+    deps.queuePending(buildPendingEnvelope(request, deps.agentName, (deps.now ?? Date.now)()));
+    return {
+        status: "queued_for_later",
+        detail,
+    };
+}
+function isExplicitlyAuthorized(request) {
+    return request.intent === "explicit_cross_chat"
+        && Boolean(request.authorizingSession)
+        && (0, types_1.isTrustedLevel)(request.authorizingSession?.trustLevel);
+}
+async function deliverCrossChatMessage(request, deps) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.cross_chat_delivery_start",
+        message: "resolving cross-chat delivery",
+        meta: {
+            friendId: request.friendId,
+            channel: request.channel,
+            key: request.key,
+            intent: request.intent,
+            authorizingTrustLevel: request.authorizingSession?.trustLevel ?? null,
+        },
+    });
+    if (request.intent === "generic_outreach") {
+        const result = queueForLater(request, deps, "generic outreach stays queued until the target session is next active");
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.cross_chat_delivery_end",
+            message: "queued generic outreach for later delivery",
+            meta: {
+                friendId: request.friendId,
+                channel: request.channel,
+                key: request.key,
+                status: result.status,
+            },
+        });
+        return result;
+    }
+    if (!isExplicitlyAuthorized(request)) {
+        const result = {
+            status: "blocked",
+            detail: "explicit cross-chat delivery requires a trusted asking session",
+        };
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "engine",
+            event: "engine.cross_chat_delivery_end",
+            message: "blocked explicit cross-chat delivery",
+            meta: {
+                friendId: request.friendId,
+                channel: request.channel,
+                key: request.key,
+                status: result.status,
+            },
+        });
+        return result;
+    }
+    const deliverer = deps.deliverers?.[request.channel];
+    if (!deliverer) {
+        const result = queueForLater(request, deps, "live delivery unavailable right now; queued for the next active turn");
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.cross_chat_delivery_end",
+            message: "queued explicit cross-chat delivery because no live deliverer was available",
+            meta: {
+                friendId: request.friendId,
+                channel: request.channel,
+                key: request.key,
+                status: result.status,
+            },
+        });
+        return result;
+    }
+    try {
+        const direct = await deliverer(request);
+        if (direct.status === "delivered_now" || direct.status === "blocked" || direct.status === "failed") {
+            const result = {
+                status: direct.status,
+                detail: direct.detail,
+            };
+            (0, runtime_1.emitNervesEvent)({
+                level: result.status === "failed" ? "error" : result.status === "blocked" ? "warn" : "info",
+                component: "engine",
+                event: "engine.cross_chat_delivery_end",
+                message: "completed direct cross-chat delivery resolution",
+                meta: {
+                    friendId: request.friendId,
+                    channel: request.channel,
+                    key: request.key,
+                    status: result.status,
+                },
+            });
+            return result;
+        }
+        const result = queueForLater(request, deps, direct.detail.trim() || "live delivery unavailable right now; queued for the next active turn");
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.cross_chat_delivery_end",
+            message: "queued explicit cross-chat delivery after adapter reported unavailability",
+            meta: {
+                friendId: request.friendId,
+                channel: request.channel,
+                key: request.key,
+                status: result.status,
+            },
+        });
+        return result;
+    }
+    catch (error) {
+        const result = {
+            status: "failed",
+            detail: error instanceof Error ? error.message : String(error),
+        };
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "engine",
+            event: "engine.cross_chat_delivery_end",
+            message: "cross-chat delivery threw unexpectedly",
+            meta: {
+                friendId: request.friendId,
+                channel: request.channel,
+                key: request.key,
+                status: result.status,
+                reason: result.detail,
+            },
+        });
+        return result;
+    }
+}

package/dist/heart/daemon/agent-discovery.js

@@ -0,0 +1,81 @@
+"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.listEnabledBundleAgents = listEnabledBundleAgents;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+function listEnabledBundleAgents(options = {}) {
+    const bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+    const readdirSync = options.readdirSync ?? fs.readdirSync;
+    const readFileSync = options.readFileSync ?? fs.readFileSync;
+    let entries;
+    try {
+        entries = readdirSync(bundlesRoot, { withFileTypes: true });
+    }
+    catch {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.agent_discovery_failed",
+            message: "failed to read bundle root for daemon agent discovery",
+            meta: { bundlesRoot },
+        });
+        return [];
+    }
+    const discovered = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !entry.name.endsWith(".ouro"))
+            continue;
+        const agentName = entry.name.slice(0, -5);
+        const configPath = path.join(bundlesRoot, entry.name, "agent.json");
+        let enabled = true;
+        try {
+            const raw = readFileSync(configPath, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.enabled === "boolean") {
+                enabled = parsed.enabled;
+            }
+        }
+        catch {
+            continue;
+        }
+        if (enabled) {
+            discovered.push(agentName);
+        }
+    }
+    return discovered.sort((left, right) => left.localeCompare(right));
+}

package/dist/heart/daemon/agent-service.js

@@ -0,0 +1,467 @@
+"use strict";
+/**
+ * Agent service layer — handles MCP-facing daemon commands.
+ * Each handler receives { agent, friendId, ...params } and returns DaemonResponse.
+ * For MVP, these read from agent state on the filesystem.
+ * Full inference support can come later.
+ */
+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.handleAgentStatus = handleAgentStatus;
+exports.handleAgentAsk = handleAgentAsk;
+exports.handleAgentCatchup = handleAgentCatchup;
+exports.handleAgentDelegate = handleAgentDelegate;
+exports.handleAgentGetContext = handleAgentGetContext;
+exports.handleAgentSearchMemory = handleAgentSearchMemory;
+exports.handleAgentGetTask = handleAgentGetTask;
+exports.handleAgentCheckScope = handleAgentCheckScope;
+exports.handleAgentRequestDecision = handleAgentRequestDecision;
+exports.handleAgentCheckGuidance = handleAgentCheckGuidance;
+exports.handleAgentReportProgress = handleAgentReportProgress;
+exports.handleAgentReportBlocker = handleAgentReportBlocker;
+exports.handleAgentReportComplete = handleAgentReportComplete;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+function readAgentFile(agent, ...segments) {
+    const filePath = path.join((0, identity_1.getAgentRoot)(agent), ...segments);
+    if (!fs.existsSync(filePath))
+        return null;
+    return fs.readFileSync(filePath, "utf-8");
+}
+/** Read agent memory from multiple possible locations. */
+function readAgentMemory(agent) {
+    // Try memory/MEMORY.md first, then psyche/memory/facts.jsonl
+    return readAgentFile(agent, "memory", "MEMORY.md")
+        ?? readAgentFile(agent, "psyche", "memory", "facts.jsonl");
+}
+function listStateFiles(agent, ...segments) {
+    const dirPath = path.join((0, identity_1.getAgentStateRoot)(agent), ...segments);
+    if (!fs.existsSync(dirPath))
+        return [];
+    return fs.readdirSync(dirPath).filter((f) => f.endsWith(".json") || f.endsWith(".jsonl") || f.endsWith(".md"));
+}
+async function handleAgentStatus(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.status",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const sessionFiles = listStateFiles(params.agent, "sessions");
+    const memoryContent = readAgentMemory(params.agent);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.status",
+        meta: { agent: params.agent },
+    });
+    return {
+        ok: true,
+        message: `Agent ${params.agent} status`,
+        data: {
+            agent: params.agent,
+            status: "active",
+            sessionCount: sessionFiles.length,
+            hasMemory: memoryContent !== null,
+        },
+    };
+}
+async function handleAgentAsk(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.ask",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const question = params.question;
+    if (!question) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.agent_service_error",
+            message: "agent.ask missing question parameter",
+            meta: { agent: params.agent },
+        });
+        return { ok: false, error: "Missing required parameter: question" };
+    }
+    // MVP: return memory + recent session context without running inference
+    const memoryContent = readAgentMemory(params.agent);
+    const context = memoryContent
+        ? `Based on agent memory:\n${memoryContent.slice(0, 2000)}`
+        : `Agent ${params.agent} has no memory file. Question was: ${question}`;
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.ask",
+        meta: { agent: params.agent },
+    });
+    return { ok: true, message: context };
+}
+async function handleAgentCatchup(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.catchup",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const sessionFiles = listStateFiles(params.agent, "sessions");
+    const recentSessions = sessionFiles.slice(-5);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.catchup",
+        meta: { agent: params.agent },
+    });
+    return {
+        ok: true,
+        message: recentSessions.length > 0
+            ? `Recent activity: ${recentSessions.length} recent sessions found`
+            : `No recent activity for ${params.agent}`,
+        data: { recentSessions },
+    };
+}
+async function handleAgentDelegate(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.delegate",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const task = params.task;
+    if (!task) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.agent_service_error",
+            message: "agent.delegate missing task parameter",
+            meta: { agent: params.agent },
+        });
+        return { ok: false, error: "Missing required parameter: task" };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.delegate",
+        meta: { agent: params.agent },
+    });
+    return {
+        ok: true,
+        message: `Task queued for delegate to ${params.agent}: ${task}`,
+        data: { task, context: params.context ?? null, queuedAt: new Date().toISOString() },
+    };
+}
+async function handleAgentGetContext(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.getContext",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const memoryContent = readAgentMemory(params.agent);
+    const taskFiles = listStateFiles(params.agent, "tasks");
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.getContext",
+        meta: { agent: params.agent },
+    });
+    return {
+        ok: true,
+        data: {
+            agent: params.agent,
+            hasMemory: memoryContent !== null,
+            memorySummary: memoryContent ? memoryContent.slice(0, 500) : null,
+            taskCount: taskFiles.length,
+        },
+    };
+}
+async function handleAgentSearchMemory(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.searchMemory",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const query = params.query;
+    if (!query) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.agent_service_error",
+            message: "agent.searchMemory missing query parameter",
+            meta: { agent: params.agent },
+        });
+        return { ok: false, error: "Missing required parameter: query" };
+    }
+    // MVP: simple substring search in memory file
+    const memoryContent = readAgentMemory(params.agent);
+    const matches = [];
+    if (memoryContent) {
+        const lines = memoryContent.split("\n");
+        const queryLower = query.toLowerCase();
+        for (const line of lines) {
+            if (line.toLowerCase().includes(queryLower)) {
+                matches.push(line.trim());
+            }
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.searchMemory",
+        meta: { agent: params.agent, matchCount: matches.length },
+    });
+    return {
+        ok: true,
+        message: matches.length > 0 ? `Found ${matches.length} matches` : "No matches found",
+        data: { query, matches: matches.slice(0, 20) },
+    };
+}
+async function handleAgentGetTask(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.getTask",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const taskFiles = listStateFiles(params.agent, "tasks");
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.getTask",
+        meta: { agent: params.agent },
+    });
+    return {
+        ok: true,
+        message: taskFiles.length > 0
+            ? `Current tasks: ${taskFiles.join(", ")}`
+            : `No active tasks for ${params.agent}`,
+        data: { tasks: taskFiles },
+    };
+}
+async function handleAgentCheckScope(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.checkScope",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const item = params.item;
+    if (!item) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.agent_service_error",
+            message: "agent.checkScope missing item parameter",
+            meta: { agent: params.agent },
+        });
+        return { ok: false, error: "Missing required parameter: item" };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.checkScope",
+        meta: { agent: params.agent },
+    });
+    return {
+        ok: true,
+        message: `Scope check for: ${item}`,
+        data: { item, inScope: true, reason: "MVP: scope check requires inference — defaulting to in-scope" },
+    };
+}
+async function handleAgentRequestDecision(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.requestDecision",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const topic = params.topic;
+    if (!topic) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.agent_service_error",
+            message: "agent.requestDecision missing topic parameter",
+            meta: { agent: params.agent },
+        });
+        return { ok: false, error: "Missing required parameter: topic" };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.requestDecision",
+        meta: { agent: params.agent },
+    });
+    return {
+        ok: true,
+        message: `Decision request queued: ${topic}`,
+        data: {
+            topic,
+            options: params.options ?? null,
+            status: "pending",
+            note: "MVP: decision requires inference — queued for agent review",
+        },
+    };
+}
+async function handleAgentCheckGuidance(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.checkGuidance",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const topic = params.topic;
+    if (!topic) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.agent_service_error",
+            message: "agent.checkGuidance missing topic parameter",
+            meta: { agent: params.agent },
+        });
+        return { ok: false, error: "Missing required parameter: topic" };
+    }
+    // MVP: check memory for relevant guidance
+    const memoryContent = readAgentMemory(params.agent);
+    let guidance = `No specific guidance found for: ${topic}`;
+    if (memoryContent) {
+        const lines = memoryContent.split("\n");
+        const topicLower = topic.toLowerCase();
+        const relevant = lines.filter((line) => line.toLowerCase().includes(topicLower));
+        if (relevant.length > 0) {
+            guidance = `Relevant guidance:\n${relevant.slice(0, 10).join("\n")}`;
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.checkGuidance",
+        meta: { agent: params.agent },
+    });
+    return { ok: true, message: guidance };
+}
+async function handleAgentReportProgress(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.reportProgress",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const summary = params.summary;
+    if (!summary) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.agent_service_error",
+            message: "agent.reportProgress missing summary parameter",
+            meta: { agent: params.agent },
+        });
+        return { ok: false, error: "Missing required parameter: summary" };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.reportProgress",
+        meta: { agent: params.agent },
+    });
+    return {
+        ok: true,
+        message: `Progress noted: ${summary}`,
+        data: { summary, receivedAt: new Date().toISOString() },
+    };
+}
+async function handleAgentReportBlocker(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.reportBlocker",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const blocker = params.blocker;
+    if (!blocker) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.agent_service_error",
+            message: "agent.reportBlocker missing blocker parameter",
+            meta: { agent: params.agent },
+        });
+        return { ok: false, error: "Missing required parameter: blocker" };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.reportBlocker",
+        meta: { agent: params.agent },
+    });
+    return {
+        ok: true,
+        message: `Blocker reported: ${blocker}`,
+        data: { blocker, receivedAt: new Date().toISOString() },
+    };
+}
+async function handleAgentReportComplete(params) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_start",
+        message: "handling agent.reportComplete",
+        meta: { agent: params.agent, friendId: params.friendId },
+    });
+    const summary = params.summary;
+    if (!summary) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.agent_service_error",
+            message: "agent.reportComplete missing summary parameter",
+            meta: { agent: params.agent },
+        });
+        return { ok: false, error: "Missing required parameter: summary" };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_service_end",
+        message: "completed agent.reportComplete",
+        meta: { agent: params.agent },
+    });
+    return {
+        ok: true,
+        message: `Completion reported: ${summary}`,
+        data: { summary, receivedAt: new Date().toISOString() },
+    };
+}