@ouro.bot/cli 0.1.0-alpha.143 → 0.1.0-alpha.146

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

@@ -2,8 +2,9 @@
 /**
  * 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.
+ *
+ * DRY: uses the same shared functions the agent's own tools use (diary, session-recall).
+ * This file is a thin adapter — no reimplemented search, parsing, or state reading.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -55,413 +56,305 @@ exports.handleAgentReportComplete = handleAgentReportComplete;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const identity_1 = require("../identity");
+const diary_1 = require("../../mind/diary");
 const runtime_1 = require("../../nerves/runtime");
+/** Format diary hits the same way the recall tool does. */
+function formatDiaryHits(hits) {
+    return hits.map((f) => `[diary] ${f.text} (source=${f.source}, createdAt=${f.createdAt})`);
+}
+/** Read a file from the agent root, returning null if it doesn't exist. */
 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");
+/** Resolve the diary root for a specific agent. */
+function agentDiaryRoot(agent) {
+    return (0, diary_1.resolveDiaryRoot)(path.join((0, identity_1.getAgentRoot)(agent), "psyche", "memory"));
+}
+/** Read inner dialog runtime status. */
+function readInnerDialogStatus(agent) {
+    const content = readAgentFile(agent, "state", "sessions", "self", "inner", "runtime.json");
+    if (!content)
+        return null;
+    try {
+        const data = JSON.parse(content);
+        return { status: data.status ?? "unknown", lastCompletedAt: data.lastCompletedAt ?? "" };
+    }
+    catch {
+        return null;
+    }
+}
+function safeReaddir(dirPath) {
+    try {
+        return fs.readdirSync(dirPath).map(String);
+        /* v8 ignore start — catch is defensive; tested paths don't trigger fs errors */
+    }
+    catch {
+        return [];
+    }
+    /* v8 ignore stop */
+}
+function safeIsDir(dirPath) {
+    try {
+        return fs.statSync(dirPath).isDirectory();
+        /* v8 ignore start — catch is defensive; tested paths don't trigger fs errors */
+    }
+    catch {
+        return false;
+    }
+    /* v8 ignore stop */
 }
-function listStateFiles(agent, ...segments) {
-    const dirPath = path.join((0, identity_1.getAgentStateRoot)(agent), ...segments);
-    if (!fs.existsSync(dirPath))
+/** Enumerate sessions from state/sessions/, reading session.json files. */
+function enumerateSessions(agent) {
+    const sessionsDir = path.join((0, identity_1.getAgentRoot)(agent), "state", "sessions");
+    if (!fs.existsSync(sessionsDir))
         return [];
-    return fs.readdirSync(dirPath).filter((f) => f.endsWith(".json") || f.endsWith(".jsonl") || f.endsWith(".md"));
+    const sessions = [];
+    for (const friendId of safeReaddir(sessionsDir)) {
+        const friendPath = path.join(sessionsDir, friendId);
+        if (!safeIsDir(friendPath))
+            continue;
+        for (const channel of safeReaddir(friendPath)) {
+            const channelPath = path.join(friendPath, channel);
+            if (!safeIsDir(channelPath))
+                continue;
+            for (const key of safeReaddir(channelPath)) {
+                const sessionFile = path.join(channelPath, key, "session.json");
+                if (!fs.existsSync(sessionFile))
+                    continue;
+                try {
+                    const data = JSON.parse(fs.readFileSync(sessionFile, "utf-8"));
+                    sessions.push({ friendId, channel, key, lastUsage: data.lastUsage ?? "" });
+                }
+                catch { /* skip malformed */ }
+            }
+        }
+    }
+    return sessions;
 }
+/** List markdown files in {agentRoot}/tasks/. */
+function listTaskFiles(agent) {
+    const tasksDir = path.join((0, identity_1.getAgentRoot)(agent), "tasks");
+    if (!fs.existsSync(tasksDir))
+        return [];
+    try {
+        return fs.readdirSync(tasksDir).map(String).filter((f) => f.endsWith(".md"));
+    }
+    catch {
+        return [];
+    }
+}
+function emit(event, message, meta) {
+    (0, runtime_1.emitNervesEvent)({ component: "daemon", event, message, meta });
+}
+// ─── Handlers ────────────────────────────────────────────────────────────────
 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 },
