@ouro.bot/cli 0.1.0-alpha.741 → 0.1.0-alpha.743

package/dist/heart/daemon/daemon.js

@@ -615,10 +615,14 @@ class OuroDaemon {
     mailboxServer = null;
     socketIdentity = null;
     senseAutostartTimer = null;
+    externalEventReconcileTimer = null;
+    externalEventReconcileRunning = false;
     mailboxServerFactory;
     privateRuntimePolicyDeps;
     onStopCommandComplete;
     externalEventRoot;
+    privilegedEventSpoolRoot;
+    privilegedEventScanner;
     rsvpHabitRunner;
     nativeHabitRunner;
     nativeHabitMatch;
@@ -640,6 +644,8 @@ class OuroDaemon {
         this.privateRuntimePolicyDeps = options.privateRuntimePolicyDeps ?? {};
         this.onStopCommandComplete = options.onStopCommandComplete ?? null;
         this.externalEventRoot = options.externalEventRoot ?? null;
+        this.privilegedEventSpoolRoot = options.privilegedEventSpoolRoot ?? "/run/ouro-events";
+        this.privilegedEventScanner = options.privilegedEventScanner ?? router_1.scanPrivilegedEventSpool;
         this.rsvpHabitRunner = options.rsvpHabitRunner;
         this.nativeHabitRunner = options.nativeHabitRunner;
         this.nativeHabitMatch = options.nativeHabitMatch;
@@ -694,6 +700,7 @@ class OuroDaemon {
             agentName,
             agentRoot: path.join(this.bundlesRoot, `${agentName}.ouro`),
         })));
