@openscout/runtime 0.2.37 → 0.2.39

package/dist/broker-daemon.js

@@ -1,16 +1,18 @@
 import { createServer } from "node:http";
 import { hostname } from "node:os";
 import { join } from "node:path";
-import { assertValidCollaborationEvent, assertValidCollaborationRecord, buildRelayReturnAddress, } from "@openscout/protocol";
+import { assertValidCollaborationEvent, assertValidCollaborationRecord, buildRelayReturnAddress, SCOUT_DISPATCHER_AGENT_ID, } from "@openscout/protocol";
 import { createInMemoryControlRuntime } from "./broker.js";
 import { FileBackedBrokerJournal } from "./broker-journal.js";
+import { buildDispatchEnvelope, resolveAgentLabel, } from "./scout-dispatcher.js";
 import { buildCollaborationInvocation } from "./collaboration-invocations.js";
 import { discoverMeshNodes } from "./mesh-discovery.js";
-import { buildMeshCollaborationEventBundle, buildMeshCollaborationRecordBundle, buildMeshInvocationBundle, buildMeshMessageBundle, forwardMeshCollaborationEvent, forwardMeshCollaborationRecord, forwardMeshInvocation, fetchPeerAgents, forwardMeshMessage, } from "./mesh-forwarding.js";
+import { buildMeshCollaborationEventBundle, buildMeshCollaborationRecordBundle, buildMeshMessageBundle, forwardMeshCollaborationEvent, forwardMeshCollaborationRecord, fetchPeerAgents, forwardMeshMessage, } from "./mesh-forwarding.js";
+import { createPeerDeliveryWorker } from "./peer-delivery.js";
 import { ensureLocalAgentBindingOnline, isLocalAgentEndpointAlive, isLocalAgentSessionAlive, invokeLocalAgentEndpoint, loadRegisteredLocalAgentBindings, shouldDisableGeneratedCodexEndpoint, } from "./local-agents.js";
 import { RecoverableSQLiteProjection } from "./sqlite-projection.js";
 import { ensureOpenScoutCleanSlateSync } from "./support-paths.js";
