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

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

@@ -40,6 +40,7 @@ const runtime_1 = require("../../nerves/runtime");
 const await_parser_1 = require("./await-parser");
 const await_runtime_state_1 = require("./await-runtime-state");
 const await_alert_1 = require("./await-alert");
+const obligations_1 = require("../../arc/obligations");
 /**
  * Daemon-side max_age expiry helper. Reads the pending await, moves it to
  * `awaiting/.done/` with `status: expired`, writes `expired_at` and
@@ -69,8 +70,8 @@ async function archiveAndAlertExpiredAwait(options) {
     }
     const parsed = (0, await_parser_1.parseAwaitFile)(content, source);
     const runtime = (0, await_runtime_state_1.readAwaitRuntimeState)(options.agentRoot, options.awaitName);
-    const lastObservation = runtime?.last_observation ?? null;
-    const expiredAt = now().toISOString();
+    const lastObservation = parsed.last_observation_at_expiry ?? runtime?.last_observation ?? null;
+    const expiredAt = parsed.expired_at ?? now().toISOString();
     const merged = {
         condition: parsed.condition,
         cadence: parsed.cadence,
@@ -81,9 +82,41 @@ async function archiveAndAlertExpiredAwait(options) {
         created_at: parsed.created_at,
         filed_from: parsed.filed_from,
         filed_for_friend_id: parsed.filed_for_friend_id,
+        filed_from_key: parsed.filed_from_key,
+        request_id: parsed.request_id,
+        obligation_id: parsed.obligation_id,
         expired_at: expiredAt,
         last_observation_at_expiry: lastObservation,
     };
+    // A request-bound return must remain live through effect authorization and
+    // acceptance. Freeze its expiry payload in the still-pending await so a
+    // crash after Telegram acceptance retries the exact same effect.
+    if (parsed.request_id) {
+        const staged = { ...merged, status: "pending" };
+        const temporary = `${source}.${process.pid}.expiry.tmp`;
+        try {
+            fs.writeFileSync(temporary, (0, await_parser_1.renderAwaitFile)(staged, parsed.body), { encoding: "utf-8", mode: 0o600, flag: "wx" });
+            fs.renameSync(temporary, source);
+        }
+        catch (error) {
+            try {
+                fs.unlinkSync(temporary);
+            }
+            catch { /* no staged residue to remove */ }
+            throw error;
+        }
+        const alertResult = await (0, await_alert_1.deliverAwaitAlert)({
+            awaitFile: (0, await_parser_1.parseAwaitFile)(fs.readFileSync(source, "utf-8"), source),
+            reason: "expired",
+            observation: lastObservation,
+            agentRoot: options.agentRoot,
+            agentName: options.agentName,
+            deliveryDeps: options.deliveryDeps,
+        });
+        if (alertResult.delivery?.status !== "delivered_now") {
+            return { archived: false, alerted: alertResult.attempted, reason: alertResult.delivery?.status ?? alertResult.skipped ?? "delivery not accepted" };
+        }
+    }
     fs.mkdirSync(doneDir, { recursive: true });
     fs.writeFileSync(target, (0, await_parser_1.renderAwaitFile)(merged, parsed.body), "utf-8");
     fs.unlinkSync(source);
