@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

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

@@ -0,0 +1,542 @@
+"use strict";
+/**
+ * Agent service layer — handles MCP-facing daemon commands.
+ * Each handler receives { agent, friendId, ...params } and returns DaemonResponse.
+ *
+ * DRY: uses the same shared functions the agent's own tools use (Desk record diary, session transcript).
+ * 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;
+    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.handleAgentSearchFacts = handleAgentSearchFacts;
+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 diary_1 = require("../../mind/diary");
+const record_paths_1 = require("../../mind/record-paths");
+const runtime_1 = require("../../nerves/runtime");
+const socket_client_1 = require("./socket-client");
+const mcp_canary_1 = require("./mcp-canary");
+/** Format diary hits the same way the search_facts 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");
+}
+/** Resolve the diary root for a specific agent. */
+function agentDiaryRoot(agent) {
+    return (0, record_paths_1.resolveRecordDiaryRoot)((0, identity_1.getAgentRoot)(agent));
+}
+/** Read private-runtime status. */
+function readPrivateRuntimeStatus(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 */
+}
+/** 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 [];
+    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 });
+}
+function objectRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : null;
+}
+function booleanValue(value) {
+    return typeof value === "boolean" ? value : null;
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function readMcpRuntimeVersion() {
+    const packagePath = path.resolve(__dirname, "..", "..", "..", "package.json");
+    try {
+        const parsed = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
+        return stringValue(parsed.version);
+    }
+    catch {
+        return null;
+    }
+}
+function summarizeRuntimeStatus(data, agent) {
+    const payload = objectRecord(data);
+    if (!payload)
+        return null;
+    const overview = objectRecord(payload.overview);
+    const workers = Array.isArray(payload.workers) ? payload.workers : [];
+    const senses = Array.isArray(payload.senses) ? payload.senses : [];
+    return {
+        daemonReachable: true,
+        overview: overview
+            ? {
+                daemon: stringValue(overview.daemon) ?? "unknown",
+                health: stringValue(overview.health) ?? "unknown",
+                version: stringValue(overview.version),
+                mode: stringValue(overview.mode),
+            }
+            : undefined,
+        workers: workers.flatMap((row) => {
+            const record = objectRecord(row);
+            if (!record || stringValue(record.agent) !== agent)
+                return [];
+            const worker = stringValue(record.worker);
+            const status = stringValue(record.status);
+            return worker && status ? [{ worker, status }] : [];
+        }),
+        senses: senses.flatMap((row) => {
+            const record = objectRecord(row);
+            if (!record || stringValue(record.agent) !== agent)
+                return [];
+            const sense = stringValue(record.sense);
+            const status = stringValue(record.status);
+            const enabled = booleanValue(record.enabled);
+            if (!sense || !status || enabled === null)
+                return [];
+            return [{
+                    sense,
+                    status,
+                    enabled,
+                    detail: stringValue(record.detail),
+                    proofMethod: stringValue(record.proofMethod),
+                    lastProofAt: stringValue(record.lastProofAt),
+                    proofAgeMs: numberValue(record.proofAgeMs),
+                    pendingRecoveryCount: numberValue(record.pendingRecoveryCount),
+                    failedRecoveryCount: numberValue(record.failedRecoveryCount),
+                    failureLayer: stringValue(record.failureLayer),
+                    lastFailure: stringValue(record.lastFailure),
+                    recoveryAction: stringValue(record.recoveryAction),
+                }];
+        }),
+    };
+}
+async function readRuntimeStatus(socketPath, agent) {
+    if (!socketPath)
+        return null;
+    try {
+        const response = await (0, socket_client_1.sendDaemonCommand)(socketPath, { kind: "daemon.status" });
+        if (!response.ok) {
+            return {
+                daemonReachable: false,
+                workers: [],
+                senses: [],
+                error: response.error ?? response.message ?? "daemon status did not answer cleanly",
+            };
+        }
+        return summarizeRuntimeStatus(response.data, agent);
+    }
+    catch (error) {
+        return {
+            daemonReachable: false,
+            workers: [],
+            senses: [],
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function formatRuntimeStatusLines(runtime, mcpVersion, agent) {
+    if (!runtime)
+        return mcpVersion ? [`mcpVersion=${mcpVersion}`] : [];
+    if (!runtime.daemonReachable) {
+        return [
+            `daemon=unreachable${runtime.error ? `\terror=${runtime.error}` : ""}`,
+            ...(mcpVersion ? [`mcpVersion=${mcpVersion}`] : []),
+        ];
+    }
+    const lines = [];
+    if (runtime.overview) {
+        const versionPart = runtime.overview.version ? `\tdaemonVersion=${runtime.overview.version}` : "";
+        const modePart = runtime.overview.mode ? `\tmode=${runtime.overview.mode}` : "";
+        const mcpVersionPart = mcpVersion ? `\tmcpVersion=${mcpVersion}` : "";
+        const hasVersionMismatch = !!(mcpVersion && runtime.overview.version && mcpVersion !== runtime.overview.version);
+        const mismatchPart = hasVersionMismatch
+            ? `\tversionMismatch=mcp:${mcpVersion},daemon:${runtime.overview.version}`
+            : "";
+        lines.push(`daemon=${runtime.overview.daemon}\thealth=${runtime.overview.health}${versionPart}${modePart}${mcpVersionPart}${mismatchPart}`);
+        if (hasVersionMismatch) {
+            const repair = (0, mcp_canary_1.buildMcpBridgeRepairGuidance)(agent);
+            lines.push(`mcpRepair=${repair.actor}\tcodex=${repair.commands[0]}\tclaudeCode=${repair.commands[1]}`);
+            lines.push(`mcpReload=required\treason=${repair.reload}`);
+        }
+    }
+    for (const worker of runtime.workers) {
+        lines.push(`worker=${worker.worker}:${worker.status}`);
+    }
+    for (const sense of runtime.senses) {
+        const detailPart = sense.detail ? `\tdetail=${sense.detail}` : "";
+        const proofPart = sense.proofMethod ? `\tproof=${sense.proofMethod}` : "";
+        const lastProofPart = sense.lastProofAt ? `\tlastProofAt=${sense.lastProofAt}` : "";
+        const proofAgePart = sense.proofAgeMs !== null ? `\tproofAgeMs=${sense.proofAgeMs}` : "";
+        const pendingPart = sense.pendingRecoveryCount !== null ? `\tpendingRecovery=${sense.pendingRecoveryCount}` : "";
+        const failedPart = sense.failedRecoveryCount !== null ? `\tfailedRecovery=${sense.failedRecoveryCount}` : "";
+        const failureLayerPart = sense.failureLayer ? `\tfailureLayer=${sense.failureLayer}` : "";
+        const failurePart = sense.lastFailure ? `\tlastFailure=${sense.lastFailure}` : "";
+        const recoveryPart = sense.recoveryAction ? `\trecovery=${sense.recoveryAction}` : "";
+        lines.push(`sense=${sense.sense}:${sense.enabled ? sense.status : "disabled"}`
+            + detailPart
+            + proofPart
+            + lastProofPart
+            + proofAgePart
+            + pendingPart
+            + failedPart
+            + failureLayerPart
+            + failurePart
+            + recoveryPart);
+    }
+    if (lines.length === 0 && mcpVersion)
+        lines.push(`mcpVersion=${mcpVersion}`);
+    return lines;
+}
+function summarizeMcpBridgeHealth(agent, runtime, mcpVersion) {
+    const daemonVersion = runtime?.daemonReachable ? runtime.overview?.version ?? null : null;
+    const versionMismatch = !!(mcpVersion && daemonVersion && mcpVersion !== daemonVersion);
+    return {
+        mcpVersion,
+        daemonVersion,
+        versionMismatch,
+        ...(versionMismatch ? { repair: (0, mcp_canary_1.buildMcpBridgeRepairGuidance)(agent) } : {}),
+    };
+}
+// ─── Handlers ────────────────────────────────────────────────────────────────
+async function handleAgentStatus(params) {
+    (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 = readPrivateRuntimeStatus(params.agent);
+    const sessions = enumerateSessions(params.agent);
+    const mcpVersion = readMcpRuntimeVersion();
+    const runtime = await readRuntimeStatus(params.socketPath ?? socket_client_1.DEFAULT_DAEMON_SOCKET_PATH, params.agent);
+    emit("daemon.agent_service_end", "completed agent.status", { agent: params.agent });
+    const innerStatusValue = innerStatus?.status ?? "unknown";
+    const lastThoughtAt = innerStatus?.lastCompletedAt ?? null;
+    const agentLine = [
+        `agent=${params.agent}`,
+        `innerStatus=${innerStatusValue}`,
+        `lastThoughtAt=${lastThoughtAt ?? "never"}`,
+        `sessionCount=${sessions.length}`,
+        `diaryEntries=${facts.length}`,
+    ].join("\t");
+    const runtimeLines = formatRuntimeStatusLines(runtime, mcpVersion, params.agent);
+    const mcpHealth = summarizeMcpBridgeHealth(params.agent, runtime, mcpVersion);
+    const message = [agentLine, ...runtimeLines].join("\n");
+    return {
+        ok: true,
+        message,
+        data: {
+            agent: params.agent,
+            innerStatus: innerStatusValue,
+            lastThoughtAt,
+            sessionCount: sessions.length,
+            hasDiaryEntries: facts.length > 0,
+            factCount: facts.length,
+            runtime,
+            mcpVersion,
+            mcpHealth,
+        },
+    };
+}
+async function handleAgentAsk(params) {
+    emit("daemon.agent_service_start", "handling agent.ask", { agent: params.agent });
+    const question = params.question;
+    if (!question) {
+        emit("daemon.agent_service_error", "agent.ask missing question", { agent: params.agent });
+        return { ok: false, error: "Missing required parameter: question" };
+    }
+    // Use the same searchDiaryEntries the search_facts 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 facts found for: ${question}`;
+    emit("daemon.agent_service_end", "completed agent.ask", { agent: params.agent });
+    return { ok: true, message: context };
+}
+async function handleAgentCatchup(params) {
+    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 = readPrivateRuntimeStatus(params.agent);
+    const parts = [];
+    if (innerStatus) {
+        parts.push(`Private runtime: ${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,
+        /* 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) {
+    emit("daemon.agent_service_start", "handling agent.delegate", { agent: params.agent });
+    const task = params.task;
+    if (!task) {
+        emit("daemon.agent_service_error", "agent.delegate missing task", { agent: params.agent });
+        return { ok: false, error: "Missing required parameter: task" };
+    }
+    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) {
+    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 = readPrivateRuntimeStatus(params.agent);
+    const sessions = enumerateSessions(params.agent);
+    const taskFiles = listTaskFiles(params.agent);
+    let recordSummary = null;
+    if (query) {
+        const hits = await (0, diary_1.searchDiaryEntries)(query, facts);
+        recordSummary = hits.length > 0
+            ? hits.slice(0, 10).map((f) => f.text).join("\n")
+            : `No relevant facts for: ${query}`;
+    }
+    else {
+        const recent = facts.slice(-10);
+        if (recent.length > 0)
+            recordSummary = 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,
+            hasDiaryEntries: facts.length > 0,
+            factCount: facts.length,
+            recordSummary,
+            taskCount: taskFiles.length,
+            sessionCount: sessions.length,
+            innerStatus: innerStatus?.status ?? null,
+        },
+    };
+}
+async function handleAgentSearchFacts(params) {
+    emit("daemon.agent_service_start", "handling agent.searchFacts", { agent: params.agent });
+    const query = params.query;
+    if (!query) {
+        emit("daemon.agent_service_error", "agent.searchFacts missing query", { agent: params.agent });
+        return { ok: false, error: "Missing required parameter: query" };
+    }
+    // Same searchDiaryEntries as the search_facts 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.searchFacts", { agent: params.agent, matchCount: hits.length });
+    return {
+        ok: true,
+        message: hits.length > 0 ? `Found ${hits.length} matches` : "No matches found",
+        data: { query, matches: formatted },
+    };
+}
+async function handleAgentGetTask(params) {
+    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: 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) {
+    emit("daemon.agent_service_start", "handling agent.checkScope", { agent: params.agent });
+    const item = params.item;
+    if (!item) {
+        emit("daemon.agent_service_error", "agent.checkScope missing item", { agent: params.agent });
+        return { ok: false, error: "Missing required parameter: item" };
+    }
+    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) {
+    emit("daemon.agent_service_start", "handling agent.requestDecision", { agent: params.agent });
+    const topic = params.topic;
+    if (!topic) {
+        emit("daemon.agent_service_error", "agent.requestDecision missing topic", { agent: params.agent });
+        return { ok: false, error: "Missing required parameter: topic" };
+    }
+    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) {
+    emit("daemon.agent_service_start", "handling agent.checkGuidance", { agent: params.agent });
+    const topic = params.topic;
+    if (!topic) {
+        emit("daemon.agent_service_error", "agent.checkGuidance missing topic", { agent: params.agent });
+        return { ok: false, error: "Missing required parameter: topic" };
+    }
+    // Same searchDiaryEntries as the search_facts 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) {
+    emit("daemon.agent_service_start", "handling agent.reportProgress", { agent: params.agent });
+    const summary = params.summary;
+    if (!summary) {
+        emit("daemon.agent_service_error", "agent.reportProgress missing summary", { agent: params.agent });
+        return { ok: false, error: "Missing required parameter: summary" };
+    }
+    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) {
+    emit("daemon.agent_service_start", "handling agent.reportBlocker", { agent: params.agent });
+    const blocker = params.blocker;
+    if (!blocker) {
+        emit("daemon.agent_service_error", "agent.reportBlocker missing blocker", { agent: params.agent });
+        return { ok: false, error: "Missing required parameter: blocker" };
+    }
+    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) {
+    emit("daemon.agent_service_start", "handling agent.reportComplete", { agent: params.agent });
+    const summary = params.summary;
+    if (!summary) {
+        emit("daemon.agent_service_error", "agent.reportComplete missing summary", { agent: params.agent });
+        return { ok: false, error: "Missing required parameter: summary" };
+    }
+    emit("daemon.agent_service_end", "completed agent.reportComplete", { agent: params.agent });
+    return { ok: true, message: `Completion reported: ${summary}`, data: { summary, receivedAt: new Date().toISOString() } };
+}