-import { buildDefaultBrokerUrl, DEFAULT_BROKER_HOST, DEFAULT_BROKER_PORT, } from "./broker-service.js";
+import { buildDefaultBrokerUrl, DEFAULT_BROKER_PORT, isLoopbackHost, resolveAdvertiseScope, resolveBrokerHost, } from "./broker-service.js";
 function createRuntimeId(prefix) {
     return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
@@ -51,7 +53,8 @@ const controlHome = resolveControlPlaneHome();
 const dbPath = join(controlHome, "control-plane.sqlite");
 const journalPath = join(controlHome, "broker-journal.jsonl");
 const port = Number.parseInt(process.env.OPENSCOUT_BROKER_PORT ?? String(DEFAULT_BROKER_PORT), 10);
-const host = process.env.OPENSCOUT_BROKER_HOST ?? DEFAULT_BROKER_HOST;
+const advertiseScope = resolveAdvertiseScope();
+const host = resolveBrokerHost(advertiseScope);
 const meshId = process.env.OPENSCOUT_MESH_ID ?? "openscout";
 const nodeName = process.env.OPENSCOUT_NODE_NAME ?? hostname();
 const tailnetName = process.env.TAILSCALE_TAILNET ?? undefined;
@@ -84,20 +87,59 @@ const activeInvocationTasks = new Map();
 const knownInvocations = new Map();
 const sseKeepAliveIntervalMs = Number.parseInt(process.env.OPENSCOUT_SSE_KEEPALIVE_MS ?? "15000", 10);
 const operatorActorId = "operator";
+// Per-invocation SSE subscribers. A single caller can watch one invocation
+// without draining the entire global event firehose.
+const invocationStreamClients = new Map();
+function invocationIdsForEvent(event) {
+    switch (event.kind) {
+        case "invocation.requested":
+            return [event.payload.invocation.id];
+        case "flight.updated":
+            return event.payload.flight.invocationId ? [event.payload.flight.invocationId] : [];
+        case "delivery.planned":
+            return event.payload.delivery.invocationId ? [event.payload.delivery.invocationId] : [];
+        case "delivery.attempted": {
+            const deliveryId = event.payload.attempt.deliveryId;
+            const delivery = journal.listDeliveries({ limit: 1000 }).find((d) => d.id === deliveryId);
+            return delivery?.invocationId ? [delivery.invocationId] : [];
+        }
+        case "delivery.state.changed":
+            return event.payload.delivery.invocationId ? [event.payload.delivery.invocationId] : [];
+        case "scout.dispatched":
+            return event.payload.dispatch.invocationId ? [event.payload.dispatch.invocationId] : [];
+        case "message.posted": {
+            const dispatch = event.payload.message.metadata
+                ?.scoutDispatch;
+            return dispatch?.invocationId ? [dispatch.invocationId] : [];
+        }
+        default:
+            return [];
+    }
+}
 function streamEvent(event) {
     projection.enqueueEvent(event);
     const payload = `event: ${event.kind}\ndata: ${JSON.stringify(event)}\n\n`;
     for (const client of eventClients) {
         client.write(payload);
     }
+    for (const invocationId of invocationIdsForEvent(event)) {
+        const subscribers = invocationStreamClients.get(invocationId);
+        if (!subscribers)
+            continue;
+        for (const client of subscribers) {
+            client.write(payload);
+        }
+    }
 }
 function streamKeepAlive() {
-    if (eventClients.size == 0) {
-        return;
-    }
     for (const client of eventClients) {
         client.write(": keepalive\n\n");
     }
+    for (const subscribers of invocationStreamClients.values()) {
+        for (const client of subscribers) {
+            client.write(": keepalive\n\n");
+        }
+    }
 }
 runtime.subscribe((event) => {
     streamEvent(event);
@@ -112,7 +154,7 @@ const localNode = {
     meshId,
     name: nodeName,
     hostName: hostname(),
-    advertiseScope: host === DEFAULT_BROKER_HOST ? "local" : "mesh",
+    advertiseScope,
     brokerUrl,
     tailnetName,
     capabilities: ["broker", "mesh", "local_runtime"],
@@ -143,6 +185,9 @@ async function discoverPeers(seeds = []) {
     });
     for (const node of result.discovered) {
         await upsertNodeDurably(node);
+        // A previously-unreachable peer may have come back — flush any deferred
+        // outbox entries targeting it without waiting for the next backoff window.
+        peerDelivery.notifyPeerOnline(node.id);
     }
     // Sync agents from each discovered peer so local broker knows about remote agents.
     // This enables @mention resolution and message forwarding across the mesh.
@@ -192,13 +237,12 @@ function runDurableWrite(work) {
     durableWriteQueue = next.then(() => undefined, () => undefined);
     return next;
 }
-async function appendJournalEntries(entries) {
-    await journal.appendEntries(entries);
-}
 async function commitDurableEntries(entriesInput, applyRuntime, options = {}) {
-    const entries = normalizeJournalEntries(entriesInput);
-    await appendJournalEntries(entries);
-    await applyRuntime();
+    const entries = await journal.appendEntries(normalizeJournalEntries(entriesInput));
+    if (entries.length === 0) {
+        return [];
+    }
+    await applyRuntime(entries);
     if (options.enqueueProjection !== false) {
         projection.enqueueEntries(entries);
     }
@@ -223,9 +267,13 @@ async function upsertAgentDurably(agent) {
         await commitDurableEntries([
             { kind: "actor.upsert", actor: agent },
             { kind: "agent.upsert", agent },
-        ], async () => {
-            await runtime.upsertActor(agent);
-            await runtime.upsertAgent(agent);
+        ], async (entries) => {
+            if (entries.some((entry) => entry.kind === "actor.upsert")) {
+                await runtime.upsertActor(agent);
+            }
+            if (entries.some((entry) => entry.kind === "agent.upsert")) {
+                await runtime.upsertAgent(agent);
+            }
         });
     });
 }
@@ -284,6 +332,49 @@ async function recordMessageDurably(message, options = {}) {
         return { deliveries, entries };
     });
 }