-    });
+    (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.agent_service_start", message: "handling agent.status", meta: { agent: params.agent } });
+    const diaryRoot = agentDiaryRoot(params.agent);
+    const facts = (0, diary_1.readDiaryEntries)(diaryRoot);
+    const innerStatus = readInnerDialogStatus(params.agent);
+    const sessions = enumerateSessions(params.agent);
+    emit("daemon.agent_service_end", "completed agent.status", { agent: params.agent });
     return {
         ok: true,
         message: `Agent ${params.agent} status`,
         data: {
             agent: params.agent,
-            status: "active",
-            sessionCount: sessionFiles.length,
-            hasMemory: memoryContent !== null,
+            innerStatus: innerStatus?.status ?? "unknown",
+            lastThoughtAt: innerStatus?.lastCompletedAt ?? null,
+            sessionCount: sessions.length,
+            hasMemory: facts.length > 0,
+            factCount: facts.length,
         },
     };
 }
 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 },
-    });
+    emit("daemon.agent_service_start", "handling agent.ask", { agent: params.agent });
     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 },
-        });
+        emit("daemon.agent_service_error", "agent.ask missing question", { 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 },
-    });
+    // Use the same searchDiaryEntries the recall tool uses (substring fallback — no embedding provider in shim)
+    const diaryRoot = agentDiaryRoot(params.agent);
+    const hits = await (0, diary_1.searchDiaryEntries)(question, (0, diary_1.readDiaryEntries)(diaryRoot));
+    const context = hits.length > 0
+        ? hits.slice(0, 10).map((f) => f.text).join("\n")
+        : `No relevant memories found for: ${question}`;
+    emit("daemon.agent_service_end", "completed agent.ask", { 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 },
-    });
+    emit("daemon.agent_service_start", "handling agent.catchup", { agent: params.agent });
+    const sessions = enumerateSessions(params.agent);
+    const sorted = sessions.sort((a, b) => (b.lastUsage || "").localeCompare(a.lastUsage || ""));
+    const recentSessions = sorted.slice(0, 5);
+    const innerStatus = readInnerDialogStatus(params.agent);
+    const parts = [];
+    if (innerStatus) {
+        parts.push(`Inner dialog: ${innerStatus.status} (last completed: ${innerStatus.lastCompletedAt || "never"})`);
+    }
+    if (recentSessions.length > 0) {
+        parts.push(`Recent sessions (${recentSessions.length}):`);
+        for (const s of recentSessions) {
+            parts.push(`  - ${s.friendId}/${s.channel}/${s.key} (${s.lastUsage || "unknown"})`);
+        }
+    }
+    else {
+        parts.push("No recent sessions");
+    }
+    emit("daemon.agent_service_end", "completed agent.catchup", { 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 },
+        /* v8 ignore next — parts always has at least one element (either sessions or "No recent sessions") */
+        message: parts.length > 0 ? parts.join("\n") : `No recent activity for ${params.agent}`,
+        data: { recentSessions, innerStatus },
     };
 }
 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 },
-    });
+    emit("daemon.agent_service_start", "handling agent.delegate", { agent: params.agent });
     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 },
