@ouro.bot/cli 0.1.0-alpha.767 → 0.1.0-alpha.769

package/changelog.json

@@ -1,6 +1,22 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.769",
+      "changes": [
+        "Keep stale Sanctuary Care evidence out of current context and require provenance-qualified same-turn Docker verification before reporting or mutation.",
+        "Recognize natural whole-Sanctuary current-status requests and require all seven current reads, including notifications, before a terminal reply.",
+        "Revive provider-lane and managed-runtime external-event dead letters exactly once per generation after typed, newer recovery evidence.",
+        "Let verified fresh Docker alerts be reported while preserving unrelated Care display and policy metadata during partial incident refreshes and constraining durable status values."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.768",
+      "changes": [
+        "Fix Sanctuary acceptance cursor snapshots for authenticated genesis and concurrent audit writes.",
+        "Cover fail-closed cursor schema, authority, and offset validation."
+      ]
+    },
     {
       "version": "0.1.0-alpha.767",
       "changes": [

package/deploy/unraid/sanctuary-acceptance-contract.json

@@ -102,7 +102,7 @@
       "fixed": {
         "allowedRoot": "/evidence",
         "evidencePath": "/evidence/cursor-snapshot.json",
-        "adapters": [{ "schema": "telegram-cursor-v1", "executable": "/opt/ouro/deploy/unraid/sanctuary-acceptance-adapter.sh" }]
+        "adapters": [{ "schema": "telegram-cursor-v1", "executable": "/opt/ouro/deploy/unraid/sanctuary-acceptance-adapter.sh", "allowGenesis": false }]
       }
     },
     "cursor-delta": {

package/deploy/unraid/sanctuary.ouro/bundle-meta.json

@@ -1,5 +1,5 @@
 {
-  "runtimeVersion": "0.1.0-alpha.767",
+  "runtimeVersion": "0.1.0-alpha.769",
   "bundleSchemaVersion": 3,
   "lastUpdated": "2026-08-30T00:00:00.000Z"
 }

package/deploy/unraid/sanctuary.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0"?>
 <Container version="2">
   <Name>Mendelow Cloud Butler</Name>
-  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.767</Repository>
+  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.769</Repository>
   <Registry>https://github.com/ourostack/ouroboros/pkgs/container/ouroboros-butler</Registry>
   <Network>host</Network>
   <Shell>sh</Shell>

package/dist/arc/cares.js

@@ -33,6 +33,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CARE_INCIDENT_RECOVERY_REVIEW_RISK = void 0;
+exports.isManagedDockerCareIncidentBinding = isManagedDockerCareIncidentBinding;
+exports.projectCareEvidence = projectCareEvidence;
 exports.createCare = createCare;
 exports.readCares = readCares;
 exports.readActiveCares = readActiveCares;
@@ -48,6 +51,32 @@ const session_events_1 = require("../heart/session-events");
 const runtime_1 = require("../nerves/runtime");
 const session_transaction_1 = require("../mind/session-transaction");
 const json_store_1 = require("./json-store");
+exports.CARE_INCIDENT_RECOVERY_REVIEW_RISK = "The verified incident recovered, but this Care still has unresolved context that needs review.";
+function isManagedDockerCareIncidentBinding(binding) {
+    return binding.source === "sanctuary-health::Docker_critical_image_disk_utilization"
+        && /^docker-image-disk-(?:100|[1-9]?[0-9])pct-[0-9]{8}T[0-9]{4}Z$/u.test(binding.incidentKey)
+        && /^[a-f0-9]{64}$/u.test(binding.classifiedRevision)
+        && binding.correlationKey === undefined
+        && binding.resolvedAt === undefined;
+}
+function projectCareEvidence(care, now = Date.now()) {
+    if (care.kind !== "system" || (care.status !== "active" && care.status !== "watching") || care.nextCheckAt === null)
+        return care;
+    const staleAt = Date.parse(care.nextCheckAt);
+    if (Number.isFinite(staleAt) && staleAt > now)
+        return care;
+    return {
+        id: care.id,
+        kind: care.kind,
+        status: care.status,
+        salience: care.salience,
+        steward: care.steward,
+        evidenceStatus: "stale",
+        recheckRequired: true,
+        staleAt: care.nextCheckAt,
+        lastAssessedAt: care.updatedAt,
+    };
+}
 function caresDir(agentRoot) {
     return path.join(agentRoot, "arc", "cares");
 }
@@ -208,11 +237,21 @@ function bindCareIncident(agentRoot, id, binding, options) {
 function upsertCareForIncident(agentRoot, input) {
     return withCareMutationLock(agentRoot, () => {
         const incident = canonicalIncidentBinding(input.incident);
-        const existing = (0, json_store_1.readJsonDir)(caresDir(agentRoot)).find((care) => care.incidentBindings?.some((binding) => binding.source === incident.source && binding.incidentKey === incident.incidentKey));
+        const existing = (0, json_store_1.readJsonDir)(caresDir(agentRoot)).find((care) => (!input.id || care.id === input.id) && care.incidentBindings?.some((binding) => binding.source === incident.source && binding.incidentKey === incident.incidentKey));
         if (existing) {
             const index = existing.incidentBindings.findIndex((binding) => binding.source === incident.source && binding.incidentKey === incident.incidentKey);
-            const unchanged = JSON.stringify(existing.incidentBindings[index]) === JSON.stringify(incident)
-                && existing.currentRisk === input.currentRisk && existing.nextCheckAt === input.nextCheckAt;
+            const requestedRisk = input.currentRisk === undefined ? existing.currentRisk : input.currentRisk === null ? null : (0, session_events_1.capStructuredRecordString)(input.currentRisk);
+            const requestedNextCheckAt = input.nextCheckAt === undefined ? existing.nextCheckAt : input.nextCheckAt;
+            const incidentStateUnchanged = JSON.stringify(existing.incidentBindings[index]) === JSON.stringify(incident)
+                && existing.currentRisk === requestedRisk
+                && existing.nextCheckAt === requestedNextCheckAt;
+            const displayUnchanged = !input.id || ((input.label === undefined || existing.label === (0, session_events_1.capStructuredRecordString)(input.label))
+                && (input.why === undefined || existing.why === (0, session_events_1.capStructuredRecordString)(input.why))
+                && (input.kind === undefined || existing.kind === input.kind)
+                && (input.status === undefined || existing.status === input.status)
+                && (input.salience === undefined || existing.salience === input.salience)
+                && (input.steward === undefined || existing.steward === input.steward));
+            const unchanged = incidentStateUnchanged && displayUnchanged;
             if (unchanged)
                 return existing;
             if (!input.expectedUpdatedAt || input.expectedUpdatedAt !== existing.updatedAt)
@@ -221,15 +260,29 @@ function upsertCareForIncident(agentRoot, input) {
             incidentBindings[index] = incident;
             const updated = {
                 ...existing,
-                currentRisk: input.currentRisk === null ? null : (0, session_events_1.capStructuredRecordString)(input.currentRisk),
-                nextCheckAt: input.nextCheckAt,
+                ...(input.id && input.label !== undefined ? { label: (0, session_events_1.capStructuredRecordString)(input.label) } : {}),
+                ...(input.id && input.why !== undefined ? { why: (0, session_events_1.capStructuredRecordString)(input.why) } : {}),
+                ...(input.id && input.kind !== undefined ? { kind: input.kind } : {}),
+                ...(input.id && input.status !== undefined ? { status: input.status } : {}),
+                ...(input.id && input.salience !== undefined ? { salience: input.salience } : {}),
+                ...(input.id && input.steward !== undefined ? { steward: input.steward } : {}),
+                currentRisk: requestedRisk,
+                nextCheckAt: requestedNextCheckAt,
                 incidentBindings,
                 updatedAt: nextUpdatedAt(existing.updatedAt),
             };
             writeCareFile(agentRoot, updated);
             return updated;
         }
-        return createCareUnlocked(agentRoot, { ...input, incidentBindings: [incident] });
+        if (input.id)
+            throw new Error("Care incident upsert target not found");
+        const { id: _id, incident: _incident, expectedUpdatedAt: _expectedUpdatedAt, ...careInput } = input;
+        return createCareUnlocked(agentRoot, {
+            label: careInput.label ?? "untitled", why: careInput.why ?? "", kind: careInput.kind ?? "system", status: careInput.status ?? "active",
+            salience: careInput.salience ?? "medium", steward: careInput.steward ?? "mine", currentRisk: careInput.currentRisk ?? null,
+            nextCheckAt: careInput.nextCheckAt ?? null, relatedFriendIds: careInput.relatedFriendIds, relatedAgentIds: careInput.relatedAgentIds,
+            relatedObligationIds: careInput.relatedObligationIds, relatedEpisodeIds: careInput.relatedEpisodeIds, incidentBindings: [incident],
+        });
     });
 }
 function resolveCareIncident(agentRoot, id, input) {
@@ -241,11 +294,40 @@ function resolveCareIncident(agentRoot, id, input) {
         const index = bindings.findIndex((binding) => binding.source === input.source && binding.incidentKey === input.incidentKey);
         if (index < 0)
             throw new Error("Care incident binding not found");
-        if (bindings[index].resolvedAt)
+        const display = input.display;
+        const requestedDisplay = display ? {
+            label: display.label === undefined ? care.label : (0, session_events_1.capStructuredRecordString)(display.label),
+            why: display.why === undefined ? care.why : (0, session_events_1.capStructuredRecordString)(display.why),
+            currentRisk: display.currentRisk === undefined ? care.currentRisk : display.currentRisk === null ? null : (0, session_events_1.capStructuredRecordString)(display.currentRisk),
+            nextCheckAt: display.nextCheckAt === undefined ? care.nextCheckAt : display.nextCheckAt,
+        } : undefined;
+        const displayUnchanged = !requestedDisplay || JSON.stringify({
+            label: care.label,
+            why: care.why,
+            currentRisk: care.currentRisk,
+            nextCheckAt: care.nextCheckAt,
+        }) === JSON.stringify(requestedDisplay);
+        if (bindings[index].resolvedAt && displayUnchanged)
             return care;
         const now = nextUpdatedAt(care.updatedAt);
-        bindings[index] = { ...bindings[index], resolvedAt: now };
-        const updated = { ...care, incidentBindings: bindings, updatedAt: now };
+        if (!bindings[index].resolvedAt)
+            bindings[index] = { ...bindings[index], resolvedAt: now };
+        const noUnresolvedBindings = bindings.every((binding) => binding.resolvedAt);
+        const unresolvedBindingsBeforeResolution = care.incidentBindings.filter((binding) => !binding.resolvedAt);
+        const soleBindingOwnsRisk = care.kind === "system" && unresolvedBindingsBeforeResolution.length === 1 && isManagedDockerCareIncidentBinding(unresolvedBindingsBeforeResolution[0]);
+        const unresolvedContextRemains = !noUnresolvedBindings || (care.currentRisk !== null && !soleBindingOwnsRisk);
+        const canonicalDisplay = requestedDisplay && requestedDisplay.currentRisk === null && unresolvedContextRemains
+            ? { ...requestedDisplay, currentRisk: exports.CARE_INCIDENT_RECOVERY_REVIEW_RISK, nextCheckAt: requestedDisplay.nextCheckAt ?? new Date(Date.parse(now) + 15 * 60_000).toISOString() }
+            : requestedDisplay;
+        const resultingRisk = canonicalDisplay ? canonicalDisplay.currentRisk : care.currentRisk;
+        const shouldResolveCare = noUnresolvedBindings && (care.currentRisk === null || soleBindingOwnsRisk) && resultingRisk === null;
+        const updated = {
+            ...care,
+            ...canonicalDisplay,
+            incidentBindings: bindings,
+            ...(shouldResolveCare ? { status: "resolved", resolvedAt: care.resolvedAt ?? now } : {}),
+            updatedAt: now,
+        };
         writeCareFile(agentRoot, updated);
         (0, runtime_1.emitNervesEvent)({
             component: "heart",

package/dist/heart/core.js

@@ -569,10 +569,10 @@ function toolResultIndicatesFailure(content) {
         || normalized.startsWith("blocked:")
         || normalized.startsWith("rejected:");
 }
-function requiredToolResultSucceeded(name, content, validate) {
+function requiredToolResultSucceeded(name, content, args, validate) {
     if (toolResultIndicatesFailure(content))
         return false;
-    return validate?.(name, content) ?? true;
+    return validate?.(name, content, args) ?? true;
 }
 function effectFingerprint(name, rawArguments) {
     let args;
@@ -1252,6 +1252,11 @@ async function runAgent(messages, callbacks, channel, signal, options) {
             })()
             : ordinaryActiveTools;
         const candidateToolNames = new Set(candidateActiveTools.map((tool) => tool.function.name));
+        const unadvertisedRequiredTool = requiredToolCallNames.find((name) => !candidateToolNames.has(name));
+        if (unadvertisedRequiredTool) {
+            (0, runtime_1.emitNervesEvent)({ level: "error", component: "engine", event: "engine.required_tool_unadvertised", message: "required tool is not advertised for the active channel", meta: { toolName: unadvertisedRequiredTool, channel: String(channel) } });
+            throw new Error(`required tool is not advertised for this channel: ${unadvertisedRequiredTool}`);
+        }
         const forcedHistoricalToolNames = new Set(unresolvedHistoricalEffects
             .map((effect) => effect.name)
             .filter((name) => candidateToolNames.has(name)));
@@ -1942,7 +1947,14 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     done = true;
                     continue;
                 }
-                const approvalCalls = await Promise.all(validCalls.map(async (entry) => {
+                const requiredDispatchRejections = new Map();
+                for (const entry of validCalls) {
+                    const requiredArgs = entry.validated.arguments;
+                    const rejection = options?.requiredToolCalls?.validateToolCallBeforeDispatch?.(entry.call.name, requiredArgs);
+                    if (rejection)
+                        requiredDispatchRejections.set(entry.call.id, { name: entry.call.name, args: requiredArgs, message: rejection });
+                }
+                const approvalCalls = await Promise.all(validCalls.filter((entry) => !requiredDispatchRejections.has(entry.call.id)).map(async (entry) => {
                     const classification = await (0, tools_1.classifyApprovalForInvocation)(entry.call.name, entry.validated.arguments, augmentedToolContext);
                     return {
                         ...entry,
@@ -2039,6 +2051,28 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 for (const tc of result.toolCalls) {
                     if (signal?.aborted)
                         break;
+                    const requiredDispatchRejection = requiredDispatchRejections.get(tc.id);
+                    if (requiredDispatchRejection) {
+                        callbacks.onToolStart(tc.name, requiredDispatchRejection.args);
+                        callbacks.onToolEnd(tc.name, (0, tools_1.summarizeArgs)(tc.name, requiredDispatchRejection.args), false);
+                        pushGenerated({ role: "tool", tool_call_id: tc.id, content: requiredDispatchRejection.message });
+                        providerRuntime.appendToolOutput(tc.id, requiredDispatchRejection.message);
+                        options?.toolBoundaryObserver?.({
+                            name: tc.name,
+                            reason: "dependency_rejected",
+                            globallyResolvable: typeof (0, tools_1.resolveToolDefinition)(tc.name)?.handler === "function",
+                            invoked: false,
+                            sideEffect: false,
+                        });
+                        (0, runtime_1.emitNervesEvent)({
+                            level: "warn",
+                            component: "engine",
+                            event: "engine.required_tool_dispatch_rejected",
+                            message: "required tool dependency rejected before approval and handler dispatch",
+                            meta: { toolName: tc.name },
+                        });
+                        continue;
+                    }
                     // Reject sole-call tools when mixed with other tool calls
                     const terminalProjection = (0, tools_1.resolveToolDefinition)(tc.name)?.terminalProjection;
                     const soleCallRejection = SOLE_CALL_REJECTION[tc.name]
@@ -2321,9 +2355,20 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         success = false;
                         augmentedToolContext?.habitSession?.recordError?.(toolResult);
                     }
-                    if (success && requiredToolCallNames.includes(tc.name) && options?.requiredToolCalls?.requireSuccessfulResults
-                        && requiredToolResultSucceeded(tc.name, toolResult, options.requiredToolCalls.validateRequiredToolResult))
+                    const validatedRequiredResult = success && requiredToolCallNames.includes(tc.name) && options?.requiredToolCalls?.requireSuccessfulResults
+                        ? requiredToolResultSucceeded(tc.name, toolResult, args, options.requiredToolCalls.validateRequiredToolResult)
+                        : false;
+                    if (validatedRequiredResult) {
                         dispatchedRequiredToolCalls.add(tc.name);
+                        for (const requiredName of options?.requiredToolCalls?.requiredToolCallsAfterResult?.(tc.name, args, toolResult) ?? []) {
+                            if (!candidateToolNames.has(requiredName)) {
+                                (0, runtime_1.emitNervesEvent)({ level: "error", component: "engine", event: "engine.required_tool_unadvertised", message: "dependent required tool is not advertised for the active channel", meta: { toolName: requiredName, channel: String(channel) } });
+                                throw new Error(`dependent required tool is not advertised for this channel: ${requiredName}`);
+                            }
+                            if (!requiredToolCallNames.includes(requiredName))
+                                requiredToolCallNames.push(requiredName);
+                        }
+                    }
                     if (success && currentEffectFingerprint && !toolResultIndicatesFailure(toolResult)) {
                         unresolvedHistoricalEffects = unresolvedHistoricalEffects.filter((effect) => effect.fingerprint !== currentEffectFingerprint);
                     }

package/dist/heart/daemon/daemon.js

@@ -70,6 +70,7 @@ const mailbox_types_1 = require("../mailbox/mailbox-types");
 const mailbox_read_1 = require("../mailbox/mailbox-read");
 const mailbox_view_1 = require("../mailbox/mailbox-view");
 const provider_visibility_1 = require("../provider-visibility");
+const provider_binding_resolver_1 = require("../provider-binding-resolver");
 const private_runtime_1 = require("../private-runtime");
 const socket_client_1 = require("./socket-client");
 const flight_recorder_1 = require("../../arc/flight-recorder");
@@ -1555,6 +1556,7 @@ class OuroDaemon {
     }
     async dispatchExternalEvents(records) {
         const claimed = [];
+        let failureClass;
         try {
             for (const record of records) {
                 const owner = `external-event:${record.agent}:${record.source}:${record.eventId}:generation:${record.generation}:attempt:${record.attemptCount + 1}`;
@@ -1575,6 +1577,11 @@ class OuroDaemon {
                 eventId: primary.eventId,
             }, receipt.id, primary.generation, primary.attemptCount), () => { for (const record of claimed)
                 this.queueExternalEventForPrivateRuntime(record); }, lease);
+            failureClass = wake.denialCode === "managed_runtime_unavailable"
+                ? "managed_runtime_unavailable"
+                : wake.data?.decision?.denialCode === "provider_lane_unavailable"
+                    ? "provider_lane_unavailable"
+                    : undefined;
             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");
@@ -1587,6 +1594,7 @@ class OuroDaemon {
                     (0, router_1.failExternalEventAttempt)(latest.recordPath, {
                         owner: record.claimOwner, expectedVersion: latest.version, expectedGeneration: latest.generation,
                         error: error instanceof Error ? error.message : String(error),
+                        ...(failureClass ? { failureClass } : {}),
                     });
                 }
             }
@@ -1614,6 +1622,43 @@ class OuroDaemon {
                 let record = (0, router_1.readExternalEventRecord)(status.recordPath);
                 if (record.dispatchEnabled === false)
                     continue;
+                if (record.executionState === "dead_letter") {
+                    const failure = (0, router_1.externalEventRecoveryFailure)(record);
+                    if (!failure || record.recoveryGrant?.generation === record.generation)
+                        continue;
+                    let evidence = null;
+                    try {
+                        if (failure.class === "provider_lane_unavailable") {
+                            const binding = (0, provider_binding_resolver_1.resolveEffectiveProviderBinding)({
+                                agentName: record.agent,
+                                agentRoot: path.join(this.bundlesRoot, `${record.agent}.ouro`),
+                                lane: "inner",
+                            });
+                            if (binding.ok && binding.binding.credential.status === "present"
+                                && binding.binding.readiness.status === "ready" && binding.binding.readiness.checkedAt
+                                && Date.parse(binding.binding.readiness.checkedAt) > Date.parse(failure.failedAt)) {
+                                evidence = { class: failure.class, observedAt: binding.binding.readiness.checkedAt };
+                            }
+                        }
+                        else if (this.hasManagedPrivateRuntime(record.agent) && Date.parse(now) > Date.parse(failure.failedAt)) {
+                            evidence = { class: failure.class, observedAt: now };
+                        }
+                        if (!evidence)
+                            continue;
+                        const revival = (0, router_1.reviveExternalEventAfterRecovery)(record.recordPath, { expectedVersion: record.version, expectedGeneration: record.generation, evidence, now: () => now });
+                        record = revival.record;
+                    }
+                    catch (error) {
+                        (0, runtime_1.emitNervesEvent)({
+                            level: "warn",
+                            component: "daemon",
+                            event: "daemon.external_event_recovery_error",
+                            message: "external event dead-letter recovery check failed",
+                            meta: { agent: record.agent, source: record.source, eventId: record.eventId, generation: record.generation, error: error instanceof Error ? error.message : String(error) },
+                        });
+                        continue;
+                    }
+                }
                 if (record.executionState === "running" && record.claimExpiresAt && Date.parse(record.claimExpiresAt) <= Date.parse(now)) {
                     record = (0, router_1.reconcileExternalEvent)(record.recordPath);
                 }
@@ -1657,6 +1702,7 @@ class OuroDaemon {
             return {
                 ok: false,
                 error: `No managed agent '${command.agent}' is registered with daemon-managed private runtime.`,
+                denialCode: "managed_runtime_unavailable",
             };
         }
         const decision = await (0, private_runtime_1.requestPrivateTurnDecision)(this.buildPrivateRuntimeWakeRequest(command), {
@@ -1667,6 +1713,7 @@ class OuroDaemon {
             return {
                 ok: true,
                 message: `private-runtime wake denied for ${command.agent}: ${decision.deniedReason}`,
+                ...(decision.denialCode ? { denialCode: decision.denialCode } : {}),
                 data: { decision },
             };
         }

package/dist/heart/daemon/sanctuary-acceptance-adapter.js

@@ -99,6 +99,7 @@ const NETWORK_TIMEOUT_MS = 10_000;
 const KEY_DIRECTORY = "/boot/config/plugins/dynamix.my.servers/keys";
 const SELECTED_KEY_RECORD = "/run/ouro-acceptance/unraid-key.json";
 const TELEGRAM_OFFSET = "/home/ouro/AgentBundles/sanctuary.ouro/state/senses/telegram/offset.json";
+const TELEGRAM_IDENTITY_KEY = "/home/ouro/AgentBundles/sanctuary.ouro/state/senses/telegram/identity.key";
 const TELEGRAM_AUDIT = `/home/ouro/AgentBundles/sanctuary.ouro/${telegram_audit_ledger_1.TELEGRAM_ACCEPTANCE_AUDIT_RELATIVE_PATH}`;
 const TELEGRAM_AUDIT_HEAD = `/home/ouro/AgentBundles/sanctuary.ouro/${telegram_audit_ledger_1.TELEGRAM_ACCEPTANCE_AUDIT_HEAD_RELATIVE_PATH}`;
 const IMAGE_DIGEST_FILE = "/run/ouro-acceptance/image-digest";
@@ -1848,16 +1849,52 @@ async function storeTelegramBootstrap(payload, deps) {
     }
     return { stored: true };
 }
-function cursorSnapshot(deps) {
+function cursorSnapshot(payload, deps) {
+    exactKeys(payload, ["allowGenesis", "operation", "schema"], "Telegram cursor snapshot request");
+    if (payload.schema !== "telegram-cursor-v1" || typeof payload.allowGenesis !== "boolean")
+        throw new Error("Telegram cursor snapshot request is invalid");
     const offsetRaw = fixedFile(deps, TELEGRAM_OFFSET);
-    const auditRaw = fixedFile(deps, TELEGRAM_AUDIT);
-    const auditHeadRaw = fixedFile(deps, TELEGRAM_AUDIT_HEAD);
+    const identityKey = fixedFile(deps, TELEGRAM_IDENTITY_KEY).trim();
+    if (!/^[A-Za-z0-9_-]{43}$/u.test(identityKey) || Buffer.from(identityKey, "base64url").length !== 32) {
+        throw new Error("Telegram identity key is invalid");
+    }
     const offset = object(JSON.parse(offsetRaw), "Telegram offset");
     if (!Number.isSafeInteger(offset.nextUpdateId) || offset.nextUpdateId < 0)
         throw new Error("Telegram offset is invalid");
+    let auditCursorDigest;
+    let verificationFailure;
+    let observedAuditState = false;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        const headBefore = optionalFixedFile(deps, TELEGRAM_AUDIT_HEAD);
+        const auditRaw = optionalFixedFile(deps, TELEGRAM_AUDIT);
+        const headAfter = optionalFixedFile(deps, TELEGRAM_AUDIT_HEAD);
+        if (headBefore === null && auditRaw === null && headAfter === null) {
+            if (payload.allowGenesis !== true)
+                throw new Error("Telegram audit genesis is not authorized for this snapshot");
+            if (!observedAuditState) {
+                auditCursorDigest = sha256("ouroboros.telegram.acceptance.cursor.v1\0genesis");
+                break;
+            }
+            continue;
+        }
+        observedAuditState = true;
+        if (headBefore !== null && auditRaw !== null && headAfter !== null && headBefore === headAfter) {
+            try {
+                (0, telegram_audit_ledger_1.verifyTelegramAuditLedger)({ ledgerRaw: auditRaw, headRaw: headAfter, identityKey });
+                auditCursorDigest = sha256(`ouroboros.telegram.acceptance.cursor.v1\0present\0${auditRaw}\0${headAfter}`);
+                break;
+            }
+            catch (error) {
+                verificationFailure = error;
+            }
+        }
+    }
+    if (auditCursorDigest === undefined) {
+        throw new Error(`Telegram acceptance audit state could not be captured consistently${verificationFailure ? `: ${verificationFailure.message}` : ""}`, verificationFailure ? { cause: verificationFailure } : undefined);
+    }
     return {
         offsetDigest: sha256(JSON.stringify({ nextUpdateId: offset.nextUpdateId })),
-        auditCursorDigest: sha256(`${auditRaw}\0${auditHeadRaw}`),
+        auditCursorDigest,
     };
 }
 function telegramPollerQuiescence(payload, deps) {
@@ -2065,7 +2102,7 @@ function provenance(payload, deps) {
     const containerDigest = fixedFile(deps, CONTAINER_DIGEST_FILE).trim();
     if (!SHA256.test(imageDigest) || !SHA256.test(containerDigest))
         throw new Error("live provenance digest is invalid");
-    const cursor = cursorSnapshot(deps);
+    const cursor = cursorSnapshot({ operation: "snapshot", schema: "telegram-cursor-v1", allowGenesis: false }, deps);
     return { imageDigest, containerDigest, cursorDigest: sha256(`${cursor.offsetDigest}\0${cursor.auditCursorDigest}`) };
 }
 function evidenceSnapshot(payload, deps) {
@@ -2078,7 +2115,11 @@ function evidenceSnapshot(payload, deps) {
     const imageDigest = fixedFile(deps, IMAGE_DIGEST_FILE).trim();
     if (!SHA256.test(imageDigest))
         throw new Error("container image digest is invalid");
-    return { healthy: health.healthy, containerImageDigest: imageDigest, telegramOffsetDigest: cursorSnapshot(deps).offsetDigest };
+    return {
+        healthy: health.healthy,
+        containerImageDigest: imageDigest,
+        telegramOffsetDigest: cursorSnapshot({ operation: "snapshot", schema: "telegram-cursor-v1", allowGenesis: false }, deps).offsetDigest,
+    };
 }
 function bootId(deps) {
     const value = fixedFile(deps, BOOT_ID_FILE).trim();
@@ -2147,6 +2188,7 @@ function materializeConfig(payload, deps) {
         if (phase !== "before" && phase !== "after")
             throw new Error("cursor snapshot phase is invalid");
         config.evidencePath = `/evidence/cursor-${phase}.json`;
+        config.adapters = config.adapters.map((adapter) => ({ ...adapter, allowGenesis: phase === "before" }));
     }
     else if (command === "unraid-key-rotate") {
         const closed = object(JSON.parse(fixedFile(deps, CLOSED_INVENTORY_FILE)), "closed Unraid inventory");
@@ -2188,7 +2230,7 @@ async function executeSanctuaryAcceptanceAdapter(rawPayload, deps = createSanctu
                 result = telegramPollerQuiescence(payload, deps);
                 break;
             case "snapshot":
-                result = cursorSnapshot(deps);
+                result = cursorSnapshot(payload, deps);
                 break;
             case "inject_callbacks_concurrently":
                 result = await concurrentCallbackProbe(payload, deps);

package/dist/heart/daemon/sanctuary-acceptance-harness.js

@@ -1011,7 +1011,10 @@ async function cursorSnapshot(config, deps) {
             throw new Error("snapshot adapter schemas must be unique");
         schemas.add(schema);
         const executable = adapter(spec.executable, "snapshot adapter executable");
-        const payload = await deps.runAdapter(executable, { operation: "snapshot", schema });
+        const allowGenesis = spec.allowGenesis === undefined ? false : boolean(spec.allowGenesis, "snapshot adapter allowGenesis");
+        if (allowGenesis && evidencePath !== path.join(root, "cursor-before.json"))
+            throw new Error("snapshot adapter genesis authority is only valid for cursor-before evidence");
+        const payload = await deps.runAdapter(executable, { operation: "snapshot", schema, allowGenesis });
         const selected = fixedEvidenceValues(schema, payload);
         for (const [name, value] of Object.entries(selected))
             values[`${schema}.${name}`] = value;