@@ -96,7 +129,9 @@ async function archiveAndAlertExpiredAwait(options) {
     // Re-parse archived file to feed the alert with merged fields
     const archivedContent = fs.readFileSync(target, "utf-8");
     const archived = (0, await_parser_1.parseAwaitFile)(archivedContent, target);
-    const alertResult = await (0, await_alert_1.deliverAwaitAlert)({
+    if (archived.obligation_id)
+        (0, obligations_1.fulfillObligation)(options.agentRoot, archived.obligation_id);
+    const alertResult = parsed.request_id ? null : await (0, await_alert_1.deliverAwaitAlert)({
         awaitFile: archived,
         reason: "expired",
         observation: lastObservation,
@@ -104,5 +139,5 @@ async function archiveAndAlertExpiredAwait(options) {
         agentName: options.agentName,
         deliveryDeps: options.deliveryDeps,
     });
-    return { archived: true, alerted: alertResult.attempted };
+    return { archived: true, alerted: parsed.request_id ? true : Boolean(alertResult?.attempted) };
 }

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/context-loss-gauntlet.js

@@ -81,8 +81,26 @@ function currentAskCheck(card) {
         evidence,
     });
 }
-function nextSafeActionCheck(card) {
+function isSettledTurnWait(resume) {
+    return resume.hasCompleteState
+        && resume.recorderHealth.status === "ok"
+        && resume.blockedBecause.length === 1
+        && resume.blockedBecause[0] === "turn outcome settled; wait for new input before acting"
+        && resume.nextSafeAction.value === "inspect the latest session and wait for new input before acting";
+}
+function nextSafeActionCheck(card, resume) {
     const evidence = card.nextAction.source ? [card.nextAction.source] : [];
+    if (isSettledTurnWait(resume)) {
+        return makeCheck({
+            id: "next_safe_action",
+            label: "Next safe action",
+            status: "pass",
+            score: 20,
+            maxScore: 20,
+            detail: "idle: turn is settled and waiting for new input.",
+            evidence: flightRecorderEvidence(card),
+        });
+    }
     if (card.nextAction.actor === "unknown") {
         return makeCheck({
             id: "next_safe_action",
@@ -117,6 +135,17 @@ function staleGuardCheck(resume, card) {
             evidence,
         });
     }
+    if (isSettledTurnWait(resume)) {
+        return makeCheck({
+            id: "stale_guard",
+            label: "Stale-state guard",
+            status: "pass",
+            score: 15,
+            maxScore: 15,
+            detail: "Flight recorder has complete settled-turn state and is safely waiting for new input.",
+            evidence,
+        });
+    }
     const reasons = [
         "canContinue is false",
         ...(!resume.hasCompleteState ? ["incomplete resume state"] : []),
@@ -287,7 +316,7 @@ function runContextLossGauntlet(agentName, agentRoot, options = {}) {
     const generatedAt = (options.now ?? (() => new Date()))().toISOString();
     const checks = [
         currentAskCheck(card),
-        nextSafeActionCheck(card),
+        nextSafeActionCheck(card, flightRecorderResume),
         staleGuardCheck(flightRecorderResume, card),
         obligationsCheck(card),
         returnRoutesCheck(card),

package/dist/heart/context-loss-sentinel.js

@@ -521,6 +521,8 @@ function healthSignals(results) {
 }
 function defaultGitStatus(agentRoot) {
     try {
+        if (!fs.existsSync(path.join(agentRoot, ".git")))
+            return { ok: true, porcelain: "" };
         const porcelain = (0, child_process_1.execFileSync)("git", ["status", "--porcelain=v1", "-uall"], {
             cwd: agentRoot,
             encoding: "utf-8",

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-healthcheck.js

@@ -72,7 +72,7 @@ function runContainerHealthcheck(options = {}) {
         fail("daemon status is not ready");
     const agents = health.agents;
     const managed = agents?.[agent];
-    if (!managed || managed.status !== "running" || typeof managed.pid !== "number" || managed.pid <= 0 || !fs.existsSync(`/proc/${managed.pid}`))
+    if (!managed || managed.status !== "running" || typeof managed.pid !== "number" || managed.pid <= 0)
         fail("managed agent is not running");
     let processArguments = "";
     try {
@@ -81,6 +81,8 @@ function runContainerHealthcheck(options = {}) {
     catch {
         fail("managed process inventory is unavailable");
     }
+    if (!(0, container_runtime_1.hasManagedAgentProcess)(processArguments, agent))
+        fail("managed agent is not running exactly once");
     if (!(0, container_runtime_1.hasManagedTelegramProcess)(processArguments, agent))
         fail("managed Telegram sense is not running exactly once");
     if (!(0, container_runtime_1.hasManagedSupercronicProcess)(processArguments, agent))

package/dist/heart/daemon/container-runtime.js

@@ -33,11 +33,24 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasManagedAgentProcess = hasManagedAgentProcess;
 exports.hasManagedTelegramProcess = hasManagedTelegramProcess;
 exports.hasManagedSupercronicProcess = hasManagedSupercronicProcess;
 exports.readContainerRuntimePolicy = readContainerRuntimePolicy;
 const fs = __importStar(require("node:fs"));
 const runtime_1 = require("../../nerves/runtime");
+function hasManagedAgentProcess(processArguments, agent) {
+    const wanted = agent.trim();
+    if (!wanted)
+        return false;
+    const matches = processArguments.split("\n").filter((line) => {
+        const fields = line.trim().split(/\s+/u);
+        const entryIndex = fields.findIndex((field) => field === "/opt/ouro/dist/heart/agent-entry.js");
+        const agentIndex = fields.findIndex((field) => field === "--agent");
+        return entryIndex >= 0 && agentIndex >= 0 && fields[agentIndex + 1] === wanted;
+    });
+    return matches.length === 1;
+}
 function hasManagedTelegramProcess(processArguments, agent) {
     const wanted = agent.trim();
     if (!wanted)

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)({