+async function recordScoutDispatchDurably(envelope, options = {}) {
+    const record = {
+        id: createRuntimeId("scout-dispatch"),
+        invocationId: options.invocationId,
+        conversationId: options.conversationId,
+        requesterId: options.requesterId,
+        ...envelope,
+    };
+    const dispatchEntries = [
+        { kind: "scout.dispatch.record", dispatch: record },
+    ];
+    let syntheticMessage = null;
+    if (options.conversationId) {
+        syntheticMessage = {
+            id: createRuntimeId("msg-scout"),
+            conversationId: options.conversationId,
+            actorId: SCOUT_DISPATCHER_AGENT_ID,
+            originNodeId: nodeId,
+            class: "system",
+            body: record.detail,
+            visibility: "workspace",
+            policy: "best_effort",
+            createdAt: record.dispatchedAt,
+            metadata: {
+                scoutDispatch: record,
+            },
+        };
+    }
+    return runDurableWrite(async () => {
+        const appended = await commitDurableEntries(dispatchEntries, async () => { });
+        if (!syntheticMessage) {
+            return { record, message: null, entries: appended };
+        }
+        const deliveries = runtime.planMessage(syntheticMessage, { localOnly: true });
+        const messageEntries = await commitDurableEntries([
+            { kind: "message.record", message: syntheticMessage },
+            { kind: "deliveries.record", deliveries },
+        ], async () => {
+            await runtime.commitMessage(syntheticMessage, deliveries);
+        });
+        return { record, message: syntheticMessage, entries: [...appended, ...messageEntries] };
+    });
+}
 async function recordInvocationDurably(invocation, options = {}) {
     return runDurableWrite(async () => {
         const flight = options.flight ?? runtime.planInvocation(invocation);
@@ -304,6 +395,11 @@ async function recordFlightDurably(flight) {
         });
     });
 }
