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

package/dist/repertoire/tools.js

@@ -2,9 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.surfaceToolDef = exports.speakTool = exports.restTool = exports.ponderTool = exports.observeTool = exports.settleTool = exports.tools = void 0;
 exports.resetMcpDefinitions = resetMcpDefinitions;
+exports.getSanctuaryRelationshipTools = getSanctuaryRelationshipTools;
 exports.getToolsForChannel = getToolsForChannel;
 exports.resolveToolDefinition = resolveToolDefinition;
 exports.approvalPolicyForToolName = approvalPolicyForToolName;
+exports.classifyApprovalForInvocation = classifyApprovalForInvocation;
+exports.approvalPolicyForInvocation = approvalPolicyForInvocation;
 exports.shellRiskProfile = shellRiskProfile;
 exports.riskProfileForTool = riskProfileForTool;
 exports.riskProfileForToolName = riskProfileForToolName;
@@ -27,6 +30,8 @@ const tools_voice_1 = require("./tools-voice");
 const shell_sessions_1 = require("./shell-sessions");
 const tools_unraid_1 = require("./tools-unraid");
 const tools_flow_1 = require("./tools-flow");
+const tools_steward_policy_1 = require("./tools-steward-policy");
+const steward_policy_1 = require("../heart/steward-policy");
 function safeGetAgentRoot() {
     try {
         return (0, identity_1.getAgentRoot)();
@@ -43,6 +48,33 @@ function isSanctuaryAgent() {
         return false;
     }
 }
+const SANCTUARY_RELATIONSHIP_BASE_TOOLS = new Set([
+    "external_event_disposition",
+    "query_active_work",
+    "save_friend_note",
+    "telegram_contact_manage",
+    "query_cares",
+    "care_manage",
+    "await_condition",
+    "resolve_await",
+    "cancel_await",
+    "send_message",
+]);
+const SANCTUARY_TELEGRAM_SURFACE = new Set([
+    "query_active_work",
+    "save_friend_note",
+    "telegram_contact_manage",
+    "query_cares",
+    "care_manage",
+    "await_condition",
+    "resolve_await",
+    "cancel_await",
+    ...tools_unraid_1.unraidToolDefinitions.map((definition) => definition.tool.function.name),
+    "steward_policy_manage",
+    "ponder",
+    "settle",
+    "speak",
+]);
 // Re-export types and constants used by the rest of the codebase
 var tools_base_2 = require("./tools-base");
 Object.defineProperty(exports, "tools", { enumerable: true, get: function () { return tools_base_2.tools; } });
@@ -55,7 +87,7 @@ Object.defineProperty(exports, "speakTool", { enumerable: true, get: function ()
 var tools_surface_2 = require("./tools-surface");
 Object.defineProperty(exports, "surfaceToolDef", { enumerable: true, get: function () { return tools_surface_2.surfaceToolDef; } });
 // All tool definitions in a single registry
-const allDefinitions = [...tools_base_1.baseToolDefinitions, ...tools_bluebubbles_1.bluebubblesToolDefinitions, ...tools_teams_1.teamsToolDefinitions, ...ado_semantic_1.adoSemanticToolDefinitions, ...tools_github_1.githubToolDefinitions, ...tools_bundle_1.bundleToolDefinitions, ...tools_voice_1.voiceToolDefinitions, ...tools_unraid_1.unraidToolDefinitions, tools_surface_1.surfaceToolDefinition];
+const allDefinitions = [...tools_base_1.baseToolDefinitions, ...tools_bluebubbles_1.bluebubblesToolDefinitions, ...tools_teams_1.teamsToolDefinitions, ...ado_semantic_1.adoSemanticToolDefinitions, ...tools_github_1.githubToolDefinitions, ...tools_bundle_1.bundleToolDefinitions, ...tools_voice_1.voiceToolDefinitions, ...tools_unraid_1.unraidToolDefinitions, tools_steward_policy_1.stewardPolicyToolDefinition, tools_surface_1.surfaceToolDefinition];
 const COMMERCE_AUTHORITY_TOOLS = new Set(["stripe_create_card", "flight_hold", "flight_book"]);
 // MCP tool definitions — populated each time getToolsForChannel() is called with an mcpManager.
 // Kept separate from allDefinitions so execTool can find them.
@@ -68,6 +100,32 @@ function baseToolsForCapabilities() {
     // Use baseToolDefinitions at call time so dynamically-added tools are included
     return tools_base_1.baseToolDefinitions.map((d) => d.tool);
 }
+function uniqueToolSchemas(tools) {
+    const seen = new Set();
+    return tools.filter((tool) => {
+        if (seen.has(tool.function.name))
+            return false;
+        seen.add(tool.function.name);
+        return true;
+    });
+}
+/**
+ * Resolve Sanctuary relationship tools from one canonical definition pool.
+ * Durable relationship profiles can only reduce this surface; they cannot
+ * introduce an arbitrary base tool by naming it in configuration.
+ */
+function getSanctuaryRelationshipTools(advertisedToolNames) {
+    const advertised = new Set(advertisedToolNames);
+    return uniqueToolSchemas([
+        ...tools_base_1.baseToolDefinitions.filter((definition) => SANCTUARY_RELATIONSHIP_BASE_TOOLS.has(definition.tool.function.name)).map((definition) => definition.tool),
+        ...tools_unraid_1.unraidToolDefinitions.map((definition) => definition.tool),
+        tools_steward_policy_1.stewardPolicyToolDefinition.tool,
+        tools_flow_1.ponderTool,
+        tools_flow_1.restTool,
+        tools_flow_1.settleTool,
+        tools_flow_1.speakTool,
+    ]).filter((tool) => advertised.has(tool.function.name));
+}
 // Apply a single tool preference to a tool schema, returning a new object.
 function applyPreference(tool, pref) {
     return {
@@ -96,12 +154,7 @@ function filterByCapability(toolList, providerCapabilities) {
 // When providerCapabilities is provided, tools with requiredCapability are filtered.
 function getToolsForChannel(capabilities, toolPreferences, _context, providerCapabilities, mcpManager, _chatModel) {
     if (capabilities?.channel === "telegram" && isSanctuaryAgent()) {
-        return [
-            ...tools_unraid_1.unraidToolDefinitions.map((definition) => definition.tool),
-            tools_flow_1.ponderTool,
-            tools_flow_1.settleTool,
-            tools_flow_1.speakTool,
-        ];
+        return getSanctuaryRelationshipTools([...SANCTUARY_TELEGRAM_SURFACE]);
     }
     const baseTools = baseToolsForCapabilities();
     const bluebubblesTools = capabilities?.channel === "bluebubbles"
@@ -156,6 +209,36 @@ function resolveToolDefinition(toolName) {
 function approvalPolicyForToolName(name, args) {
     return resolveToolDefinition(name)?.approvalPolicy?.(args) ?? { kind: "not_required" };
 }
+async function routineActionInvocation(name, args, ctx) {
+    const target = typeof args.container === "string" ? args.container : "";
+    if (name !== "unraid_restart_container" || !ctx?.agentRoot || !(0, tools_base_1.routineActionRequester)(ctx) || !target)
+        return null;
+    const relationshipAuthorization = ctx.relationshipAuthorization;
+    if (!relationshipAuthorization)
+        return null;
+    let authorization;
+    try {
+        authorization = await relationshipAuthorization.authorizeTool(name, args);
+    }
+    catch {
+        return null;
+    }
+    if (!authorization.allowed || !Number.isInteger(authorization.profileVersion) || Number(authorization.profileVersion) < 1)
+        return null;
+    const key = `unraid.restart:${target}`;
+    const decision = (0, steward_policy_1.inspectRoutineActionGrant)(ctx.agentRoot, { key, action: "unraid.container.restart", target });
+    return decision.allowed ? { key, target, expectedPolicyVersion: decision.policyVersion } : null;
+}
+async function classifyApprovalForInvocation(name, args, ctx) {
+    const fallback = approvalPolicyForToolName(name, args);
+    if (name !== "unraid_restart_container" || fallback.kind !== "required")
+        return { policy: fallback };
+    const routineActionSelection = await routineActionInvocation(name, args, ctx);
+    return routineActionSelection ? { policy: { kind: "not_required" }, routineActionSelection } : { policy: fallback };
+}
+async function approvalPolicyForInvocation(name, args, ctx) {
+    return (await classifyApprovalForInvocation(name, args, ctx)).policy;
+}
 const findDefinition = resolveToolDefinition;
 function normalizeGuardArgs(_name, args) {
     return args;
@@ -267,6 +350,17 @@ async function execTool(name, args, ctx) {
         });
         return `unknown: ${name}`;
     }
+    const relationshipDecision = await ctx?.relationshipAuthorization?.authorizeTool(name, args);
+    if (relationshipDecision && !relationshipDecision.allowed) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            event: "tool.relationship_authorization_block",
+            component: "tools",
+            message: "relationship authorization blocked tool execution",
+            meta: { name, reason: relationshipDecision.reason },
+        });
+        return `relationship authorization required: ${relationshipDecision.reason}`;
+    }
     const riskProfile = riskProfileForTool(def, name, args);
     const orientationPolicy = ctx?.orientationFrame?.actionPolicy;
     if (orientationPolicy?.mode === "correction_hold"
@@ -323,16 +417,17 @@ async function execTool(name, args, ctx) {
         });
         return `commerce authority required: ${commerceReservation.reason}`;
     }
+    const authorizedContext = ctx;
     const toolContext = commerceReservation?.ok
         ? {
-            ...ctx,
+            ...authorizedContext,
             agentRoot: guardContext.agentRoot,
             commerceAuthority: {
                 checkoutId: commerceReservation.checkoutId,
                 reservationToken: commerceReservation.reservationToken,
             },
         }
-        : ctx;
+        : authorizedContext;
     try {
         const result = await def.handler(args, toolContext);
         (0, runtime_1.emitNervesEvent)({

package/dist/repertoire/unraid-restart.js

@@ -8,6 +8,12 @@ const unraid_client_1 = require("./unraid-client");
 exports.SANCTUARY_RESTART_MUTATION = `mutation SanctuaryRestart($id: PrefixedID!) {
   docker { restart(id: $id) { id names state status autoStart } }
 }`;
+class RoutineActionReceiptError extends Error {
+    constructor(cause) {
+        super("routine action receipt persistence failed", { cause });
+        this.name = "RoutineActionReceiptError";
+    }
+}
 function failure(code, message) {
     return { ok: false, error: { code, message, degraded: true } };
 }
@@ -40,7 +46,15 @@ function createApprovedUnraidRestartExecutor(options) {
     const sleep = options.sleep ?? ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)));
     const now = options.now ?? (() => new Date());
     const observationTimeoutMs = options.observationTimeoutMs ?? 30_000;
-    return async (args) => {
+    const transitionRoutine = (input) => {
+        try {
+            options.transitionRoutineAction?.(input);
+        }
+        catch (error) {
+            throw new RoutineActionReceiptError(error);
+        }
+    };
+    return async (args, execution) => {
         if (!validArgument(args.container))
             return failure("invalid_response", "container must be one bounded exact name");
         const resolved = exactTarget(await options.listContainers(), args.container);
@@ -51,6 +65,22 @@ function createApprovedUnraidRestartExecutor(options) {
             return fresh;
         if (fresh.id !== resolved.id)
             return failure("stale_target", "container identity changed before restart");
+        let routineAuthorization = null;
+        if (execution?.routine) {
+            let authorization;
+            try {
+                authorization = await execution.routine.reauthorize();
+            }
+            catch {
+                return failure("stale_target", "routine relationship authorization is unavailable");
+            }
+            if (!authorization.allowed)
+                return failure("stale_target", authorization.reason);
+            if (!authorization.receiptId.trim() || !Number.isInteger(authorization.profileVersion) || authorization.profileVersion < 1) {
+                return failure("stale_target", "routine relationship authorization is not versioned");
+            }
+            routineAuthorization = { receiptId: authorization.receiptId, profileVersion: authorization.profileVersion };
+        }
         const scenarioHandleDigest = options.acceptanceScenarioHandleDigest?.();
         const approval = options.acceptanceApproval?.();
         const attempt = {
@@ -65,13 +95,44 @@ function createApprovedUnraidRestartExecutor(options) {
             mutationAcknowledged: false,
             afterState: null,
         };
+        let routineReceipt = null;
+        let routineState = null;
+        if (execution?.routine) {
+            if (!options.reserveRoutineAction || !options.transitionRoutineAction)
+                return failure("invalid_response", "routine action ledger is unavailable");
+            try {
+                routineReceipt = options.reserveRoutineAction({
+                    key: execution.routine.key,
+                    expectedPolicyVersion: execution.routine.expectedPolicyVersion,
+                    authorizationReceiptId: routineAuthorization.receiptId,
+                    authorizationVersion: routineAuthorization.profileVersion,
+                    action: "unraid.container.restart",
+                    target: fresh.name,
+                    attemptId: attempt.attemptId,
+                    expectedBeforeState: fresh.state,
+                    resolvedTarget: { id: fresh.id, name: fresh.name },
+                    effect: { operation: "restart", targetId: fresh.id },
+                });
+                routineState = "reserved";
+            }
+            catch (error) {
+                return failure("stale_target", error instanceof Error ? error.message : "routine action authority changed");
+            }
+        }
         if (approval && approval.argumentDigest !== attempt.argumentDigest)
             return failure("stale_target", "approval arguments changed before restart");
         await options.persistAttempt?.({ ...attempt, observedAt: now().toISOString(), state: "attempt_not_started" });
         const apiKey = await options.loadWriteApiKey();
-        if (!apiKey.trim())
+        if (!apiKey.trim()) {
+            if (routineReceipt && routineState === "reserved")
+                transitionRoutine({ id: routineReceipt.id, expectedState: "reserved", state: "failed", recoveryState: { state: "completed", compensation: "none" } });
             return failure("invalid_response", "Unraid write credential is unavailable");
+        }
         const client = createClient({ endpoint: options.endpoint, apiKey });
+        if (routineReceipt && routineState === "reserved") {
+            transitionRoutine({ id: routineReceipt.id, expectedState: "reserved", state: "attempting" });
+            routineState = "attempting";
+        }
         await options.persistAttempt?.({ ...attempt, observedAt: now().toISOString(), state: "attempting" });
         (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.unraid_restart_start", message: "approved Unraid restart started", meta: { containerId: fresh.id, containerName: fresh.name } });
         const persistTerminal = async (terminal) => {
@@ -85,8 +146,9 @@ function createApprovedUnraidRestartExecutor(options) {
             }
         };
         let acknowledged = false;
+        let mutation = null;
         try {
-            const mutation = await client.mutate(exports.SANCTUARY_RESTART_MUTATION, { id: fresh.id });
+            mutation = await client.mutate(exports.SANCTUARY_RESTART_MUTATION, { id: fresh.id });
             acknowledged = acknowledgedIdentity(mutation, fresh);
             if (!acknowledged)
                 throw new Error("restart response identity was invalid");
@@ -94,6 +156,10 @@ function createApprovedUnraidRestartExecutor(options) {
         catch {
             acknowledged = false;
         }
+        if (acknowledged && mutation && routineReceipt && routineState === "attempting") {
+            transitionRoutine({ id: routineReceipt.id, expectedState: "attempting", state: "effect_acknowledged", effectReceipt: (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(mutation)).digest("hex") });
+            routineState = "effect_acknowledged";
+        }
         const startedAt = now().getTime();
         let sawRestarting = false;
         try {
@@ -102,6 +168,8 @@ function createApprovedUnraidRestartExecutor(options) {
                 if (!("ok" in observed)) {
                     if (observed.id !== fresh.id) {
                         await persistTerminal({ ...attempt, observedAt: now().toISOString(), state: "attempted_or_indeterminate", mutationAcknowledged: acknowledged });
+                        if (routineReceipt && routineState)
+                            transitionRoutine({ id: routineReceipt.id, expectedState: routineState, state: "indeterminate", recoveryState: { state: "manual_inspection_required", compensation: "none" } });
                         return failure("ambiguous", "container identity changed after restart attempt");
                     }
                     sawRestarting ||= observed.state === "restarting";
@@ -109,6 +177,14 @@ function createApprovedUnraidRestartExecutor(options) {
                         if (!await persistTerminal({ ...attempt, observedAt: now().toISOString(), state: "succeeded", mutationAcknowledged: acknowledged, afterState: observed.state })) {
                             return failure("ambiguous", "restart succeeded but its terminal receipt could not be persisted; it was not retried");
                         }
+                        if (routineReceipt && routineState === "attempting") {
+                            transitionRoutine({ id: routineReceipt.id, expectedState: "attempting", state: "effect_acknowledged", effectReceipt: (0, node_crypto_1.createHash)("sha256").update(JSON.stringify({ observation: "restarting", target: fresh.id })).digest("hex") });
+                            routineState = "effect_acknowledged";
+                        }
+                        if (routineReceipt && routineState === "effect_acknowledged") {
+                            transitionRoutine({ id: routineReceipt.id, expectedState: "effect_acknowledged", state: "verified", verifiedAfterState: observed.state, recoveryState: { state: "completed", compensation: "none" } });
+                            routineState = null;
+                        }
                         (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.unraid_restart_end", message: "approved Unraid restart completed", meta: { containerId: fresh.id, observedRestart: true } });
                         return { ok: true, data: { container: { id: fresh.id, name: fresh.name }, beforeState: fresh.state, afterState: observed.state, observedRestart: true, degraded: false } };
                     }
@@ -118,12 +194,18 @@ function createApprovedUnraidRestartExecutor(options) {
                 await sleep(1_000);
             } while (true);
         }
-        catch {
+        catch (error) {
+            if (error instanceof RoutineActionReceiptError)
+                throw error;
             await persistTerminal({ ...attempt, observedAt: now().toISOString(), state: "attempted_or_indeterminate", mutationAcknowledged: acknowledged });
+            if (routineReceipt && routineState)
+                transitionRoutine({ id: routineReceipt.id, expectedState: routineState, state: "indeterminate", recoveryState: { state: "manual_inspection_required", compensation: "none" } });
             (0, runtime_1.emitNervesEvent)({ level: "error", component: "repertoire", event: "repertoire.unraid_restart_error", message: "approved Unraid restart observation failed", meta: { containerId: fresh.id, acknowledged } });
             return failure("ambiguous", "restart was attempted but observation failed; it was not retried");
         }
         await persistTerminal({ ...attempt, observedAt: now().toISOString(), state: "attempted_or_indeterminate", mutationAcknowledged: acknowledged });
+        if (routineReceipt && routineState)
+            transitionRoutine({ id: routineReceipt.id, expectedState: routineState, state: "indeterminate", recoveryState: { state: "manual_inspection_required", compensation: "none" } });
         (0, runtime_1.emitNervesEvent)({ level: "error", component: "repertoire", event: "repertoire.unraid_restart_error", message: "approved Unraid restart outcome was ambiguous", meta: { containerId: fresh.id, acknowledged } });
         return failure("ambiguous", "restart was attempted but could not be proven; it was not retried");
     };

package/dist/senses/private-runtime-worker.js

@@ -39,6 +39,7 @@ exports.startPrivateRuntimeWorker = startPrivateRuntimeWorker;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const private_runtime_1 = require("./private-runtime");
+const router_1 = require("../heart/external-events/router");
 const runtime_1 = require("../nerves/runtime");
 const identity_1 = require("../heart/identity");
 const pending_1 = require("../mind/pending");
@@ -471,9 +472,29 @@ function createPrivateRuntimeWorker(runTurn = (options) => (0, private_runtime_1
             });
         }
     }
-    async function run(reason, taskId, habitName, awaitName, trigger, privateTurnDecision, noSend) {
+    const startExternalEventHeartbeat = (event) => {
+        const renew = () => {
+            for (const member of [event, ...(event.relatedEvents ?? [])]) {
+                try {
+                    (0, router_1.renewExternalEventClaim)(member.recordPath, { owner: member.claimOwner, expectedGeneration: member.generation, leaseMs: 30_000 });
+                }
+                catch (error) {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn", component: "senses", event: "senses.external_event_lease_renew_error",
+                        message: "external-event turn lease renewal failed",
+                        meta: { recordPath: member.recordPath, generation: member.generation, error: error instanceof Error ? error.message : String(error) },
+                    });
+                }
+            }
+        };
+        renew();
+        const timer = setInterval(renew, 10_000);
+        timer.unref?.();
+        return () => clearInterval(timer);
+    };
+    async function run(reason, taskId, habitName, awaitName, trigger, privateTurnDecision, noSend, externalEvent) {
         if (running) {
-            queue.push({ reason, taskId, habitName, awaitName, trigger, privateTurnDecision, noSend });
+            queue.push({ reason, taskId, habitName, awaitName, trigger, privateTurnDecision, noSend, externalEvent, ...(externalEvent ? { stopExternalEventHeartbeat: startExternalEventHeartbeat(externalEvent) } : {}) });
             return;
         }
         running = true;
@@ -484,6 +505,8 @@ function createPrivateRuntimeWorker(runTurn = (options) => (0, private_runtime_1
             let nextAwaitName = awaitName;
             let nextTrigger = trigger;
             let nextPrivateTurnDecision = privateTurnDecision;
+            let nextExternalEvent = externalEvent;
+            let nextExternalEventHeartbeat = externalEvent ? startExternalEventHeartbeat(externalEvent) : undefined;
             let nextNoSend = reason === "habit" ? noSend : undefined;
             let nextHabitRun = null;
             let consecutiveInstinctTurns = reason === "instinct" ? 1 : 0;
@@ -492,6 +515,8 @@ function createPrivateRuntimeWorker(runTurn = (options) => (0, private_runtime_1
                 const currentHabitName = nextHabitName;
                 const currentTrigger = nextTrigger ?? "overdue";
                 const currentNoSend = nextNoSend;
+                const currentExternalEventHeartbeat = nextExternalEventHeartbeat;
+                nextExternalEventHeartbeat = undefined;
                 const currentHabitRun = currentReason === "habit" && currentHabitName
                     ? nextHabitRun && nextHabitRun.habit.name === currentHabitName
                         ? nextHabitRun
@@ -545,6 +570,7 @@ function createPrivateRuntimeWorker(runTurn = (options) => (0, private_runtime_1
                             awaitName: nextAwaitName,
                             ...(currentNoSend ? { noSend: true } : {}),
                             ...(nextPrivateTurnDecision ? { privateTurnDecision: nextPrivateTurnDecision } : {}),
+                            ...(nextExternalEvent ? { externalEvent: nextExternalEvent } : {}),
                             ...(currentHabitRun
                                 ? {
                                     trigger: currentHabitRun.trigger,
@@ -587,6 +613,7 @@ function createPrivateRuntimeWorker(runTurn = (options) => (0, private_runtime_1
                         },
                     });
                 }
+                currentExternalEventHeartbeat?.();
                 if (currentReason === "habit" && currentHabitName === "heartbeat") {
                     heartbeatOkRestedAt = isHeartbeatOkRestResult(turnResult) ? nowSource() : null;
                 }
@@ -613,6 +640,8 @@ function createPrivateRuntimeWorker(runTurn = (options) => (0, private_runtime_1
                     nextAwaitName = next.awaitName;
                     nextTrigger = next.trigger;
                     nextPrivateTurnDecision = next.privateTurnDecision;
+                    nextExternalEvent = next.externalEvent;
+                    nextExternalEventHeartbeat = next.stopExternalEventHeartbeat;
                     nextNoSend = next.reason === "habit" ? next.noSend : undefined;
                     consecutiveInstinctTurns = nextReason === "instinct" ? consecutiveInstinctTurns + 1 : 0;
                     continue runLoop;
@@ -650,6 +679,8 @@ function createPrivateRuntimeWorker(runTurn = (options) => (0, private_runtime_1
                         nextAwaitName = undefined;
                         nextTrigger = currentTrigger;
                         nextPrivateTurnDecision = undefined;
+                        nextExternalEvent = undefined;
+                        nextExternalEventHeartbeat = undefined;
                         nextNoSend = currentNoSend;
                         nextHabitRun = currentHabitRun;
                     }
@@ -662,6 +693,8 @@ function createPrivateRuntimeWorker(runTurn = (options) => (0, private_runtime_1
                         nextAwaitName = undefined;
                         nextTrigger = undefined;
                         nextPrivateTurnDecision = undefined;
+                        nextExternalEvent = undefined;
+                        nextExternalEventHeartbeat = undefined;
                         nextNoSend = undefined;
                     }
                     continue;
@@ -715,7 +748,7 @@ function createPrivateRuntimeWorker(runTurn = (options) => (0, private_runtime_1
         if (maybeMessage.type === "chat" ||
             maybeMessage.type === "message") {
             clearHeartbeatRestShield();
-            await run("instinct", undefined, undefined, undefined, undefined, maybeMessage.privateTurnDecision);
+            await run("instinct", undefined, undefined, undefined, undefined, maybeMessage.privateTurnDecision, undefined, maybeMessage.externalEvent);
             return;
         }
         if (maybeMessage.type === "shutdown") {