@ouro.bot/cli 0.1.0-alpha.816 → 0.1.0-alpha.818

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

@@ -48,20 +48,19 @@ const path = __importStar(require("node:path"));
 const node_util_1 = require("node:util");
 const friends_1 = require("@ouro.bot/friends");
 const runtime_1 = require("../../nerves/runtime");
-const telegram_1 = require("../../senses/telegram");
-const runtime_credentials_1 = require("../runtime-credentials");
+const sanctuary_authority_resident_1 = require("../../senses/sanctuary-authority-resident");
 const relationship_authorization_1 = require("../../repertoire/relationship-authorization");
 const tools_1 = require("../../repertoire/tools");
 const MAX_ADAPTER_OUTPUT = 1_048_576;
 const DEFAULT_ADAPTER_TIMEOUT_MS = 240_000;
-const DEFAULT_TELEGRAM_TIMEOUT_MS = 10_000;
+const DEFAULT_TELEGRAM_TIMEOUT_MS = 65_000;
 const PACKAGED_PROVENANCE_ADAPTER = "/opt/ouro/deploy/unraid/sanctuary-acceptance-adapter.sh";
 const OPAQUE_DIGEST = /^[0-9a-f]{64}$/u;
 function exactSanctuaryContainmentProfileBoundaries(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return false;
     const boundaries = value;
-    const versions = { "sanctuary-owner": 8, "sanctuary-household": 5, "sanctuary-event": 4 };
+    const versions = { "sanctuary-owner": 9, "sanctuary-household": 5, "sanctuary-event": 4 };
     if (!(0, node_util_1.isDeepStrictEqual)(Object.keys(boundaries).sort(), Object.keys(versions).sort()))
         return false;
     const packageRoot = path.resolve(__dirname, "../../../deploy/unraid/sanctuary.ouro");
@@ -73,7 +72,7 @@ function exactSanctuaryContainmentProfileBoundaries(value) {
             return false;
         const boundary = raw;
         const capabilities = boundary.providerCapabilities;
-        if (!Array.isArray(capabilities) || !capabilities.every((entry) => entry === "reasoning-effort" || entry === "phase-annotation")
+        if (!Array.isArray(capabilities) || !capabilities.every((entry) => entry === "reasoning-effort" || entry === "phase-annotation" || entry === "approval-continuation")
             || new Set(capabilities).size !== capabilities.length)
             return false;
         const profile = registry.profiles[id];
@@ -104,10 +103,8 @@ function createSanctuaryAcceptanceHarnessDependencies(secretFd = 3, options = {}
     const adapterTimeoutMs = options.adapterTimeoutMs ?? DEFAULT_ADAPTER_TIMEOUT_MS;
     const telegramTimeoutMs = options.telegramTimeoutMs ?? DEFAULT_TELEGRAM_TIMEOUT_MS;
     return {
+        gateway: () => (0, sanctuary_authority_resident_1.openSanctuaryResidentAuthority)({}, {}),
         readSecret: () => (0, node_fs_1.readFileSync)(secretFd, "utf8"),
-        refreshRuntime: runtime_credentials_1.refreshRuntimeCredentialConfig,
-        mergeRuntime: runtime_credentials_1.mergeRuntimeCredentialConfig,
-        telegramCredentials: telegram_1.loadTelegramSenseCredentials,
         runAdapter: async (executable, payload, remainingMs) => {
             requireAbsoluteExecutable(executable);
             const result = (0, node_child_process_1.spawnSync)(executable, [], {
@@ -134,32 +131,12 @@ function createSanctuaryAcceptanceHarnessDependencies(secretFd = 3, options = {}
             }
         },
         realpath: node_fs_1.realpathSync,
-        fetch,
         now: Date.now,
         randomBytes: node_crypto_1.randomBytes,
         sleep: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
         telegramTimeoutMs,
     };
 }
-async function canonicalTelegramBootstrapToken(deps) {
-    let refreshed;
-    try {
-        refreshed = await deps.refreshRuntime("sanctuary");
-    }
-    catch {
-        throw new Error("Telegram runtime credentials are unavailable; actor: human-required; unlock or repair vault runtime/config");
-    }
-    if (!refreshed.ok)
-        throw new Error("Telegram runtime credentials are unavailable; actor: human-required; unlock or repair vault runtime/config");
-    try {
-        const token = deps.telegramCredentials("sanctuary").botToken.trim();
-        (0, telegram_1.telegramBotIdFromToken)(token);
-        return token;
-    }
-    catch {
-        throw new Error("Telegram runtime credentials are invalid; actor: human-required; repair vault runtime/config");
-    }
-}
 function object(value, label) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         throw new Error(`${label} must be an object`);
@@ -357,39 +334,6 @@ function safeErrorCategory(error) {
 function failedCheckpoint(root, filePath, base, error) {
     replaceCheckpoint(root, filePath, { ...base, phase: "failed", errorCategory: safeErrorCategory(error) });
 }
-async function telegramRequest(deps, token, method, body, requestTimeoutMs = deps.telegramTimeoutMs ?? DEFAULT_TELEGRAM_TIMEOUT_MS) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), requestTimeoutMs);
-    let response;
-    try {
-        response = await deps.fetch(`https://api.telegram.org/bot${token}/${method}`, {
-            ...(body ? {
-                method: "POST",
-                headers: { "content-type": "application/json" },
-                body: JSON.stringify(body),
-            } : {}),
-            signal: controller.signal,
-        });
-    }
-    catch (error) {
-        if (controller.signal.aborted)
-            throw new Error("Telegram request timed out");
-        throw error;
-    }
-    finally {
-        clearTimeout(timeout);
-    }
-    let envelope;
-    try {
-        envelope = object(await response.json(), "Telegram response");
-    }
-    catch {
-        throw new Error("Telegram returned invalid JSON");
-    }
-    if (!response.ok || envelope.ok !== true)
-        throw new Error("Telegram request failed");
-    return envelope.result;
-}
 function telegramBootstrapRequestError(method, error) {
     const outcome = error instanceof Error && /timed out/iu.test(error.message) ? "timed out" : "failed";
     return new Error(`Telegram ${method} ${outcome}; actor: agent-runnable; retry Telegram bootstrap`);
@@ -401,7 +345,7 @@ exports.SANCTUARY_UNIT_16_EVIDENCE_LABELS = [
     "unit-16a-pre-reboot-checkpoint",
     "unit-16a-reboot-request",
     "unit-16a-boot-recovery-milestones",
-    "unit-16b-runtime-vault-containment",
+    "unit-16b-runtime-vault-readiness",
     "unit-16c-provider-readiness",
     "unit-16d-whats-up",
     "unit-16d-1-space",
@@ -470,6 +414,8 @@ function requiredInteger(value, key, expected, label) {
         throw new Error(`${label} ${key} must equal ${expected}`);
 }
 function validateSanctuaryUnit16EvidenceAssertions(label, raw) {
+    if (!exports.SANCTUARY_UNIT_16_EVIDENCE_LABELS.includes(label))
+        throw new Error("Sanctuary evidence label is retired or unsupported");
     const value = object(raw, `${label} assertions`);
     const exact = (keys) => exactObjectKeys(value, keys, `${label} assertions`);
     const allTrue = (keys) => keys.forEach((key) => requiredTrue(value, key, label));
@@ -506,13 +452,10 @@ function validateSanctuaryUnit16EvidenceAssertions(label, raw) {
             allTrue(["arrayReady", "bootIdentityChanged", "butlerReady", "dockerReady", "hostReady", "postbootIntegrityPreserved", "sshReady", "tailscaleReady"]);
             opaqueDigest(value.processBindingDigest, `${label} processBindingDigest`);
             break;
-        case "unit-16b-runtime-vault-containment":
-            exact(["autostartExact", "exactImage", "manualAuthRequired", "mountCount", "mountsExact", "nonRootUid", "publishedPortCount", "readOnlyRoot", "updaterDisabled", "vaultUnlocked"]);
-            allTrue(["autostartExact", "exactImage", "mountsExact", "readOnlyRoot", "updaterDisabled", "vaultUnlocked"]);
+        case "unit-16b-runtime-vault-readiness":
+            exact(["autostartExact", "exactImage", "manualAuthRequired", "updaterDisabled", "vaultUnlocked"]);
+            allTrue(["autostartExact", "exactImage", "updaterDisabled", "vaultUnlocked"]);
             requiredFalse(value, "manualAuthRequired", label);
-            requiredInteger(value, "mountCount", 4, label);
-            requiredInteger(value, "nonRootUid", 10001, label);
-            requiredInteger(value, "publishedPortCount", 0, label);
             break;
         case "unit-16c-provider-readiness":
             exact(["innerReady", "laneSelectionExact", "outwardReady", "silentFallback", "singleCredentialExact", "vaultCoordinatesExact"]);
@@ -566,7 +509,7 @@ function validateSanctuaryUnit16EvidenceAssertions(label, raw) {
             integer(value.auditLifecyclePairCount, `${label} auditLifecyclePairCount`, 1);
             if (text(value.containerUser, `${label} containerUser`) !== "10001:10001" || text(value.liveProcessUser, `${label} liveProcessUser`) !== "10001:10001" || text(value.networkMode, `${label} networkMode`) !== "host")
                 throw new Error(`${label} container identity or network is invalid`);
-            requiredInteger(value, "mountCount", 3, label);
+            requiredInteger(value, "mountCount", 4, label);
             requiredInteger(value, "typedWriteExecutorCount", 1, label);
             allTrue(["writeApprovalPolicyExact", "mountsExact", "securityExact", "updaterDisabled"]);
             break;
@@ -703,7 +646,7 @@ exports.SANCTUARY_SCENARIO_GATES = {
     "unit-16a-pre-reboot-checkpoint": "none",
     "unit-16a-reboot-request": "none",
     "unit-16a-boot-recovery-milestones": "none",
-    "unit-16b-runtime-vault-containment": "none",
+    "unit-16b-runtime-vault-readiness": "none",
     "unit-16c-provider-readiness": "none",
     "unit-16d-whats-up": "authorized-telegram-message",
     "unit-16d-1-space": "authorized-telegram-message",
@@ -727,7 +670,7 @@ exports.SANCTUARY_SCENARIO_SOURCES = {
     "unit-16a-pre-reboot-checkpoint": ["telegram-audit", "telegram-offset", "approval-journal", "container-inspect", "cron-runtime", "reboot-checkpoint"],
     "unit-16a-reboot-request": ["reboot-checkpoint"],
     "unit-16a-boot-recovery-milestones": ["reboot-checkpoint", "container-inspect"],
-    "unit-16b-runtime-vault-containment": ["container-inspect"],
+    "unit-16b-runtime-vault-readiness": ["container-inspect"],
     "unit-16c-provider-readiness": ["provider-live-check"],
     "unit-16d-whats-up": ["telegram-audit", "telegram-offset", "telegram-turn-receipts", "live-grounding-read"],
     "unit-16d-1-space": ["telegram-audit", "telegram-offset", "telegram-turn-receipts", "restart-attempt-ledger", "container-inspect", "live-grounding-read"],
@@ -945,110 +888,94 @@ async function telegramBootstrap(config, deps) {
     const pollTimeoutSeconds = integer(config.pollTimeoutSeconds, "pollTimeoutSeconds", 1);
     if (pollTimeoutSeconds > 50)
         throw new Error("Telegram poll timeout exceeds 50 seconds");
-    const token = deps.readSecret().trim();
-    let getMe;
-    try {
-        getMe = await telegramRequest(deps, token, "getMe");
-    }
-    catch (error) {
-        throw telegramBootstrapRequestError("getMe", error);
-    }
-    const bot = object(getMe, "Telegram getMe result");
-    if (String(bot.id) !== expectedBotId || bot.username !== expectedUsername) {
-        throw new Error("Telegram bot identity mismatch; actor: human-required; repair vault runtime/config");
+    const gateway = deps.gateway?.();
+    if (!gateway)
+        throw new Error("Telegram root gateway is unavailable");
+    async function bounded(operation, timeoutMs = deps.telegramTimeoutMs ?? DEFAULT_TELEGRAM_TIMEOUT_MS) {
+        let timer;
+        try {
+            return await Promise.race([
+                operation(),
+                new Promise((_resolve, reject) => {
+                    timer = setTimeout(() => reject(new Error("Telegram gateway request timed out")), timeoutMs);
+                }),
+            ]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
     }
-    const nonce = deps.randomBytes(16).toString("hex");
-    const base = {
-        schemaVersion: 1,
-        operation: "telegram-bootstrap",
-        phase: "preflight",
-        botIdentityDigest: digest({ id: expectedBotId, username: expectedUsername }),
-        startedAt: deps.now(),
-    };
-    initializeCheckpoint(root, evidencePath, base);
     try {
-        const quiesced = object(await deps.runAdapter(pollerAdapter, {
-            operation: "quiesce_telegram_poller",
-            expectedState: "stopped",
-        }), "Telegram poller precondition");
-        exactObjectKeys(quiesced, ["activePollers", "quiesced"], "Telegram poller precondition");
-        if (quiesced.quiesced !== true || quiesced.activePollers !== 0)
-            throw new Error("Telegram competing poller is not quiescent");
-        writeAtomicPrivateText(root, noncePath, nonce);
-        const deadline = deps.now() + deadlineMs;
-        let nextOffset = currentOffset;
-        let match;
-        while (deps.now() < deadline && !match) {
-            let updates;
-            try {
-                updates = await telegramRequest(deps, token, "getUpdates", {
-                    offset: nextOffset,
-                    timeout: pollTimeoutSeconds,
-                    allowed_updates: ["message"],
-                }, (pollTimeoutSeconds + 5) * 1_000);
-            }
-            catch (error) {
-                throw telegramBootstrapRequestError("getUpdates", error);
-            }
-            if (!Array.isArray(updates))
-                throw new Error("Telegram getUpdates result must be an array");
-            const parsed = updates.map((entry) => object(entry, "Telegram update"));
-            const updateIds = parsed.map((entry) => integer(entry.update_id, "Telegram update id"));
-            if (updateIds.length > 0)
-                nextOffset = Math.max(nextOffset, ...updateIds.map((id) => id + 1));
-            const matches = parsed.filter((entry) => {
-                const message = entry.message && typeof entry.message === "object" && !Array.isArray(entry.message) ? entry.message : null;
-                const chat = message?.chat && typeof message.chat === "object" && !Array.isArray(message.chat) ? message.chat : null;
-                return message?.text === nonce
-                    && chat?.type === "private"
-                    && typeof message?.from === "object"
-                    && message.from !== null
-                    && !Array.isArray(message.from)
-                    && !Object.keys(message).some((key) => key.startsWith("forward_"))
-                    && Number.isSafeInteger(message.date)
-                    && message.date >= Math.floor(base.startedAt / 1000);
-            });
-            if (matches.length > 1)
-                throw new Error("Telegram nonce update is ambiguous");
-            match = matches[0];
+        if (!await bounded(async () => gateway.authorityTransport.hostApproval?.refresh()))
+            throw new Error("Telegram root gateway health is unavailable");
+        const initialCursor = await bounded(() => gateway.cursorSnapshot());
+        if (initialCursor.cursor !== currentOffset)
+            throw new Error("Telegram gateway cursor changed before bootstrap");
+        let getMe;
+        try {
+            getMe = await bounded(() => gateway.authorityTransport.api.request("getMe", {}));
         }
-        if (!match)
-            throw new Error("Telegram nonce confirmation timed out");
-        const message = object(match.message, "Telegram nonce message");
-        const from = object(message.from, "Telegram nonce sender");
-        const chat = object(message.chat, "Telegram nonce chat");
-        const userId = String(integer(from.id, "Telegram user id", 1));
-        const chatId = String(integer(chat.id, "Telegram chat id", 1));
-        const nextUpdateId = nextOffset;
-        const confirmed = {
-            ...base,
-            phase: "nonce_confirmed",
-            updateDigest: digest(match),
-            coordinateDigest: digest({ userId, chatId }),
-            offsetDigest: digest(nextUpdateId),
+        catch (error) {
+            throw telegramBootstrapRequestError("getMe", error);
+        }
+        const bot = object(getMe, "Telegram getMe result");
+        if (String(bot.id) !== expectedBotId || gateway.credentials.botId !== expectedBotId || bot.username !== expectedUsername) {
+            throw new Error("Telegram bot identity mismatch; repair root gateway identity");
+        }
+        const nonce = deps.randomBytes(16).toString("hex");
+        const base = {
+            schemaVersion: 1, operation: "telegram-bootstrap", phase: "preflight",
+            botIdentityDigest: digest({ id: expectedBotId, username: expectedUsername }), startedAt: deps.now(),
         };
-        replaceCheckpoint(root, evidencePath, confirmed);
-        let stored;
+        initializeCheckpoint(root, evidencePath, base);
         try {
-            stored = await deps.mergeRuntime("sanctuary", {
-                telegramAuthorizedUserId: userId,
-                telegramAuthorizedChatId: chatId,
-            });
-        }
-        catch {
-            throw new Error("Telegram bootstrap vault update failed; actor: agent-runnable; retry Telegram bootstrap");
+            const quiesced = object(await deps.runAdapter(pollerAdapter, { operation: "quiesce_telegram_poller", expectedState: "stopped" }), "Telegram poller precondition");
+            exactObjectKeys(quiesced, ["activePollers", "quiesced"], "Telegram poller precondition");
+            if (quiesced.quiesced !== true || quiesced.activePollers !== 1)
+                throw new Error("Telegram root poller or stopped resident is not proven");
+            writeAtomicPrivateText(root, noncePath, nonce);
+            const deadline = deps.now() + deadlineMs;
+            let match;
+            while (deps.now() < deadline && !match) {
+                let updates;
+                try {
+                    updates = await bounded(() => gateway.authorityTransport.api.request("getUpdates", { offset: currentOffset, timeout: pollTimeoutSeconds, allowed_updates: ["message", "callback_query"] }), Math.min(deps.telegramTimeoutMs ?? DEFAULT_TELEGRAM_TIMEOUT_MS, deadline - deps.now()));
+                }
+                catch (error) {
+                    throw telegramBootstrapRequestError("getUpdates", error);
+                }
+                if (!Array.isArray(updates) || updates.length > 1)
+                    throw new Error("Telegram gateway delivery is ambiguous");
+                if (updates.length === 0)
+                    continue;
+                const candidate = updates[0];
+                const message = candidate.message;
+                const observation = gateway.authorityTransport.metadataForUpdate(candidate);
+                if (!message || message.text !== nonce || message.chat.type !== "private" || !message.from
+                    || Object.keys(message).some((key) => key.startsWith("forward_")) || !Number.isSafeInteger(message.date) || message.date < Math.floor(Number(base.startedAt) / 1000)
+                    || !observation?.ownerEligible || observation.userId !== gateway.credentials.authorizedUserId || observation.chatId !== gateway.credentials.authorizedChatId) {
+                    throw new Error("Telegram gateway has a pending non-bootstrap owner update; resume resident dispatch without discarding it");
+                }
+                match = candidate;
+            }
+            if (!match)
+                throw new Error("Telegram nonce confirmation timed out");
+            const confirmed = { ...base, phase: "nonce_confirmed", updateDigest: digest(match), coordinateDigest: digest({ userId: gateway.credentials.authorizedUserId, chatId: gateway.credentials.authorizedChatId }) };
+            replaceCheckpoint(root, evidencePath, confirmed);
+            await bounded(() => gateway.authorityTransport.settleTransport(match, "completed"));
+            const settled = await bounded(() => gateway.cursorSnapshot());
+            if (settled.cursor <= match.update_id)
+                throw new Error("Telegram gateway settlement readback did not advance");
+            atomicPrivateJson(root, offsetPath, { nextUpdateId: settled.cursor, progressDigest: settled.progressDigest });
+            replaceCheckpoint(root, evidencePath, { ...confirmed, phase: "complete", offsetDigest: settled.progressDigest.slice("sha256:".length), completedAt: deps.now() });
         }
-        if (!stored.ok || stored.config.telegramBotToken !== token
-            || stored.config.telegramAuthorizedUserId !== userId || stored.config.telegramAuthorizedChatId !== chatId) {
-            throw new Error("Telegram bootstrap vault readback failed; actor: agent-runnable; retry Telegram bootstrap");
+        catch (error) {
+            failedCheckpoint(root, evidencePath, base, error);
+            throw error;
         }
-        replaceCheckpoint(root, evidencePath, { ...confirmed, phase: "vault_committed" });
-        atomicPrivateJson(root, offsetPath, { nextUpdateId });
-        replaceCheckpoint(root, evidencePath, { ...confirmed, phase: "complete", completedAt: deps.now() });
     }
-    catch (error) {
-        failedCheckpoint(root, evidencePath, base, error);
-        throw error;
+    finally {
+        gateway.authorityTransport.api.stop();
     }
 }
 function atomicPrivateJson(root, filePath, value) {
@@ -1862,8 +1789,7 @@ async function executeSanctuaryAcceptanceHarness(command, rawConfig, deps = crea
         const config = object(rawConfig, "acceptance config");
         switch (command) {
             case "telegram-bootstrap": {
-                const token = await canonicalTelegramBootstrapToken(deps);
-                await telegramBootstrap(config, { ...deps, readSecret: () => token });
+                await telegramBootstrap(config, deps);
                 break;
             }
             case "cursor-snapshot":

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

@@ -132,7 +132,7 @@ function exactContainmentAudit(evidence) {
         && (0, sanctuary_acceptance_harness_1.exactSanctuaryContainmentProfileBoundaries)(evidence.profileBoundaries)
         && evidence.auditPathDigest === (0, node_crypto_1.createHash)("sha256").update(CONTAINMENT_AUDIT_PATH).digest("hex")
         && evidence.auditRecordCount >= 2 && evidence.auditLifecyclePairCount >= 1
-        && evidence.containerUser === "10001:10001" && evidence.liveProcessUser === "10001:10001" && evidence.mountCount === 3 && evidence.publishedPortCount === 0
+        && evidence.containerUser === "10001:10001" && evidence.liveProcessUser === "10001:10001" && evidence.mountCount === 4 && evidence.publishedPortCount === 0
         && evidence.networkMode === "host" && evidence.readOnlyRoot === false && evidence.mountsExact && evidence.securityExact && evidence.updaterDisabled
         && !evidence.writableKeyExposure && evidence.rawWriteMaterialFieldCount === 0 && evidence.typedWriteExecutorCount === 1
         && evidence.writeApprovalPolicyExact && !evidence.sensitiveMaterialObserved
@@ -422,15 +422,13 @@ function deriveSanctuaryScenarioAssertions(label, before, after, _now, scenarioH
             if (!after.reboot || after.reboot.phase !== "complete" || !SHA256.test(after.reboot.processBindingDigest) || !after.reboot.bootIdentityChanged || !after.reboot.arrayReady || !after.reboot.butlerReady || !after.reboot.dockerReady || !after.reboot.hostReady || !after.reboot.sshReady || !after.reboot.tailscaleReady || !postbootIntegrity)
                 return null;
             return { arrayReady: after.reboot.arrayReady, bootIdentityChanged: true, butlerReady: after.reboot.butlerReady, dockerReady: after.reboot.dockerReady, hostReady: after.reboot.hostReady, postbootIntegrityPreserved: true, processBindingDigest: after.reboot.processBindingDigest, sshReady: after.reboot.sshReady, tailscaleReady: after.reboot.tailscaleReady };
-        case "unit-16b-runtime-vault-containment":
+        case "unit-16b-runtime-vault-readiness":
             if (!after.container)
                 return null;
             if (!after.container.autostartExact || !after.container.exactImage || !after.container.mountsExact || after.container.manualAuthRequired
-                || after.container.mountCount !== 4 || Number(after.container.user.split(":")[0]) !== 10001
-                || after.container.publishedPortCount !== 0 || !after.container.readOnlyRoot
                 || !after.container.updaterDisabled || !after.container.vaultUnlocked)
                 return null;
-            return { autostartExact: after.container.autostartExact, exactImage: after.container.exactImage, manualAuthRequired: after.container.manualAuthRequired, mountCount: after.container.mountCount, mountsExact: after.container.mountsExact, nonRootUid: Number(after.container.user.split(":")[0]), publishedPortCount: after.container.publishedPortCount, readOnlyRoot: after.container.readOnlyRoot, updaterDisabled: after.container.updaterDisabled, vaultUnlocked: after.container.vaultUnlocked };
+            return { autostartExact: after.container.autostartExact, exactImage: after.container.exactImage, manualAuthRequired: after.container.manualAuthRequired, updaterDisabled: after.container.updaterDisabled, vaultUnlocked: after.container.vaultUnlocked };
         case "unit-16c-provider-readiness":
             return after.provider && after.provider.outwardReady && after.provider.innerReady && !after.provider.silentFallback
                 && after.provider.credentialRevisionsPresent === true && after.provider.requestSemanticsExact === true && after.provider.fallbackAttemptCount === 0
@@ -635,6 +633,7 @@ function deriveSanctuaryScenarioAssertions(label, before, after, _now, scenarioH
                 state: approval.state,
             };
     }
+    return null;
 }
 function createSanctuaryScenarioCapture(deps) {
     const receiptRoot = deps.receiptRoot ?? path.join(deps.agentRoot, "state", "acceptance", "receipts");

package/dist/heart/daemon/sanctuary-authority-codec.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicalAuthorityJson = canonicalAuthorityJson;
+exports.authorityArtifactDigest = authorityArtifactDigest;
+exports.signAuthorityPayload = signAuthorityPayload;
+exports.verifyAuthorityPayload = verifyAuthorityPayload;
+const node_crypto_1 = require("node:crypto");
+const runtime_1 = require("../../nerves/runtime");
+const ARTIFACT_KEYS = ["domain", "keyId", "payload", "schemaVersion", "signature"];
+const BASE64URL_SIGNATURE = /^[A-Za-z0-9_-]{86}$/u;
+function invalidCanonicalJson() {
+    throw new Error("canonical authority JSON value is invalid");
+}
+function canonicalAuthorityJson(value) {
+    if (value === null || typeof value === "boolean" || typeof value === "string")
+        return JSON.stringify(value);
+    if (typeof value === "number") {
+        if (!Number.isSafeInteger(value) || Object.is(value, -0))
+            return invalidCanonicalJson();
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        const entries = [];
+        for (let index = 0; index < value.length; index += 1) {
+            if (!(index in value))
+                return invalidCanonicalJson();
+            entries.push(canonicalAuthorityJson(value[index]));
+        }
+        return `[${entries.join(",")}]`;
+    }
+    if (typeof value !== "object" || Object.getPrototypeOf(value) !== Object.prototype)
+        return invalidCanonicalJson();
+    const record = value;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalAuthorityJson(record[key])}`).join(",")}}`;
+}
+function signingBytes(domain, payload) {
+    if (!domain)
+        throw new Error("authority domain is invalid");
+    return Buffer.from(`ouro.sanctuary.authority.v1\0${domain}\0${canonicalAuthorityJson(payload)}`, "utf8");
+}
+function authorityArtifactDigest(domain, payload) {
+    return `sha256:${(0, node_crypto_1.createHash)("sha256").update(signingBytes(domain, payload)).digest("hex")}`;
+}
+function signAuthorityPayload(input) {
+    if (!input.keyId)
+        throw new Error("authority key id is invalid");
+    return {
+        schemaVersion: 1,
+        domain: input.domain,
+        keyId: input.keyId,
+        payload: input.payload,
+        signature: (0, node_crypto_1.sign)(null, signingBytes(input.domain, input.payload), input.privateKey).toString("base64url"),
+    };
+}
+function authorityArtifact(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("authority artifact shape is invalid");
+    const record = value;
+    if (JSON.stringify(Object.keys(record).sort()) !== JSON.stringify([...ARTIFACT_KEYS]))
+        throw new Error("authority artifact shape is invalid");
+    if (record.schemaVersion !== 1)
+        throw new Error("authority artifact schema is invalid");
+    if (typeof record.domain !== "string" || !record.domain)
+        throw new Error("authority artifact domain is invalid");
+    if (typeof record.keyId !== "string" || !record.keyId)
+        throw new Error("authority artifact key id is invalid");
+    if (typeof record.signature !== "string" || !BASE64URL_SIGNATURE.test(record.signature)
+        || Buffer.from(record.signature, "base64url").length !== 64
+        || Buffer.from(record.signature, "base64url").toString("base64url") !== record.signature) {
+        throw new Error("authority artifact signature is invalid");
+    }
+    canonicalAuthorityJson(record.payload);
+    return record;
+}
+function verifyAuthorityPayload(input) {
+    const artifact = authorityArtifact(input.artifact);
+    if (artifact.domain !== input.expectedDomain)
+        throw new Error("authority artifact domain changed");
+    if (artifact.keyId !== input.expectedKeyId)
+        throw new Error("authority artifact key id changed");
+    if (!(0, node_crypto_1.verify)(null, signingBytes(artifact.domain, artifact.payload), input.publicKey, Buffer.from(artifact.signature, "base64url"))) {
+        throw new Error("authority artifact signature is invalid");
+    }
+    (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.sanctuary_authority_signature_verified", message: "Sanctuary authority signature verified" });
+    return artifact.payload;
+}