+async function recordDeliveryDurably(delivery) {
+    await runDurableWrite(async () => {
+        await commitDurableEntries({ kind: "deliveries.record", deliveries: [delivery] }, async () => { });
+    });
+}
 async function recordDeliveryAttemptDurably(attempt) {
     await runDurableWrite(async () => {
         await commitDurableEntries({
@@ -388,44 +484,33 @@ async function applyMeshBundleDurably(bundle, options = {}) {
         assertValidCollaborationEvent(bundle.collaborationEvent, record);
     }
     const entries = buildMeshBundleEntries(bundle);
-    return commitDurableEntries(entries, async () => {
-        const appliedActorIds = new Set();
-        const appliedAgentIds = new Set();
-        const appliedBindingIds = new Set();
-        await runtime.upsertNode(bundle.originNode);
-        for (const actor of bundle.actors) {
-            if (appliedActorIds.has(actor.id)) {
-                continue;
-            }
-            appliedActorIds.add(actor.id);
-            await runtime.upsertActor(actor);
-        }
-        for (const agent of bundle.agents) {
-            if (appliedAgentIds.has(agent.id)) {
-                continue;
-            }
-            appliedAgentIds.add(agent.id);
-            if (!appliedActorIds.has(agent.id)) {
-                appliedActorIds.add(agent.id);
-                await runtime.upsertActor(agent);
-            }
-            await runtime.upsertAgent(agent);
-        }
-        if (bundle.conversation) {
-            await runtime.upsertConversation(bundle.conversation);
-        }
-        for (const binding of bundle.bindings ?? []) {
-            if (appliedBindingIds.has(binding.id)) {
-                continue;
+    return commitDurableEntries(entries, async (retainedEntries) => {
+        for (const entry of retainedEntries) {
+            switch (entry.kind) {
+                case "node.upsert":
+                    await runtime.upsertNode(entry.node);
+                    break;
+                case "actor.upsert":
+                    await runtime.upsertActor(entry.actor);
+                    break;
+                case "agent.upsert":
+                    await runtime.upsertAgent(entry.agent);
+                    break;
+                case "conversation.upsert":
+                    await runtime.upsertConversation(entry.conversation);
+                    break;
+                case "binding.upsert":
+                    await runtime.upsertBinding(entry.binding);
+                    break;
+                case "collaboration.record":
+                    await runtime.upsertCollaboration(entry.record);
+                    break;
+                case "collaboration.event.record":
+                    await runtime.appendCollaborationEvent(entry.event);
+                    break;
+                default:
+                    break;
             }
-            appliedBindingIds.add(binding.id);
-            await runtime.upsertBinding(binding);
-        }
-        if (bundle.collaborationRecord) {
-            await runtime.upsertCollaboration(bundle.collaborationRecord);
-        }
-        if (bundle.collaborationEvent) {
-            await runtime.appendCollaborationEvent(bundle.collaborationEvent);
         }
     }, options);
 }
@@ -1211,27 +1296,6 @@ async function forwardPeerBrokerCollaborationEvent(event) {
     }
     return { forwarded, failed };
 }
-async function maybeForwardInvocation(invocation) {
-    const targetAgent = runtime.agent(invocation.targetAgentId);
-    if (!targetAgent) {
-        throw new Error(`unknown agent ${invocation.targetAgentId}`);
-    }
-    if (targetAgent.authorityNodeId === nodeId) {
-        return { forwarded: false };
-    }
-    const authorityNode = runtime.node(targetAgent.authorityNodeId);
-    if (!authorityNode?.brokerUrl) {
-        throw new Error(`authority node ${targetAgent.authorityNodeId} is not reachable`);
-    }
-    const bundle = buildMeshInvocationBundle(runtime.peek(), currentLocalNode(), invocation);
-    const result = await forwardMeshInvocation(authorityNode.brokerUrl, bundle);
-    const { entries } = await recordInvocationDurably(invocation, {
-        flight: result.flight,
-        enqueueProjection: false,
-    });
-    projection.enqueueEntries(entries);
-    return { forwarded: true, flight: result.flight };
-}
 function parseLimit(url) {
     const limit = Number.parseInt(url.searchParams.get("limit") ?? "100", 10);
     if (!Number.isFinite(limit) || limit <= 0)
@@ -1346,23 +1410,20 @@ async function handleCommand(command) {
             return { ok: true, message: command.message, deliveries, mesh };
         }
         case "agent.invoke": {
-            const forwarded = await maybeForwardInvocation(command.invocation);
-            if (forwarded.forwarded) {
-                console.log(`[openscout-runtime] invocation ${command.invocation.id} forwarded to ${command.invocation.targetAgentId}`);
-                return { ok: true, flight: forwarded.flight, forwarded: true };
-            }
-            const { flight, entries } = await recordInvocationDurably(command.invocation, {
-                enqueueProjection: false,
+            const flight = await acceptInvocationDurably(command.invocation);
+            console.log(`[openscout-runtime] invocation ${command.invocation.id} accepted for ${command.invocation.targetAgentId} (state=${flight.state})`);
+            dispatchAcceptedInvocation(command.invocation).catch((error) => {
+                console.error(`[openscout-runtime] background dispatch failed for invocation ${command.invocation.id}:`, error);
             });
-            console.log(`[openscout-runtime] invocation ${command.invocation.id} -> ${command.invocation.targetAgentId} is ${flight.state}${flight.summary ? ` (${flight.summary})` : ""}`);
-            if (flight.state === "failed") {
-                await postInvocationStatusMessage(command.invocation, flight);
-            }
-            else {
-                launchLocalInvocation(command.invocation, flight);
-            }
-            projection.enqueueEntries(entries);
-            return { ok: true, flight };
+            return {
+                ok: true,
+                accepted: true,
+                invocationId: command.invocation.id,
+                flightId: flight.id,
+                targetAgentId: command.invocation.targetAgentId,
+                state: flight.state,
+                flight,
+            };
         }
         case "agent.ensure_awake":
             await runtime.dispatch(command);
@@ -1375,6 +1436,76 @@ async function handleCommand(command) {
         }
     }
 }
+async function acceptInvocationDurably(invocation) {
+    const { flight, entries } = await recordInvocationDurably(invocation, {
+        enqueueProjection: false,
+    });
+    projection.enqueueEntries(entries);
+    return flight;
+}
+async function dispatchAcceptedInvocation(invocation) {
+    const targetAgent = runtime.agent(invocation.targetAgentId);
+    if (!targetAgent) {
+        await failAcceptedInvocation(invocation, `unknown agent ${invocation.targetAgentId}`);
+        return;
+    }
+    const flight = runtime.flightForInvocation(invocation.id);
+    if (!flight) {
+        console.warn(`[openscout-runtime] dispatch skipped — flight missing for invocation ${invocation.id}`);
+        return;
+    }
+    if (targetAgent.authorityNodeId && targetAgent.authorityNodeId !== nodeId) {
+        // Cross-node: hand off to the outbox worker. Peer reachability is now a
+        // delivery concern (deferred ↔ accepted retries), not an HTTP error.
+        const authorityNode = runtime.node(targetAgent.authorityNodeId);
+        if (!authorityNode) {
+            await failAcceptedInvocation(invocation, `authority node ${targetAgent.authorityNodeId} is not reachable`);
+            return;
+        }
+        await peerDelivery.enqueue(invocation, authorityNode);
+        return;
+    }
+    // Local authority — run the normal launch path.
+    if (flight.state === "failed") {
+        await postInvocationStatusMessage(invocation, flight);
+    }
+    else {
+        launchLocalInvocation(invocation, flight);
+    }
+}
+async function failAcceptedInvocation(invocation, detail) {
+    const now = Date.now();
+    const existing = runtime.flightForInvocation(invocation.id);
+    const failed = {
+        id: existing?.id ?? createRuntimeId("flt"),
+        invocationId: invocation.id,
+        requesterId: invocation.requesterId,
+        targetAgentId: invocation.targetAgentId,
+        state: "failed",
+        startedAt: existing?.startedAt ?? now,
+        completedAt: now,
+        summary: detail,
+        error: detail,
+        metadata: invocation.metadata,
+    };
+    await recordFlightDurably(failed);
+    await postInvocationStatusMessage(invocation, failed);
+}
+const peerDelivery = createPeerDeliveryWorker({
+    journal,
+    snapshot: () => runtime.peek(),
+    localNode: currentLocalNode,
+    localNodeId: nodeId,
+    nodeFor: (id) => runtime.node(id),
+    agentFor: (id) => runtime.agent(id),
+    invocationFor: (id) => knownInvocations.get(id),
+    recordDelivery: recordDeliveryDurably,
+    updateDeliveryStatus: updateDeliveryStatusDurably,
+    recordDeliveryAttempt: recordDeliveryAttemptDurably,
+    recordFlight: recordFlightDurably,
+    failInvocation: failAcceptedInvocation,
+    emit: streamEvent,
+});
 async function routeRequest(request, response) {
     const method = request.method ?? "GET";
     const url = new URL(request.url ?? "/", `http://${request.headers.host ?? `${host}:${port}`}`);
@@ -1488,6 +1619,75 @@ async function routeRequest(request, response) {
         json(response, 200, runtime.snapshot().nodes);
         return;
     }
+    // Per-invocation snapshot — current state of the invocation, its flight,
+    // its deliveries, and any scout dispatch that fired for it. Callers use
+    // this to seed UI state before subscribing to the stream.
+    const invocationSnapshotMatch = method === "GET"
+        ? url.pathname.match(/^\/v1\/invocations\/([^/]+)$/)
+        : null;
+    if (invocationSnapshotMatch) {
+        const invocationId = decodeURIComponent(invocationSnapshotMatch[1] ?? "");
+        const flight = runtime.flightForInvocation(invocationId);
+        const deliveries = journal
+            .listDeliveries({ limit: 500 })
+            .filter((delivery) => delivery.invocationId === invocationId);
+        const dispatches = journal
+            .listScoutDispatches({ limit: 50 })
+            .filter((record) => record.invocationId === invocationId);
+        const invocation = knownInvocations.get(invocationId);
+        json(response, 200, {
+            invocationId,
+            invocation: invocation ?? null,
+            flight: flight ?? null,
+            deliveries,
+            dispatches,
+        });
+        return;
+    }
+    // Per-invocation SSE — initial snapshot frame, then every event whose
+    // payload references this invocation. Caller closes the stream when done.
+    const invocationStreamMatch = method === "GET"
+        ? url.pathname.match(/^\/v1\/invocations\/([^/]+)\/stream$/)
+        : null;
+    if (invocationStreamMatch) {
+        const invocationId = decodeURIComponent(invocationStreamMatch[1] ?? "");
+        response.writeHead(200, {
+            "content-type": "text/event-stream",
+            "cache-control": "no-cache, no-transform",
+            connection: "keep-alive",
+        });
+        const flight = runtime.flightForInvocation(invocationId);
+        const deliveries = journal
+            .listDeliveries({ limit: 500 })
+            .filter((delivery) => delivery.invocationId === invocationId);
+        const dispatches = journal
+            .listScoutDispatches({ limit: 50 })
+            .filter((record) => record.invocationId === invocationId);
+        const invocation = knownInvocations.get(invocationId);
+        response.write(`event: snapshot\ndata: ${JSON.stringify({
+            invocationId,
+            invocation: invocation ?? null,
+            flight: flight ?? null,
+            deliveries,
+            dispatches,
+        })}\n\n`);
+        let subscribers = invocationStreamClients.get(invocationId);
+        if (!subscribers) {
+            subscribers = new Set();
+            invocationStreamClients.set(invocationId, subscribers);
+        }
+        subscribers.add(response);
+        request.on("close", () => {
+            const set = invocationStreamClients.get(invocationId);
+            if (set) {
+                set.delete(response);
+                if (set.size === 0)
+                    invocationStreamClients.delete(invocationId);
+            }
+            response.end();
+        });
+        return;
+    }
     if (method === "GET" && url.pathname === "/v1/events/stream") {
         response.writeHead(200, {
             "content-type": "text/event-stream",
@@ -1817,9 +2017,38 @@ async function routeRequest(request, response) {
     }
     if (method === "POST" && url.pathname === "/v1/invocations") {
         try {
-            const invocation = await readRequestBody(request);
-            const result = await handleCommand({ kind: "agent.invoke", invocation });
-            json(response, 200, result);
+            const payload = await readRequestBody(request);
+            const resolved = resolveInvocationTarget(payload);
+            if (resolved.kind !== "resolved") {
+                const envelope = buildDispatchEnvelope(resolved, payload.targetLabel?.trim() || payload.targetAgentId || "", nodeId, runtime.snapshot(), { homeEndpointFor: homeEndpointForAgent });
+                const { record } = await recordScoutDispatchDurably(envelope, {
+                    invocationId: payload.id,
+                    conversationId: payload.conversationId,
+                    requesterId: payload.requesterId,
+                });
+                json(response, 202, {
+                    accepted: true,
+                    invocationId: payload.id,
+                    dispatch: record,
+                });
+                return;
+            }
+            const invocation = {
+                ...payload,
+                targetAgentId: resolved.agent.id,
+            };
+            const flight = await acceptInvocationDurably(invocation);
+            json(response, 202, {
+                accepted: true,
+                invocationId: invocation.id,
+                flightId: flight.id,
+                targetAgentId: invocation.targetAgentId,
+                state: flight.state,
+                flight,
+            });
+            dispatchAcceptedInvocation(invocation).catch((error) => {
+                console.error(`[openscout-runtime] background dispatch failed for invocation ${invocation.id}:`, error);
+            });
         }
         catch (error) {
             badRequest(response, error);
@@ -1828,6 +2057,24 @@ async function routeRequest(request, response) {
     }
     notFound(response);
 }
+function resolveInvocationTarget(payload) {
+    const snapshot = runtime.snapshot();
+    const directId = payload.targetAgentId?.trim();
+    if (directId) {
+        const agent = snapshot.agents[directId];
+        if (agent && !isStaleLocalAgent(agent)) {
+            return { kind: "resolved", agent };
+        }
+    }
+    const label = payload.targetLabel?.trim() || directId || "";
+    if (!label) {
+        return { kind: "unparseable", label: "" };
+    }
+    return resolveAgentLabel(snapshot, label, {
+        preferLocalNodeId: nodeId,
+        helpers: { isStale: isStaleLocalAgent },
+    });
+}
 const server = createServer((request, response) => {
     routeRequest(request, response).catch((error) => {
         json(response, 500, {
@@ -1838,7 +2085,11 @@ const server = createServer((request, response) => {
 });
 try {
     await listen(server);
-    console.log(`[openscout-runtime] broker listening on ${brokerUrl}`);
+    peerDelivery.start();
+    console.log(`[openscout-runtime] broker listening on ${host}:${port} (scope: ${advertiseScope}, url: ${brokerUrl})`);
+    if (advertiseScope === "mesh" && isLoopbackHost(host)) {
+        console.warn(`[openscout-runtime] WARNING: mesh scope bound to loopback ${host} — peers cannot reach this broker. Set OPENSCOUT_BROKER_HOST=0.0.0.0 or unset to use the mesh default.`);
+    }
     console.log(`[openscout-runtime] node ${nodeId} in mesh ${meshId}`);
     console.log(`[openscout-runtime] journal ${journalPath}`);
     console.log(`[openscout-runtime] sqlite ${sqliteDisabled ? "disabled" : dbPath}`);
@@ -1878,9 +2129,16 @@ if (Number.isFinite(discoveryIntervalMs) && discoveryIntervalMs > 0) {
 }
 for (const signal of ["SIGINT", "SIGTERM"]) {
     process.on(signal, () => {
+        peerDelivery.stop();
         for (const client of eventClients) {
             client.end();
         }
+        for (const subscribers of invocationStreamClients.values()) {
+            for (const client of subscribers) {
+                client.end();
+            }
+        }
+        invocationStreamClients.clear();
         projection.close();
         server.close(() => process.exit(0));
     });

package/dist/broker-journal.d.ts

@@ -1,4 +1,4 @@
-import type { ActorIdentity, AgentDefinition, AgentEndpoint, CollaborationEvent, CollaborationRecord, ConversationBinding, ConversationDefinition, DeliveryAttempt, DeliveryIntent, FlightRecord, InvocationRequest, MessageRecord, NodeDefinition } from "@openscout/protocol";
+import type { ActorIdentity, AgentDefinition, AgentEndpoint, CollaborationEvent, CollaborationRecord, ConversationBinding, ConversationDefinition, DeliveryAttempt, DeliveryIntent, FlightRecord, InvocationRequest, MessageRecord, NodeDefinition, ScoutDispatchRecord } from "@openscout/protocol";
 import { type RuntimeRegistrySnapshot } from "./registry.js";
 export type BrokerJournalEntry = {
     kind: "node.upsert";
@@ -46,6 +46,9 @@ export type BrokerJournalEntry = {
     metadata?: Record<string, unknown>;
     leaseOwner?: string | null;
     leaseExpiresAt?: number | null;
+} | {
+    kind: "scout.dispatch.record";
+    dispatch: ScoutDispatchRecord;
 };
 export declare class FileBackedBrokerJournal {
     private readonly filePath;
@@ -57,7 +60,7 @@ export declare class FileBackedBrokerJournal {
     readEntries(): Promise<BrokerJournalEntry[]>;
     replay(visitor: (entry: BrokerJournalEntry) => void | Promise<void>): Promise<void>;
     snapshot(): RuntimeRegistrySnapshot;
-    appendEntries(entriesInput: BrokerJournalEntry | BrokerJournalEntry[]): Promise<void>;
+    appendEntries(entriesInput: BrokerJournalEntry | BrokerJournalEntry[]): Promise<BrokerJournalEntry[]>;
     listCollaborationRecords(options?: {
         limit?: number;
         kind?: CollaborationRecord["kind"];
@@ -75,5 +78,13 @@ export declare class FileBackedBrokerJournal {
         limit?: number;
     }): DeliveryIntent[];
     listDeliveryAttempts(deliveryId: string): DeliveryAttempt[];
+    private rewriteEntries;
+    private selectEntriesToAppend;
+    private shouldAppendEntry;
+    private applyToSnapshot;
     private apply;
+    listScoutDispatches(options?: {
+        limit?: number;
+        askedLabel?: string;
+    }): ScoutDispatchRecord[];
 }