@ouro.bot/cli 0.1.0-alpha.66 → 0.1.0-alpha.661

package/dist/heart/mailbox/mailbox-view.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMailboxMachineView = buildMailboxMachineView;
+exports.buildMailboxAgentView = buildMailboxAgentView;
+const runtime_1 = require("../../nerves/runtime");
+const mailbox_types_1 = require("./mailbox-types");
+function deriveAttention(agent) {
+    if (agent.degraded.status === "degraded") {
+        return { level: "degraded", label: "Degraded" };
+    }
+    if (agent.freshness.status === "stale") {
+        return { level: "stale", label: "Stale" };
+    }
+    if (agent.tasks.blockedCount > 0 || agent.coding.blockedCount > 0) {
+        return { level: "blocked", label: "Blocked" };
+    }
+    if (agent.tasks.liveCount > 0 || agent.coding.activeCount > 0 || agent.obligations.openCount > 0) {
+        return { level: "active", label: "Active" };
+    }
+    return { level: "idle", label: "Idle" };
+}
+function deriveAgentAttention(agent) {
+    return deriveAttention({
+        agentName: agent.agentName,
+        enabled: agent.enabled,
+        freshness: agent.freshness,
+        degraded: agent.degraded,
+        tasks: {
+            liveCount: agent.tasks.liveCount,
+            blockedCount: agent.tasks.blockedCount,
+        },
+        obligations: {
+            openCount: agent.obligations.openCount,
+        },
+        coding: {
+            activeCount: agent.coding.activeCount,
+            blockedCount: agent.coding.blockedCount,
+        },
+    });
+}
+function buildTotals(machine) {
+    return machine.agents.reduce((totals, agent) => ({
+        agents: totals.agents + 1,
+        enabledAgents: totals.enabledAgents + (agent.enabled ? 1 : 0),
+        degradedAgents: totals.degradedAgents + (agent.degraded.status === "degraded" ? 1 : 0),
+        staleAgents: totals.staleAgents + (agent.freshness.status === "stale" ? 1 : 0),
+        liveTasks: totals.liveTasks + agent.tasks.liveCount,
+        blockedTasks: totals.blockedTasks + agent.tasks.blockedCount,
+        openObligations: totals.openObligations + agent.obligations.openCount,
+        activeCodingAgents: totals.activeCodingAgents + (agent.coding.activeCount > 0 ? 1 : 0),
+        blockedCodingAgents: totals.blockedCodingAgents + (agent.coding.blockedCount > 0 ? 1 : 0),
+    }), {
+        agents: 0,
+        enabledAgents: 0,
+        degradedAgents: 0,
+        staleAgents: 0,
+        liveTasks: 0,
+        blockedTasks: 0,
+        openObligations: 0,
+        activeCodingAgents: 0,
+        blockedCodingAgents: 0,
+    });
+}
+function deriveMood(machine, daemon) {
+    if (machine.degraded.status === "degraded" || daemon.health === "warn") {
+        return "strained";
+    }
+    if (machine.freshness.status === "stale") {
+        return "watchful";
+    }
+    return "calm";
+}
+function buildMailboxMachineView(input) {
+    const totals = buildTotals(input.machine);
+    const agents = input.machine.agents
+        .map((agent) => ({
+        ...agent,
+        attention: deriveAttention(agent),
+    }))
+        .sort((left, right) => {
+        const leftAt = left.freshness.latestActivityAt ?? "";
+        const rightAt = right.freshness.latestActivityAt ?? "";
+        return rightAt.localeCompare(leftAt);
+    });
+    return {
+        overview: {
+            productName: mailbox_types_1.MAILBOX_PRODUCT_NAME,
+            observedAt: input.machine.observedAt,
+            primaryEntryPoint: input.daemon.mailboxUrl,
+            daemon: input.daemon,
+            runtime: input.machine.runtime,
+            freshness: input.machine.freshness,
+            degraded: input.machine.degraded,
+            totals,
+            mood: deriveMood(input.machine, input.daemon),
+            entrypoints: [
+                { kind: "web", label: "Open Mailbox", target: input.daemon.mailboxUrl },
+                { kind: "cli", label: "CLI JSON", target: "ouro mailbox --json" },
+            ],
+        },
+        agents,
+    };
+}
+function normalizeViewer(viewer) {
+    return {
+        kind: viewer?.kind ?? "human",
+        agentName: viewer?.agentName,
+        innerDetail: viewer?.innerDetail ?? "summary",
+    };
+}
+function buildInnerView(inner, viewer) {
+    if (viewer.innerDetail === "deep") {
+        return {
+            mode: "deep",
+            status: inner.status,
+            summary: inner.surfacedSummary,
+            hasPending: inner.hasPending,
+            origin: inner.origin,
+            obligationStatus: inner.obligationStatus,
+            returnObligationQueue: inner.returnObligationQueue,
+        };
+    }
+    return {
+        mode: "summary",
+        status: inner.status,
+        summary: inner.surfacedSummary,
+        hasPending: inner.hasPending,
+        returnObligationQueue: inner.returnObligationQueue,
+    };
+}
+function buildRecentActivity(agent) {
+    const items = [
+        ...agent.coding.items.map((item) => ({
+            kind: "coding",
+            at: item.lastActivityAt,
+            label: item.checkpoint ?? `${item.runner} ${item.status}`,
+            detail: item.workdir,
+        })),
+        ...agent.sessions.items.map((item) => ({
+            kind: "session",
+            at: item.lastActivityAt,
+            label: `${item.friendName} via ${item.channel}`,
+            detail: item.key,
+        })),
+        ...agent.obligations.items.map((item) => ({
+            kind: "obligation",
+            at: item.updatedAt,
+            label: item.content,
+            detail: item.nextAction ?? item.status,
+        })),
+    ];
+    if (agent.inner.latestActivityAt) {
+        items.push({
+            kind: "inner",
+            at: agent.inner.latestActivityAt,
+            label: agent.inner.surfacedSummary ?? agent.inner.status,
+            detail: agent.inner.hasPending ? "pending inner work" : agent.inner.obligationStatus ?? "no linked obligation",
+        });
+    }
+    return items
+        .filter((item) => Number.isFinite(Date.parse(item.at)))
+        .sort((left, right) => right.at.localeCompare(left.at))
+        .slice(0, 4);
+}
+function buildMailboxAgentView(input) {
+    /* v8 ignore next */
+    (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.mailbox_view_agent", message: `building mailbox view for ${input.agent.agentName}`, meta: { agent: input.agent.agentName } });
+    const viewer = normalizeViewer(input.viewer);
+    return {
+        productName: mailbox_types_1.MAILBOX_PRODUCT_NAME,
+        interactionModel: mailbox_types_1.MAILBOX_RELEASE_INTERACTION_MODEL,
+        viewer,
+        agent: {
+            agentName: input.agent.agentName,
+            agentRoot: input.agent.agentRoot,
+            enabled: input.agent.enabled,
+            provider: input.agent.provider,
+            providers: input.agent.providers ?? null,
+            senses: input.agent.senses,
+            freshness: input.agent.freshness,
+            degraded: input.agent.degraded,
+            attention: deriveAgentAttention(input.agent),
+        },
+        work: {
+            tasks: input.agent.tasks,
+            obligations: input.agent.obligations,
+            sessions: input.agent.sessions,
+            coding: input.agent.coding,
+            bridges: input.agent.tasks.activeBridges,
+        },
+        inner: buildInnerView(input.agent.inner, viewer),
+        activity: {
+            freshness: input.agent.freshness,
+            recent: buildRecentActivity(input.agent),
+        },
+    };
+}

package/dist/heart/mailbox/readers/agent-machine.js

@@ -0,0 +1,418 @@
+"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.readObligationSummary = readObligationSummary;
+exports.readMailboxAgentState = readMailboxAgentState;
+exports.readMailboxMachineState = readMailboxMachineState;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../../nerves/runtime");
+const obligations_1 = require("../../../arc/obligations");
+const session_activity_1 = require("../../session-activity");
+const identity_1 = require("../../identity");
+const agent_discovery_1 = require("../../daemon/agent-discovery");
+const runtime_metadata_1 = require("../../daemon/runtime-metadata");
+const provider_visibility_1 = require("../../provider-visibility");
+const thoughts_1 = require("../../daemon/thoughts");
+const mailbox_types_1 = require("../mailbox-types");
+const shared_1 = require("./shared");
+function emptyByStatus() {
+    return {
+        drafting: 0,
+        processing: 0,
+        validating: 0,
+        collaborating: 0,
+        paused: 0,
+        blocked: 0,
+        cancelled: 0,
+        done: 0,
+    };
+}
+function readAgentConfig(agentRoot) {
+    const configPath = path.join(agentRoot, "agent.json");
+    try {
+        const raw = fs.readFileSync(configPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const senses = Object.entries(parsed.senses ?? {})
+            .filter(([, value]) => value && typeof value.enabled === "boolean" && value.enabled)
+            .map(([name]) => name)
+            .sort((left, right) => left.localeCompare(right));
+        return {
+            summary: {
+                enabled: typeof parsed.enabled === "boolean" ? parsed.enabled : true,
+                provider: typeof parsed.provider === "string" ? parsed.provider : null,
+                senses,
+            },
+            issues: [],
+        };
+    }
+    catch (error) {
+        return {
+            summary: {
+                enabled: false,
+                provider: null,
+                senses: [],
+            },
+            issues: [(0, shared_1.issue)("agent-config-unreadable", `${configPath}: ${error instanceof Error ? error.message : String(error)}`)],
+        };
+    }
+}
+// W6 Unit 8a: built-in task module reads removed; mailbox surface keeps
+// MailboxTaskSummary shape but reports zero counts. The desk MCP server is
+// the new source of truth — its read surface will be wired into mailbox in
+// a follow-up unit (8b). For now consumers see "no tasks tracked" which is
+// the correct steady state until desk-side reads are in place.
+function readTaskSummary(_agentRoot) {
+    return {
+        summary: {
+            totalCount: 0,
+            liveCount: 0,
+            blockedCount: 0,
+            byStatus: emptyByStatus(),
+            liveTaskNames: [],
+            actionRequired: [],
+            activeBridges: [],
+        },
+        issues: [],
+    };
+}
+const STALE_CODING_SURFACE_WINDOW_MS = 60 * 60 * 1000;
+function buildLiveCodingSurfaceLabels(agentRoot) {
+    return new Set(readCodingSummary(agentRoot).items
+        .filter((item) => shared_1.ACTIVE_CODING_STATUSES.has(item.status))
+        .map((item) => `${item.runner} ${item.id}`));
+}
+function normalizeObligationCurrentSurface(currentSurface, updatedAt, liveCodingSurfaceLabels) {
+    if (!currentSurface || currentSurface.kind !== "coding")
+        return currentSurface;
+    const liveLabel = currentSurface.label.trim();
+    if (!liveLabel)
+        return null;
+    if (liveCodingSurfaceLabels.has(liveLabel))
+        return currentSurface;
+    const updatedAtMs = Date.parse(updatedAt);
+    const recentlyTouched = Number.isFinite(updatedAtMs)
+        && (Date.now() - updatedAtMs) <= STALE_CODING_SURFACE_WINDOW_MS;
+    return recentlyTouched ? currentSurface : null;
+}
+function readObligationSummary(agentRoot) {
+    const liveCodingSurfaceLabels = buildLiveCodingSurfaceLabels(agentRoot);
+    const items = (0, obligations_1.readPendingObligations)(agentRoot)
+        .map((obligation) => {
+        const updatedAt = obligation.updatedAt ?? obligation.createdAt;
+        return {
+            id: obligation.id,
+            status: obligation.status,
+            content: obligation.content,
+            updatedAt,
+            nextAction: obligation.nextAction ?? null,
+            /* v8 ignore start */
+            origin: obligation.origin ?? null,
+            currentSurface: normalizeObligationCurrentSurface(obligation.currentSurface ?? null, updatedAt, liveCodingSurfaceLabels),
+            /* v8 ignore stop */
+        };
+    })
+        .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+    return { items };
+}
+function readSessionSummary(agentName, agentRoot, now) {
+    const items = (0, session_activity_1.listSessionActivity)({
+        sessionsDir: path.join(agentRoot, "state", "sessions"),
+        friendsDir: path.join(agentRoot, "friends"),
+        agentName,
+        nowMs: now.getTime(),
+    })
+        .filter((session) => !(session.friendId === "self" && session.channel === "inner"))
+        .map((session) => ({
+        friendId: session.friendId,
+        friendName: session.friendName,
+        channel: session.channel,
+        key: session.key,
+        sessionPath: session.sessionPath,
+        lastActivityAt: session.lastActivityAt,
+        activitySource: session.activitySource,
+    }));
+    return { items };
+}
+function readInnerSummary(agentRoot) {
+    const sessionPath = (0, thoughts_1.getInnerDialogSessionPath)(agentRoot);
+    const pendingDir = path.join(agentRoot, "state", "pending", "self", "inner", "dialog");
+    const { pendingMessages, turns, runtimeState } = (0, thoughts_1.readInnerDialogRawData)(sessionPath, pendingDir);
+    const job = (0, thoughts_1.deriveInnerJob)(pendingMessages, turns, runtimeState);
+    const surfacedSummary = job.surfacedResult ? (0, thoughts_1.formatSurfacedValue)(job.surfacedResult) : null;
+    const latestPendingTimestamp = pendingMessages.length > 0
+        ? new Date(Math.max(...pendingMessages.map((message) => message.timestamp))).toISOString()
+        : null;
+    const latestActivityAt = latestPendingTimestamp
+        ?? runtimeState?.startedAt
+        ?? runtimeState?.lastCompletedAt
+        ?? null;
+    // Read the return-obligation queue so the Inner tab can show what the
+    // agent is actually holding right now. Before this, the "Inner work"
+    // panel only consulted the pending-messages dir (inbox-style); it
+    // reported "No pending inner work" even when dozens of held items were
+    // sitting in arc/obligations/inner/ waiting to be reinjected next turn.
+    const returnObligationQueue = readReturnObligationQueueSummary(agentRoot);
+    return {
+        summary: {
+            visibility: mailbox_types_1.MAILBOX_DEFAULT_INNER_VISIBILITY,
+            status: job.status,
+            hasPending: pendingMessages.length > 0,
+            surfacedSummary,
+            origin: job.origin,
+            obligationStatus: job.obligationStatus,
+            latestActivityAt,
+            returnObligationQueue,
+        },
+        issues: [],
+        latestActivityAt,
+    };
+}
+function readReturnObligationQueueSummary(agentRoot) {
+    const dir = path.join(agentRoot, "arc", "obligations", "inner");
+    let names = [];
+    try {
+        names = fs.readdirSync(dir).filter((name) => name.endsWith(".json"));
+    }
+    catch {
+        return { queuedCount: 0, runningCount: 0, oldestActiveAt: null };
+    }
+    let queuedCount = 0;
+    let runningCount = 0;
+    let oldestActiveAt = null;
+    for (const name of names) {
+        let parsed = null;
+        try {
+            parsed = JSON.parse(fs.readFileSync(path.join(dir, name), "utf-8"));
+        }
+        catch {
+            continue;
+        }
+        if (!parsed)
+            continue;
+        const status = parsed.status;
+        if (status === "queued")
+            queuedCount += 1;
+        else if (status === "running")
+            runningCount += 1;
+        else
+            continue;
+        const createdAt = typeof parsed.createdAt === "number" ? parsed.createdAt : null;
+        if (createdAt !== null && (oldestActiveAt === null || createdAt < oldestActiveAt)) {
+            oldestActiveAt = createdAt;
+        }
+    }
+    return { queuedCount, runningCount, oldestActiveAt };
+}
+function readCodingSummary(agentRoot) {
+    const stateFilePath = path.join(agentRoot, "state", "coding", "sessions.json");
+    const issues = [];
+    if (!fs.existsSync(stateFilePath)) {
+        return { items: [], issues };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(stateFilePath, "utf-8"));
+    }
+    catch (error) {
+        issues.push((0, shared_1.issue)("coding-state-unreadable", `${stateFilePath}: ${error instanceof Error ? error.message : String(error)}`));
+        return { items: [], issues };
+    }
+    const items = Array.isArray(parsed.records)
+        ? parsed.records.flatMap((record) => {
+            const session = record?.session;
+            if (!session || typeof session.id !== "string" || typeof session.runner !== "string" || typeof session.status !== "string" || typeof session.workdir !== "string" || typeof session.lastActivityAt !== "string") {
+                return [];
+            }
+            const checkpoint = typeof session.checkpoint === "string"
+                ? session.checkpoint
+                : typeof session.stderrTail === "string" && session.stderrTail.trim().length > 0
+                    ? session.stderrTail.trim()
+                    : typeof session.stdoutTail === "string" && session.stdoutTail.trim().length > 0
+                        ? session.stdoutTail.trim()
+                        : null;
+            const originSession = session.originSession;
+            const normalizedOrigin = originSession
+                && typeof originSession.friendId === "string"
+                && typeof originSession.channel === "string"
+                && typeof originSession.key === "string"
+                ? {
+                    friendId: originSession.friendId,
+                    channel: originSession.channel,
+                    key: originSession.key,
+                }
+                : null;
+            return [{
+                    id: session.id,
+                    runner: session.runner,
+                    status: session.status,
+                    checkpoint,
+                    taskRef: typeof session.taskRef === "string" ? session.taskRef : null,
+                    workdir: session.workdir,
+                    originSession: normalizedOrigin,
+                    lastActivityAt: session.lastActivityAt,
+                }];
+        })
+        : [];
+    return { items, issues };
+}
+function collectLatestActivityTimestamps(input) {
+    const timestamps = [];
+    for (const item of input.obligations)
+        timestamps.push(item.updatedAt);
+    for (const item of input.sessions)
+        timestamps.push(item.lastActivityAt);
+    for (const item of input.coding)
+        timestamps.push(item.lastActivityAt);
+    if (input.innerLatestActivityAt)
+        timestamps.push(input.innerLatestActivityAt);
+    return timestamps
+        .filter((value) => Number.isFinite(Date.parse(value)));
+}
+function summarizeFreshness(latestActivityAt, now) {
+    if (!latestActivityAt) {
+        return {
+            status: "unknown",
+            latestActivityAt: null,
+            ageMs: null,
+        };
+    }
+    const ageMs = now.getTime() - Date.parse(latestActivityAt);
+    return {
+        status: ageMs > shared_1.STALE_THRESHOLD_MS ? "stale" : "fresh",
+        latestActivityAt,
+        ageMs,
+    };
+}
+function summarizeDegraded(issues) {
+    return {
+        status: issues.length > 0 ? "degraded" : "ok",
+        issues,
+    };
+}
+function summarizeAgent(state) {
+    return {
+        agentName: state.agentName,
+        enabled: state.enabled,
+        providers: state.providers,
+        freshness: state.freshness,
+        degraded: state.degraded,
+        tasks: {
+            liveCount: state.tasks.liveCount,
+            blockedCount: state.tasks.blockedCount,
+        },
+        obligations: {
+            openCount: state.obligations.openCount,
+        },
+        coding: {
+            activeCount: state.coding.activeCount,
+            blockedCount: state.coding.blockedCount,
+        },
+    };
+}
+function readMailboxAgentState(agentName, options = {}) {
+    const bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+    const now = options.now?.() ?? new Date();
+    const agentRoot = path.join(bundlesRoot, `${agentName}.ouro`);
+    const issues = [];
+    const config = readAgentConfig(agentRoot);
+    issues.push(...config.issues);
+    const tasks = readTaskSummary(agentRoot);
+    issues.push(...tasks.issues);
+    const obligations = readObligationSummary(agentRoot);
+    const sessions = readSessionSummary(agentName, agentRoot, now);
+    const inner = readInnerSummary(agentRoot);
+    issues.push(...inner.issues);
+    const coding = readCodingSummary(agentRoot);
+    issues.push(...coding.issues);
+    const providers = (0, provider_visibility_1.buildAgentProviderVisibility)({ agentName, agentRoot, homeDir: options.homeDir });
+    const latestActivityAt = collectLatestActivityTimestamps({
+        obligations: obligations.items,
+        sessions: sessions.items,
+        innerLatestActivityAt: inner.latestActivityAt,
+        coding: coding.items,
+    }).sort((left, right) => right.localeCompare(left))[0] ?? null;
+    return {
+        productName: mailbox_types_1.MAILBOX_PRODUCT_NAME,
+        agentName,
+        agentRoot,
+        enabled: config.summary.enabled,
+        provider: config.summary.provider,
+        providers,
+        senses: config.summary.senses,
+        freshness: summarizeFreshness(latestActivityAt, now),
+        degraded: summarizeDegraded(issues),
+        tasks: tasks.summary,
+        obligations: {
+            openCount: obligations.items.length,
+            items: obligations.items,
+        },
+        sessions: {
+            liveCount: sessions.items.length,
+            items: sessions.items,
+        },
+        inner: inner.summary,
+        coding: {
+            totalCount: coding.items.length,
+            activeCount: coding.items.filter((item) => shared_1.ACTIVE_CODING_STATUSES.has(item.status)).length,
+            blockedCount: coding.items.filter((item) => shared_1.BLOCKED_CODING_STATUSES.has(item.status)).length,
+            items: coding.items,
+        },
+    };
+}
+function readMailboxMachineState(options = {}) {
+    /* v8 ignore next */
+    (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.mailbox_read", message: "reading mailbox machine state", meta: {} });
+    const bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+    const now = options.now?.() ?? new Date();
+    const runtime = options.runtimeMetadata ?? (0, runtime_metadata_1.getRuntimeMetadata)({ bundlesRoot });
+    const agentNames = options.agentNames ?? (0, agent_discovery_1.listEnabledBundleAgents)({ bundlesRoot });
+    const agentStates = agentNames.map((agentName) => readMailboxAgentState(agentName, { ...options, bundlesRoot, now: () => now }));
+    const degradedIssues = agentStates
+        .flatMap((state) => state.degraded.issues.map((problem) => (0, shared_1.issue)("agent-degraded", `${state.agentName}: ${problem.detail}`)));
+    const freshest = agentStates
+        .map((state) => state.freshness.latestActivityAt)
+        .filter((value) => typeof value === "string")
+        .sort((left, right) => right.localeCompare(left))[0] ?? null;
+    return {
+        productName: mailbox_types_1.MAILBOX_PRODUCT_NAME,
+        observedAt: now.toISOString(),
+        runtime,
+        agentCount: agentStates.length,
+        freshness: summarizeFreshness(freshest, now),
+        degraded: summarizeDegraded(degradedIssues),
+        agents: agentStates.map(summarizeAgent),
+    };
+}