+        const externalEvents = (0, router_1.listExternalEventStatus)(this.externalEventRoot ?? (0, router_1.getExternalEventRoot)());
         const mailboxUrl = this.mailboxServer?.origin ?? "http://127.0.0.1:0";
         return {
             overview: {
@@ -714,6 +721,7 @@ class OuroDaemon {
             sync,
             agents,
             ...(providers.length > 0 ? { providers } : {}),
+            ...(externalEvents.length > 0 ? { externalEvents } : {}),
         };
     }
     overlaySchedulerHealth(healthChecks) {
@@ -801,6 +809,11 @@ class OuroDaemon {
         // (daemon manages multiple agents; agent identity must be set before loading MCP config)
         await this.orphanStartupDrain(this.socketPath);
         await this.openCommandSocket();
+        await this.reconcileExternalEvents();
+        this.externalEventReconcileTimer = setInterval(() => {
+            void this.reconcileExternalEvents();
+        }, 1_000);
+        this.externalEventReconcileTimer.unref?.();
         this.triggerAutoStartAgents();
         this.triggerAutoStartSensesWhenAgentsSettled();
         // Write all managed PIDs to disk so the next daemon can clean up
@@ -1105,6 +1118,10 @@ class OuroDaemon {
             clearTimeout(this.senseAutostartTimer);
             this.senseAutostartTimer = null;
         }
+        if (this.externalEventReconcileTimer) {
+            clearInterval(this.externalEventReconcileTimer);
+            this.externalEventReconcileTimer = null;
+        }
         const workerStopTasks = [Promise.resolve().then(() => this.processManager.stopAll())];
         if (this.senseManager) {
             workerStopTasks.push(Promise.resolve().then(() => this.senseManager.stopAll()));
@@ -1279,14 +1296,14 @@ class OuroDaemon {
             ],
         };
     }
-    buildExternalEventPrivateWakeCommand(command, receiptId) {
+    buildExternalEventPrivateWakeCommand(command, receiptId, generation, attemptCount) {
         return {
             kind: "private.wake",
             agent: command.agent,
             reason: `external event ${command.source}/${command.eventType}`,
             triggerSource: "external-event",
             budgetClass: "interactive",
-            idempotencyKey: `external-event:${command.agent}:${command.source}:${command.eventId}`,
+            idempotencyKey: `external-event:${command.agent}:${command.source}:${command.eventId}:generation:${generation}:attempt:${attemptCount}`,
             originRefs: [
                 { kind: "external-event", id: command.eventId, source: command.source, eventType: command.eventType },
                 { kind: "queue-receipt", id: receiptId },
@@ -1456,7 +1473,7 @@ class OuroDaemon {
             data: result,
         };
     }
-    buildPrivateRuntimeWorkerWakeMessage(command, decision) {
+    buildPrivateRuntimeWorkerWakeMessage(command, decision, externalEvent) {
         const awaitName = (0, await_private_wake_1.awaitNameFromPrivateWakeCommand)(command);
         if (awaitName) {
             return {
@@ -1483,13 +1500,13 @@ class OuroDaemon {
                 privateTurnDecision: decision,
             };
         }
-        return { type: "message", privateTurnDecision: decision };
+        return { type: "message", privateTurnDecision: decision, ...(externalEvent ? { externalEvent } : {}) };
     }
     queueExternalEventForPrivateRuntime(record) {
         const pendingDir = path.join(this.bundlesRoot, `${record.agent}.ouro`, "state", "pending", pending_1.PRIVATE_RUNTIME_PENDING.friendId, pending_1.PRIVATE_RUNTIME_PENDING.channel, pending_1.PRIVATE_RUNTIME_PENDING.key);
         const originKey = `${record.source}:${record.eventId}`;
         const parsedReceivedAt = Date.parse(record.receivedAt);
-        (0, pending_1.queuePendingMessage)(pendingDir, {
+        (0, pending_1.queuePendingMessageOnce)(pendingDir, {
             from: "ouro-external-event",
             friendId: "ouro-external-event",
             channel: "external-event",
@@ -1503,6 +1520,7 @@ class OuroDaemon {
             },
             obligationStatus: "pending",
             mode: "relay",
+            packetId: `external-event:${record.agent}:${record.source}:${record.eventId}:generation:${record.generation}:attempt:${record.attemptCount}`,
         });
         (0, runtime_1.emitNervesEvent)({
             component: "daemon",
@@ -1517,7 +1535,124 @@ class OuroDaemon {
             },
         });
     }
-    async handlePrivateRuntimeWake(command, beforeDispatch) {
+    externalEventRootPath() {
+        return this.externalEventRoot ?? (0, router_1.getExternalEventRoot)();
+    }
+    externalEventLease(record) {
+        /* v8 ignore next -- dispatcher calls this only with the record returned by claimExternalEvent @preserve */
+        if (!record.claimOwner)
+            throw new Error("External event dispatch requires a claimed receipt");
+        return {
+            schemaVersion: 1,
+            recordPath: record.recordPath,
+            agent: record.agent,
+            source: record.source,
+            eventId: record.eventId,
+            generation: record.generation,
+            observationRevision: record.observationRevision,
+            claimOwner: record.claimOwner,
+        };
+    }
+    async dispatchExternalEvents(records) {
+        const claimed = [];
+        try {
+            for (const record of records) {
+                const owner = `external-event:${record.agent}:${record.source}:${record.eventId}:generation:${record.generation}:attempt:${record.attemptCount + 1}`;
+                claimed.push((0, router_1.claimExternalEvent)(record.recordPath, { owner, expectedVersion: record.version, expectedGeneration: record.generation }));
+            }
+            const primary = claimed[0];
+            const [primaryLease, ...relatedEvents] = claimed.map((record) => this.externalEventLease(record));
+            const lease = { ...primaryLease, ...(relatedEvents.length > 0 ? { relatedEvents } : {}) };
+            const receipt = {
+                id: `external-event:${primary.agent}:${primary.source}:${primary.eventId}:generation:${primary.generation}:attempt:${primary.attemptCount}`,
+                queuedAt: primary.updatedAt,
+            };
+            const wake = await this.handlePrivateRuntimeWake(this.buildExternalEventPrivateWakeCommand({
+                kind: "external.event.submit",
+                agent: primary.agent,
+                source: primary.source,
+                eventType: primary.eventType,
+                eventId: primary.eventId,
+            }, receipt.id, primary.generation, primary.attemptCount), () => { for (const record of claimed)
+                this.queueExternalEventForPrivateRuntime(record); }, lease);
+            const denied = !wake.ok || wake.data?.decision?.executable === false;
+            if (denied)
+                throw new Error(wake.error ?? wake.message ?? /* v8 ignore next -- daemon wake responses always carry an error or message @preserve */ "external-event private turn was denied");
+            return { events: claimed, event: primary, receipt, wake };
+        }
+        catch (error) {
+            for (const record of claimed) {
+                const latest = (0, router_1.readExternalEventRecord)(record.recordPath);
+                if (latest.executionState === "running" && latest.claimOwner === record.claimOwner) {
+                    (0, router_1.failExternalEventAttempt)(latest.recordPath, {
+                        owner: record.claimOwner, expectedVersion: latest.version, expectedGeneration: latest.generation,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+            throw error;
+        }
+    }
+    dispatchExternalEvent(record) {
+        return this.dispatchExternalEvents([record]);
+    }
+    async reconcileExternalEvents() {
+        /* v8 ignore next -- re-entrancy guard is exercised only by overlapping real timer callbacks @preserve */
+        if (this.externalEventReconcileRunning)
+            return;
+        this.externalEventReconcileRunning = true;
+        try {
+            const now = new Date().toISOString();
+            if (fs.existsSync(this.privilegedEventSpoolRoot)) {
+                this.privilegedEventScanner({ spoolRoot: this.privilegedEventSpoolRoot, eventRoot: this.externalEventRootPath() });
+            }
+            const statuses = (0, router_1.listExternalEventStatus)(this.externalEventRootPath());
+            const dueRecords = [];
+            for (const status of statuses) {
+                if (status.corrupt)
+                    continue;
+                let record = (0, router_1.readExternalEventRecord)(status.recordPath);
+                if (record.dispatchEnabled === false)
+                    continue;
+                if (record.executionState === "running" && record.claimExpiresAt && Date.parse(record.claimExpiresAt) <= Date.parse(now)) {
+                    record = (0, router_1.reconcileExternalEvent)(record.recordPath);
+                }
+                const due = record.executionState === "received"
+                    || record.executionState === "queued"
+                    || (record.executionState === "retry_wait" && record.nextAttemptAt !== null && Date.parse(record.nextAttemptAt) <= Date.parse(now));
+                if (due)
+                    dueRecords.push(record);
+            }
+            const batches = new Map();
+            for (const record of dueRecords) {
+                const key = `${record.agent}\0${record.source}`;
+                const batch = batches.get(key) ?? [];
+                batch.push(record);
+                batches.set(key, batch);
+            }
+            for (const records of batches.values()) {
+                for (let offset = 0; offset < records.length; offset += 32) {
+                    const batch = records.slice(offset, offset + 32);
+                    try {
+                        await this.dispatchExternalEvents(batch);
+                    }
+                    catch (error) {
+                        (0, runtime_1.emitNervesEvent)({
+                            level: "warn",
+                            component: "daemon",
+                            event: "daemon.external_event_dispatch_error",
+                            message: "external event dispatch failed",
+                            meta: { recordPath: batch[0].recordPath, batchSize: batch.length, error: error instanceof Error ? error.message : /* v8 ignore next -- dispatch failures are Error objects @preserve */ String(error) },
+                        });
+                    }
+                }
+            }
+        }
+        finally {
+            this.externalEventReconcileRunning = false;
+        }
+    }
+    async handlePrivateRuntimeWake(command, beforeDispatch, externalEvent) {
         if (!this.hasManagedPrivateRuntime(command.agent)) {
             return {
                 ok: false,
@@ -1537,7 +1672,7 @@ class OuroDaemon {
         }
         await beforeDispatch?.(decision);
         await this.processManager.startAgent(command.agent);
-        this.processManager.sendToAgent?.(command.agent, this.buildPrivateRuntimeWorkerWakeMessage(command, decision));
+        this.processManager.sendToAgent?.(command.agent, this.buildPrivateRuntimeWorkerWakeMessage(command, decision, externalEvent));
         return {
             ok: true,
             message: `woke private runtime for ${command.agent}`,
@@ -1766,27 +1901,24 @@ class OuroDaemon {
                     evidence: command.evidence,
                     payloadPath: command.payloadPath,
                     priority: command.priority,
+                    observationRevision: command.observationRevision,
+                    transition: command.transition,
                 }, {
                     ...(this.externalEventRoot ? { root: this.externalEventRoot } : {}),
+                    dispatchEnabled: command.wake !== false,
                 });
-                const receipt = await this.router.send({
-                    from: "ouro-external-event",
-                    to: command.agent,
-                    content: (0, router_1.buildExternalEventMessage)(record),
-                    priority: record.priority,
-                    sessionId: command.sessionId,
-                    taskRef: command.taskRef ?? `${record.source}:${record.eventId}`,
-                });
-                let wake = null;
-                if (command.wake !== false) {
-                    wake = await this.handlePrivateRuntimeWake(this.buildExternalEventPrivateWakeCommand(command, receipt.id), () => this.queueExternalEventForPrivateRuntime(record));
+                if (!record.shouldWake || command.wake === false) {
+                    return {
+                        ok: true,
+                        message: `updated external event ${record.source}/${record.eventId} without wake`,
+                        data: { event: record, receipt: null, wake: null },
+                    };
                 }
+                const dispatched = await this.dispatchExternalEvent(record);
                 return {
                     ok: true,
-                    message: command.wake === false
-                        ? `queued external event ${record.source}/${record.eventId} as ${receipt.id}`
-                        : `queued external event ${record.source}/${record.eventId} as ${receipt.id}; ${wake?.message ?? "wake skipped"}`,
-                    data: { event: record, receipt, wake },
+                    message: `queued external event ${record.source}/${record.eventId} as ${dispatched.receipt.id}; ${dispatched.wake.message ?? "wake skipped"}`,
+                    data: dispatched,
                 };
             }
             case "private.decisions": {