-        });
+        emit("daemon.agent_service_error", "agent.delegate missing task", { 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() },
-    };
+    emit("daemon.agent_service_end", "completed agent.delegate", { agent: params.agent });
+    return { ok: true, message: `Task queued: ${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 },
-    });
+    emit("daemon.agent_service_start", "handling agent.getContext", { agent: params.agent });
+    const query = (params.question ?? params.query ?? params.topic);
+    const diaryRoot = agentDiaryRoot(params.agent);
+    const facts = (0, diary_1.readDiaryEntries)(diaryRoot);
+    const innerStatus = readInnerDialogStatus(params.agent);
+    const sessions = enumerateSessions(params.agent);
+    const taskFiles = listTaskFiles(params.agent);
+    let memorySummary = null;
+    if (query) {
+        const hits = await (0, diary_1.searchDiaryEntries)(query, facts);
+        memorySummary = hits.length > 0
+            ? hits.slice(0, 10).map((f) => f.text).join("\n")
+            : `No relevant memories for: ${query}`;
+    }
+    else {
+        const recent = facts.slice(-10);
+        if (recent.length > 0)
+            memorySummary = recent.map((f) => f.text).join("\n");
+    }
+    emit("daemon.agent_service_end", "completed agent.getContext", { agent: params.agent });
     return {
         ok: true,
         data: {
             agent: params.agent,
-            hasMemory: memoryContent !== null,
-            memorySummary: memoryContent ? memoryContent.slice(0, 500) : null,
+            hasMemory: facts.length > 0,
+            factCount: facts.length,
+            memorySummary,
             taskCount: taskFiles.length,
+            sessionCount: sessions.length,
+            innerStatus: innerStatus?.status ?? null,
         },
     };
 }
 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 },
-    });
+    emit("daemon.agent_service_start", "handling agent.searchMemory", { agent: params.agent });
     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 },
-        });
+        emit("daemon.agent_service_error", "agent.searchMemory missing query", { 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 },
-    });
+    // Same searchDiaryEntries as the recall tool
+    const diaryRoot = agentDiaryRoot(params.agent);
+    const hits = await (0, diary_1.searchDiaryEntries)(query, (0, diary_1.readDiaryEntries)(diaryRoot));
+    const formatted = formatDiaryHits(hits.slice(0, 20));
+    emit("daemon.agent_service_end", "completed agent.searchMemory", { agent: params.agent, matchCount: hits.length });
     return {
         ok: true,
-        message: matches.length > 0 ? `Found ${matches.length} matches` : "No matches found",
-        data: { query, matches: matches.slice(0, 20) },
+        message: hits.length > 0 ? `Found ${hits.length} matches` : "No matches found",
+        data: { query, matches: formatted },
     };
 }
 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 },
+    emit("daemon.agent_service_start", "handling agent.getTask", { agent: params.agent });
+    const taskFiles = listTaskFiles(params.agent);
+    const activeTasks = taskFiles.filter((f) => f.toLowerCase().includes("doing") && !f.toLowerCase().includes("done"));
+    const taskNames = activeTasks.length > 0 ? activeTasks : taskFiles;
+    const tasks = taskNames.map((name) => {
+        const content = readAgentFile(params.agent, "tasks", name);
+        const firstLine = content?.split("\n").find((l) => l.trim().length > 0)?.trim() ?? "";
+        return { name, statusLine: firstLine };
     });
+    emit("daemon.agent_service_end", "completed agent.getTask", { agent: params.agent });
     return {
         ok: true,
-        message: taskFiles.length > 0
-            ? `Current tasks: ${taskFiles.join(", ")}`
-            : `No active tasks for ${params.agent}`,
-        data: { tasks: taskFiles },
+        message: tasks.length > 0 ? `Tasks (${tasks.length}): ${tasks.map((t) => t.name).join(", ")}` : `No active tasks for ${params.agent}`,
+        data: { tasks, activeCount: activeTasks.length, totalCount: taskFiles.length },
     };
 }
 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 },
-    });
+    emit("daemon.agent_service_start", "handling agent.checkScope", { agent: params.agent });
     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 },
-        });
+        emit("daemon.agent_service_error", "agent.checkScope missing item", { 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" },
-    };
+    emit("daemon.agent_service_end", "completed agent.checkScope", { 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 },
-    });
+    emit("daemon.agent_service_start", "handling agent.requestDecision", { agent: params.agent });
     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 },
-        });
+        emit("daemon.agent_service_error", "agent.requestDecision missing topic", { 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",
-        },
-    };
+    emit("daemon.agent_service_end", "completed agent.requestDecision", { agent: params.agent });
+    return { ok: true, message: `Decision request queued: ${topic}`, data: { topic, options: params.options ?? null, status: "pending" } };
 }
 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 },
-    });
+    emit("daemon.agent_service_start", "handling agent.checkGuidance", { agent: params.agent });
     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 },
-        });
+        emit("daemon.agent_service_error", "agent.checkGuidance missing topic", { 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 },
-    });
+    // Same searchDiaryEntries as the recall tool
+    const diaryRoot = agentDiaryRoot(params.agent);
+    const hits = await (0, diary_1.searchDiaryEntries)(topic, (0, diary_1.readDiaryEntries)(diaryRoot));
+    const guidance = hits.length > 0
+        ? `Relevant guidance:\n${hits.slice(0, 10).map((f) => f.text).join("\n")}`
+        : `No specific guidance found for: ${topic}`;
+    emit("daemon.agent_service_end", "completed agent.checkGuidance", { 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 },
-    });
+    emit("daemon.agent_service_start", "handling agent.reportProgress", { agent: params.agent });
     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 },
-        });
+        emit("daemon.agent_service_error", "agent.reportProgress missing summary", { 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() },
-    };
+    emit("daemon.agent_service_end", "completed agent.reportProgress", { 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 },
-    });
+    emit("daemon.agent_service_start", "handling agent.reportBlocker", { agent: params.agent });
     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 },
-        });
+        emit("daemon.agent_service_error", "agent.reportBlocker missing blocker", { 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() },
-    };
+    emit("daemon.agent_service_end", "completed agent.reportBlocker", { 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 },
-    });
+    emit("daemon.agent_service_start", "handling agent.reportComplete", { agent: params.agent });
     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 },
-        });
+        emit("daemon.agent_service_error", "agent.reportComplete missing summary", { 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() },
-    };
+    emit("daemon.agent_service_end", "completed agent.reportComplete", { agent: params.agent });
+    return { ok: true, message: `Completion reported: ${summary}`, data: { summary, receivedAt: new Date().toISOString() } };
 }