@ouro.bot/cli 0.1.0-alpha.742 → 0.1.0-alpha.744

package/dist/heart/awaiting/await-parser.js

@@ -66,10 +66,14 @@ function emptyAwait(stem, body) {
         alert: null,
         mode: "full",
         max_age: null,
+        wake_at: null,
         status: "pending",
         created_at: null,
         filed_from: null,
         filed_for_friend_id: null,
+        filed_from_key: null,
+        request_id: null,
+        obligation_id: null,
         body,
         resolved_at: null,
         resolution_observation: null,
@@ -102,10 +106,14 @@ function parseAwaitFile(content, filePath) {
         alert: nonEmptyString(frontmatter.alert),
         mode,
         max_age: nonEmptyString(frontmatter.max_age),
+        wake_at: nonEmptyString(frontmatter.wake_at),
         status,
         created_at: nonEmptyString(frontmatter.created_at),
         filed_from: nonEmptyString(frontmatter.filed_from),
         filed_for_friend_id: nonEmptyString(frontmatter.filed_for_friend_id),
+        filed_from_key: nonEmptyString(frontmatter.filed_from_key),
+        request_id: nonEmptyString(frontmatter.request_id),
+        obligation_id: nonEmptyString(frontmatter.obligation_id),
         body,
         resolved_at: nonEmptyString(frontmatter.resolved_at),
         resolution_observation: nonEmptyString(frontmatter.resolution_observation),

package/dist/heart/core.js

@@ -962,6 +962,9 @@ async function runAgent(messages, callbacks, channel, signal, options) {
         try {
             const buildSystemOptions = {
                 ...options,
+                relationshipContextScopes: options?.toolContext?.relationshipAuthorization?.authorizedContextScopes,
+                relationshipProfileId: options?.toolContext?.relationshipAuthorization?.profileId,
+                relationshipToolNames: options?.toolContext?.relationshipAuthorization?.advertisedToolNames,
                 orientationFrame: turnOrientationFrame,
                 resumePriorWork: options?.resumePriorWork === true,
                 providerCapabilities: providerRuntime.capabilities,
@@ -1083,7 +1086,11 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     catch { /* unsupported */ }
     const toolPreferences = currentContext?.friend?.toolPreferences;
     const unboundBaseTools = options?.tools ?? (0, tools_1.getToolsForChannel)(channel ? (0, friends_1.getChannelCapabilities)(channel) : undefined, toolPreferences && Object.keys(toolPreferences).length > 0 ? toolPreferences : undefined, currentContext, providerRuntime.capabilities, options?.mcpManager, providerRuntime.model);
-    const baseTools = bindCurrentIngressEvidenceLocator(unboundBaseTools, options?.toolContext?.currentIngressEvidence);
+    const relationshipToolNames = options?.toolContext?.relationshipAuthorization?.advertisedToolNames;
+    const relationshipScopedTools = relationshipToolNames
+        ? unboundBaseTools.filter((tool) => relationshipToolNames.includes(tool.function.name))
+        : unboundBaseTools;
+    const baseTools = bindCurrentIngressEvidenceLocator(relationshipScopedTools, options?.toolContext?.currentIngressEvidence);
     // Augment tool context with reasoning effort controls from provider
     const baseToolContext = options?.toolContext
         ?? (turnOrientationFrame ? { signin: async () => undefined, orientationFrame: turnOrientationFrame } : undefined);
@@ -1127,7 +1134,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
         const filteredBaseTools = isPrivateRuntimeChannel
             ? baseTools.filter((t) => privateRuntimeHabitCanSendMessage || t.function.name !== "send_message")
             : baseTools;
-        const ordinaryActiveTools = [
+        const unscopedOrdinaryActiveTools = [
             ...filteredBaseTools,
             ...(augmentedToolContext?.noSend === true ? [] : [tools_1.ponderTool]),
             ...(isPrivateRuntimeChannel && privateRuntimeHabitCanSurface ? [tools_2.surfaceToolDef] : []),
@@ -1136,6 +1143,9 @@ async function runAgent(messages, callbacks, channel, signal, options) {
             ...(!isPrivateRuntimeChannel ? [tools_1.settleTool] : []),
             ...(isChatStyleChannel(channel ?? "") ? [tools_1.speakTool] : []),
         ];
+        const ordinaryActiveTools = relationshipToolNames
+            ? unscopedOrdinaryActiveTools.filter((tool) => relationshipToolNames.includes(tool.function.name))
+            : unscopedOrdinaryActiveTools;
         const activeTools = options?.toolProfile === "sanctuary-health-private"
             ? (() => {
                 const sendTools = baseTools.filter((tool) => tool.function.name === "send_message");
@@ -1740,10 +1750,13 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     done = true;
                     continue;
                 }
-                const approvalCalls = options?.approvalCoordinator ? validCalls.map((entry) => ({
-                    ...entry,
-                    policy: (0, tools_1.approvalPolicyForToolName)(entry.call.name, entry.validated.arguments),
-                })) : [];
+                const approvalCalls = await Promise.all(validCalls.map(async (entry) => {
+                    const classification = await (0, tools_1.classifyApprovalForInvocation)(entry.call.name, entry.validated.arguments, augmentedToolContext);
+                    return {
+                        ...entry,
+                        ...classification,
+                    };
+                }));
                 const protectedCall = approvalCalls.find((entry) => entry.policy.kind === "required");
                 if (protectedCall && result.toolCalls.length !== 1) {
                     streamCallbackBuffer?.discard();
@@ -1763,6 +1776,21 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     continue;
                 }
                 if (protectedCall && protectedCall.policy.kind === "required") {
+                    if (!options?.approvalCoordinator) {
+                        streamCallbackBuffer?.discard();
+                        pushGenerated(msg);
+                        const rejection = "rejected: this protected tool requires approval, but the approval coordinator is unavailable; the handler was not invoked.";
+                        pushGenerated({ role: "tool", tool_call_id: protectedCall.call.id, content: rejection });
+                        providerRuntime.appendToolOutput(protectedCall.call.id, rejection);
+                        (0, runtime_1.emitNervesEvent)({
+                            level: "warn",
+                            component: "engine",
+                            event: "engine.approval_coordinator_unavailable",
+                            message: "protected tool failed closed before handler execution",
+                            meta: { toolName: protectedCall.call.name, toolCallId: protectedCall.call.id },
+                        });
+                        continue;
+                    }
                     streamCallbackBuffer?.discard();
                     pushGenerated(msg);
                     const toolDigest = (0, tool_arguments_1.digestJson)({
@@ -2078,7 +2106,9 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     let success;
                     try {
                         const execToolFn = options?.execTool ?? tools_1.execTool;
-                        toolResult = await execToolFn(tc.name, args, augmentedToolContext);
+                        const routineActionSelection = approvalCalls.find((entry) => entry.call.id === tc.id)?.routineActionSelection;
+                        const executionToolContext = routineActionSelection && augmentedToolContext ? { ...augmentedToolContext, routineActionSelection } : augmentedToolContext;
+                        toolResult = await execToolFn(tc.name, args, executionToolContext);
                         success = true;
                     }
                     catch (e) {

package/dist/heart/cross-chat-delivery.js

@@ -10,6 +10,7 @@ function buildPendingEnvelope(request, agentName, now) {
         channel: request.channel,
         key: request.key,
         content: request.content,
+        ...(request.requestId ? { requestId: request.requestId } : {}),
         timestamp: now,
     };
 }

package/dist/heart/daemon/container-spec-auditor-main.js

@@ -71,8 +71,11 @@ function runContainerSpecAuditorCli(args, deps = {}) {
     const write = deps.write ?? ((text) => process.stdout.write(text));
     const staged = parseModeArguments(args, ["--template", "--runtime-policy", "--expected-image"]);
     const effective = parseModeArguments(args, ["--inspect", "--image-inspect", "--expected-image"]);
-    if (!staged && !effective) {
-        write(JSON.stringify({ ok: false, error: "usage: staged --template <path> --runtime-policy <path> --expected-image <id>; effective --inspect <path> --image-inspect <path> --expected-image <id>" }) + "\n");
+    const legacyCandidate = parseModeArguments(args, ["--inspect", "--image-inspect", "--expected-image", "--mount-contract"]);
+    const legacyEffective = legacyCandidate?.["--mount-contract"] === "legacy-alpha742" ? legacyCandidate : null;
+    const selectedEffective = effective ?? legacyEffective;
+    if (!staged && !selectedEffective) {
+        write(JSON.stringify({ ok: false, error: "usage: staged --template <path> --runtime-policy <path> --expected-image <id>; effective --inspect <path> --image-inspect <path> --expected-image <id> [--mount-contract legacy-alpha742]" }) + "\n");
         (0, runtime_1.emitNervesEvent)({
             level: "error",
             component: "daemon",
@@ -82,12 +85,12 @@ function runContainerSpecAuditorCli(args, deps = {}) {
         });
         return 2;
     }
-    if (effective) {
+    if (selectedEffective) {
         let containerText;
         let imageText;
         try {
-            containerText = readFile(effective["--inspect"]);
-            imageText = readFile(effective["--image-inspect"]);
+            containerText = readFile(selectedEffective["--inspect"]);
+            imageText = readFile(selectedEffective["--image-inspect"]);
         }
         catch (error) {
             write(JSON.stringify({ ok: false, error: "effective audit inputs are unreadable" }) + "\n");
@@ -118,10 +121,11 @@ function runContainerSpecAuditorCli(args, deps = {}) {
             return 2;
         }
         const result = (0, container_spec_auditor_1.auditSanctuaryContainerSpec)(containerInspect, {
-            expectedImage: effective["--expected-image"],
+            expectedImage: selectedEffective["--expected-image"],
             expectedEnvironment,
+            mountContract: legacyEffective ? "legacy-alpha742" : "canonical",
         });
-        if (imageInspect.Id !== effective["--expected-image"]) {
+        if (imageInspect.Id !== selectedEffective["--expected-image"]) {
             result.ok = false;
             result.violations.unshift("reviewed image inspect identity does not match the expected local image ID");
         }

package/dist/heart/daemon/container-spec-auditor.js

@@ -6,11 +6,18 @@ const runtime_1 = require("../../nerves/runtime");
 const EXPECTED_BINDS = [
     "/mnt/user/appdata/ouro-butler/runtime/.ouro-cli:/home/ouro/.ouro-cli:rw",
     "/mnt/user/appdata/ouro-butler/agent/sanctuary.ouro:/home/ouro/AgentBundles/sanctuary.ouro:rw",
+    "/boot/config/custom/ouro-events/spool:/run/ouro-events:ro",
+    "/mnt/user/appdata/sabnzbd/sabnzbd.ini:/run/sanctuary/sabnzbd.ini:ro",
 ];
 const EXPECTED_MOUNTS = [
-    ["/mnt/user/appdata/ouro-butler/runtime/.ouro-cli", "/home/ouro/.ouro-cli"],
-    ["/mnt/user/appdata/ouro-butler/agent/sanctuary.ouro", "/home/ouro/AgentBundles/sanctuary.ouro"],
+    ["/mnt/user/appdata/ouro-butler/runtime/.ouro-cli", "/home/ouro/.ouro-cli", true],
+    ["/mnt/user/appdata/ouro-butler/agent/sanctuary.ouro", "/home/ouro/AgentBundles/sanctuary.ouro", true],
+    ["/boot/config/custom/ouro-events/spool", "/run/ouro-events", false],
+    ["/mnt/user/appdata/sabnzbd/sabnzbd.ini", "/run/sanctuary/sabnzbd.ini", false],
 ];
+const LEGACY_ALPHA742_IMAGE = "sha256:681449ad47a2621705cd339b481e6339236b31dc65e195b1cf5025d0f2191d7d";
+const LEGACY_ALPHA742_BINDS = EXPECTED_BINDS.slice(0, 2);
+const LEGACY_ALPHA742_MOUNTS = EXPECTED_MOUNTS.slice(0, 2);
 const EXPECTED_EXTRA_PARAMS = "--restart=unless-stopped --user=10001:10001";
 function record(value) {
     return value && typeof value === "object" && !Array.isArray(value)
@@ -29,12 +36,18 @@ function auditSanctuaryContainerSpec(value, options) {
     const root = record(value);
     const config = record(root?.Config);
     const host = record(root?.HostConfig);
+    const network = record(root?.NetworkSettings);
     if (!root || !config || !host) {
         violations.push("inspect payload must contain object Config and HostConfig records");
     }
     else {
         if (!/^sha256:[a-f0-9]{64}$/u.test(options.expectedImage))
             violations.push("expected image must be an exact local Docker image ID");
+        const mountContract = options.mountContract ?? "canonical";
+        if (mountContract === "legacy-alpha742" && options.expectedImage !== LEGACY_ALPHA742_IMAGE)
+            violations.push("legacy mount exception requires the pinned alpha.742 image ID");
+        const expectedBinds = mountContract === "legacy-alpha742" ? LEGACY_ALPHA742_BINDS : EXPECTED_BINDS;
+        const expectedMounts = mountContract === "legacy-alpha742" ? LEGACY_ALPHA742_MOUNTS : EXPECTED_MOUNTS;
         if (config.Image !== options.expectedImage)
             violations.push("image does not match the reviewed exact local Docker image ID");
         if (root.Path !== "node")
@@ -54,8 +67,16 @@ function auditSanctuaryContainerSpec(value, options) {
             violations.push("container must expose no ports");
         if (host.NetworkMode !== "host")
             violations.push("network mode must be host");
+        if (host.PidMode !== "")
+            violations.push("PID namespace must be private");
+        if (host.IpcMode !== "private")
+            violations.push("IPC namespace must be private");
         if (host.Privileged !== false)
             violations.push("container must not be privileged");
+        if (host.ReadonlyRootfs !== false)
+            violations.push("root filesystem mode must match the reviewed runtime");
+        if (!(host.SecurityOpt === null || (Array.isArray(host.SecurityOpt) && host.SecurityOpt.length === 0)))
+            violations.push("container must set no security options");
         const restart = record(host.RestartPolicy);
         if (restart?.Name !== "unless-stopped" || restart.MaximumRetryCount !== 0)
             violations.push("restart policy must be unless-stopped");
@@ -65,19 +86,25 @@ function auditSanctuaryContainerSpec(value, options) {
             violations.push("container must have no devices");
         if (!(host.CapAdd === null || (Array.isArray(host.CapAdd) && host.CapAdd.length === 0)))
             violations.push("container must add no capabilities");
+        if (!(host.CapDrop === null || (Array.isArray(host.CapDrop) && host.CapDrop.length === 0)))
+            violations.push("container must drop no capabilities");
+        if (host.PublishAllPorts !== false)
+            violations.push("container must not publish all exposed ports");
+        if (!isEmptyRecord(network?.Ports))
+            violations.push("effective network ports must be empty");
         const binds = stringArray(host.Binds);
-        if (!binds || JSON.stringify([...binds].sort()) !== JSON.stringify([...EXPECTED_BINDS].sort()))
-            violations.push("bind set must equal the canonical two writable roots");
+        if (!binds || JSON.stringify([...binds].sort()) !== JSON.stringify([...expectedBinds].sort()))
+            violations.push("bind set does not match the selected Sanctuary mount contract");
         const mounts = Array.isArray(root.Mounts) ? root.Mounts : [];
         const normalizedMounts = mounts.map((mount) => {
             const item = record(mount);
-            return item && item.Type === "bind" && item.RW === true && typeof item.Source === "string" && typeof item.Destination === "string"
-                ? [item.Source, item.Destination]
+            return item && item.Type === "bind" && typeof item.RW === "boolean" && typeof item.Source === "string" && typeof item.Destination === "string"
+                ? [item.Source, item.Destination, item.RW]
                 : null;
         });
         if (normalizedMounts.some((mount) => mount === null)
-            || JSON.stringify(normalizedMounts.sort()) !== JSON.stringify(EXPECTED_MOUNTS.map((mount) => [...mount]).sort())) {
-            violations.push("effective mounts must equal the canonical two writable bind mounts");
+            || JSON.stringify(normalizedMounts.sort()) !== JSON.stringify(expectedMounts.map((mount) => [...mount]).sort())) {
+            violations.push("effective mounts do not match the selected Sanctuary mount contract");
         }
     }
     const result = { ok: violations.length === 0, violations };
@@ -130,10 +157,10 @@ function auditSanctuaryStagedFiles(input) {
         const mode = match[1].match(/\bMode="([^"]+)"/u)?.[1];
         return type === "Path" && target && mode ? `${match[2]}:${target}:${mode}` : "invalid";
     });
-    if (configOpenCount !== 2
-        || configEntries.length !== 2
+    if (configOpenCount !== 4
+        || configEntries.length !== 4
         || JSON.stringify([...pathConfigs].sort()) !== JSON.stringify([...EXPECTED_BINDS].sort())) {
-        violations.push("template Config entries must equal the canonical two path binds");
+        violations.push("template Config entries must equal the canonical four path binds");
     }
     const postArgsOpenCount = [...input.templateXml.matchAll(/<PostArgs\b/gu)].length;
     const postArgs = [...input.templateXml.matchAll(/<PostArgs(?:(?:\s*\/>)|>([^<]*)<\/PostArgs>)/gu)];

package/dist/heart/daemon/daemon-entry.js

@@ -412,12 +412,20 @@ const daemon = new daemon_1.OuroDaemon({
         const before = schedulerScenario ? (0, sanctuary_scheduler_liveness_1.readSanctuaryHealthCursor)(agentRoot) : null;
         let providerInvocationCount = 0;
         let privateTurnCount = 0;
-        const result = await (0, sanctuary_health_runner_1.runSanctuaryHealthHabit)(agent, schedulerScenario ? {
-            acceptanceMetrics: {
-                onPrivateTurnStart: () => { privateTurnCount += 1; },
-                onProviderInvocation: () => { providerInvocationCount += 1; },
+        const result = await (0, sanctuary_health_runner_1.runSanctuaryHealthHabit)(agent, {
+            submitEvidence: async (input) => {
+                const response = await daemon.handleCommand({ kind: "external.event.submit", ...input });
+                if (!response.ok)
+                    throw new Error(response.error ?? "Sanctuary health evidence submission failed");
+                return response.data.event;
             },
-        } : {});
+            ...(schedulerScenario ? {
+                acceptanceMetrics: {
+                    onPrivateTurnStart: () => { privateTurnCount += 1; },
+                    onProviderInvocation: () => { providerInvocationCount += 1; },
+                },
+            } : {}),
+        });
         if (schedulerScenario) {
             if (!supercronicSupervisor || !before || !occurrenceId || !schedulerOrigin)
                 throw new Error("Sanctuary scheduler liveness supervisor provenance is unavailable");
@@ -834,6 +842,12 @@ void (0, daemon_bootstrap_startup_1.startDaemonAfterContainerCredentialBootstrap
                         awaitName,
                         deliveryDeps: {
                             agentName: agent,
+                            deliverers: {
+                                telegram: async (request) => {
+                                    const { sendTelegramAwaitFollowUp } = await Promise.resolve().then(() => __importStar(require("../../senses/telegram")));
+                                    return sendTelegramAwaitFollowUp(agent, request);
+                                },
+                            },
                             queuePending: () => {
                                 // Best-effort: queue private-runtime wake so the agent processes the alert path.
                                 (0, socket_client_1.sendDaemonCommand)(socketPath, (0, await_private_wake_1.buildAwaitPrivateWakeCommand)({

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": {