@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

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

@@ -0,0 +1,2654 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proveAttemptedRecoveryWithoutRetry = void 0;
+exports.evaluateSanctuaryProviderReadinessContract = evaluateSanctuaryProviderReadinessContract;
+exports.createSanctuaryAcceptanceVaultProbeDependencies = createSanctuaryAcceptanceVaultProbeDependencies;
+exports.createSanctuaryAcceptanceAdapterDependencies = createSanctuaryAcceptanceAdapterDependencies;
+exports.createSanctuaryHealthAcceptanceScenarioDriver = createSanctuaryHealthAcceptanceScenarioDriver;
+exports.createSanctuaryInteractiveAcceptanceScenarioDriver = createSanctuaryInteractiveAcceptanceScenarioDriver;
+exports.createSanctuaryAcceptanceScenarioFinalizer = createSanctuaryAcceptanceScenarioFinalizer;
+exports.auditContainsSensitiveMaterial = auditContainsSensitiveMaterial;
+exports.canonicalDockerIdFromUnraidPrefixedId = canonicalDockerIdFromUnraidPrefixedId;
+exports.runSanctuaryProductionBoundaryProbe = runSanctuaryProductionBoundaryProbe;
+exports.createSanctuaryReadOnlyDenialScenarioDriver = createSanctuaryReadOnlyDenialScenarioDriver;
+exports.readDefaultSanctuaryScenarioFacts = readDefaultSanctuaryScenarioFacts;
+exports.callbackPlaybackSnapshot = callbackPlaybackSnapshot;
+exports.recordCallbackPlayback = recordCallbackPlayback;
+exports.executeSanctuaryAcceptanceAdapter = executeSanctuaryAcceptanceAdapter;
+exports.executeSanctuaryAcceptanceVaultProbe = executeSanctuaryAcceptanceVaultProbe;
+exports.executeSanctuaryAcceptanceRevokedProbe = executeSanctuaryAcceptanceRevokedProbe;
+exports.executeSanctuaryInteractiveRuntimeOperation = executeSanctuaryInteractiveRuntimeOperation;
+exports.executeSanctuaryAcceptanceCallbackProbe = executeSanctuaryAcceptanceCallbackProbe;
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_net_1 = require("node:net");
+const path = __importStar(require("node:path"));
+const node_util_1 = require("node:util");
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const friends_1 = require("@ouro.bot/friends");
+const runtime_1 = require("../../nerves/runtime");
+const sanctuary_authority_resident_1 = require("../../senses/sanctuary-authority-resident");
+const telegram_approval_runtime_1 = require("../../senses/telegram-approval-runtime");
+const telegram_effect_adapter_1 = require("../../senses/telegram-effect-adapter");
+const telegram_admission_1 = require("../../senses/telegram-admission");
+const sanctuary_interactive_control_1 = require("../../senses/sanctuary-interactive-control");
+const shared_turn_1 = require("../../senses/shared-turn");
+const telegram_1 = require("../../senses/telegram");
+const telegram_audit_ledger_1 = require("../../senses/telegram-audit-ledger");
+const sanctuary_runtime_1 = require("../../senses/sanctuary-runtime");
+const sanctuary_grounding_1 = require("../../senses/sanctuary-grounding");
+const tools_1 = require("../../repertoire/tools");
+const relationship_authorization_1 = require("../../repertoire/relationship-authorization");
+const core_1 = require("../core");
+const identity_1 = require("../identity");
+const approval_store_1 = require("../approval-store");
+const provider_credentials_1 = require("../provider-credentials");
+const provider_ping_1 = require("../provider-ping");
+const sanctuary_acceptance_harness_1 = require("./sanctuary-acceptance-harness");
+const sanctuary_acceptance_marker_1 = require("./sanctuary-acceptance-marker");
+const sanctuary_acceptance_scenarios_1 = require("./sanctuary-acceptance-scenarios");
+const sanctuary_scheduler_liveness_1 = require("./sanctuary-scheduler-liveness");
+const runtime_credentials_1 = require("../runtime-credentials");
+const KEY_ID = /^[A-Za-z0-9._:-]+$/u;
+const AUTH_PROBE = "query AcceptanceAuthProbe { info { os { hostname } } }";
+const WRITE_PROBE = "mutation AcceptanceWriteProbe($id: PrefixedID!) { docker { restart(id: $id) { id } } }";
+function evaluateSanctuaryProviderReadinessContract(input) {
+    return {
+        laneSelectionExact: input.outward.provider === "minimax" && input.outward.model === "MiniMax-M3"
+            && input.inner.provider === "minimax" && input.inner.model === "MiniMax-M3",
+        vaultCoordinatesExact: input.minimax.vaultItem === "providers/minimax"
+            && input.selectionPolicy === "explicit-same-lane-only",
+        singleCredentialExact: typeof input.minimax.apiKey === "string" && input.minimax.apiKey.trim().length > 0,
+    };
+}
+const MISSING_CONTAINER_ID = "Docker:ouro-acceptance-guaranteed-missing";
+// container_snapshot may execute bounded 20s inspect + 30s vault + 30s recovery
+// probes + 10s GraphQL + 20s image-policy checks sequentially in the host broker.
+const ADAPTER_TIMEOUT_MS = 240_000;
+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 CALLBACK_PLAYBACK_JOURNAL = "state/approvals/sanctuary-callback-playback.sqlite";
+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";
+const CONTAINER_DIGEST_FILE = "/run/ouro-acceptance/container-digest";
+const PROCESS_BINDING_DIGEST_FILE = "/run/ouro-acceptance/process-binding-digest";
+const POSTBOOT_HEALTH_FILE = "/run/ouro-acceptance/postboot-health.json";
+const BOOT_ID_FILE = "/run/ouro-acceptance/boot-id";
+const CONTRACT_FILE = "/opt/ouro/deploy/unraid/sanctuary-acceptance-contract.json";
+const CLOSED_INVENTORY_FILE = "/run/ouro-acceptance/closed-inventory.json";
+const HOST_BROKER_SOCKET = "/run/ouro-host-acceptance/adapter.sock";
+const MAX_BROKER_RESPONSE = 256 * 1024;
+const TARGET_SERVER_ID = "sanctuary-unraid";
+const TARGET_ID = "sanctuary";
+const SHA256 = /^[0-9a-f]{64}$/u;
+const APPROVAL_EVIDENCE_LABELS = new Set([
+    "unit-15c-1-no-callback-terminalization", "unit-16i-delayed-approval", "unit-16j-denial",
+    "unit-16k-timeout-stale", "unit-16l-duplicate-callback", "unit-16m-restart-continuation",
+]);
+const HEALTH_ACCEPTANCE_LABELS = new Set([
+    "unit-16f-cron-fingerprint",
+    "unit-16g-health-transition",
+    "unit-16h-acceptance-delivery-probe",
+]);
+const PERMISSION_RESOURCES = new Set([
+    "ACTIVATION_CODE", "API_KEY", "ARRAY", "CLOUD", "CONFIG", "CONNECT", "CONNECT__REMOTE_ACCESS",
+    "CUSTOMIZATIONS", "DASHBOARD", "DISK", "DISPLAY", "DOCKER", "FLASH", "INFO", "LOGS", "ME",
+    "NETWORK", "NOTIFICATIONS", "ONLINE", "OS", "OWNER", "PERMISSION", "REGISTRATION", "SERVERS",
+    "SERVICES", "SHARE", "VARS", "VMS", "WELCOME",
+]);
+const PERMISSION_ACTIONS = new Set(["CREATE_ANY", "CREATE_OWN", "READ_ANY", "READ_OWN", "UPDATE_ANY", "UPDATE_OWN", "DELETE_ANY", "DELETE_OWN"]);
+const RO_PERMISSIONS = ["ARRAY", "DASHBOARD", "DISK", "DOCKER", "INFO", "LOGS", "NOTIFICATIONS", "SHARE", "VARS"]
+    .map((resource) => `${resource}:READ_ANY`).sort();
+function object(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error(`${label} must be an object`);
+    return value;
+}
+function text(value, label) {
+    if (typeof value !== "string" || !value.trim())
+        throw new Error(`${label} must be nonempty text`);
+    return value.trim();
+}
+function keyId(value) {
+    const result = text(value, "keyId");
+    if (!KEY_ID.test(result))
+        throw new Error("keyId is invalid");
+    return result;
+}
+function readRawKeyDirectory(keyDirectory) {
+    return (0, node_fs_1.readdirSync)(keyDirectory, { withFileTypes: true })
+        .map((entry) => {
+        if (!entry.isFile() || !entry.name.endsWith(".json"))
+            throw new Error("unexpected key directory entry");
+        return entry;
+    })
+        .map((entry) => object(JSON.parse((0, node_fs_1.readFileSync)(`${keyDirectory}/${entry.name}`, "utf8")), "Unraid key file"));
+}
+function readKeyDirectory(keyDirectory) {
+    return readRawKeyDirectory(keyDirectory).map(normalizeKey);
+}
+function readKeyRecords(keyDirectory) {
+    return readRawKeyDirectory(keyDirectory).map((raw) => ({
+        ...normalizeKey(raw),
+        key: text(raw.key, "Unraid key descriptor"),
+    }));
+}
+function readSelectedKeyRecord(keyRecordPath) {
+    const raw = object(JSON.parse((0, node_fs_1.readFileSync)(keyRecordPath, "utf8")), "selected Unraid key file");
+    return { ...normalizeKey(raw), key: text(raw.key, "Unraid key descriptor") };
+}
+function createSanctuaryAcceptanceVaultProbeDependencies(options) {
+    const keyRecordPath = options.keyRecordPath;
+    return {
+        refresh: runtime_credentials_1.refreshMachineRuntimeCredentialConfig,
+        readKeyRecords: () => [readSelectedKeyRecord(keyRecordPath)],
+        fetch,
+    };
+}
+async function defaultExecFile(executable, args, timeoutMs) {
+    const result = (0, node_child_process_1.spawnSync)(executable, args, {
+        cwd: "/",
+        encoding: "utf8",
+        env: { PATH: "/usr/local/sbin:/usr/sbin:/usr/bin:/sbin:/bin" },
+        maxBuffer: 1_048_576,
+        timeout: timeoutMs,
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+    if (result.error && "code" in result.error && result.error.code === "ETIMEDOUT")
+        throw new Error("acceptance adapter subprocess timed out");
+    if (result.error || result.status !== 0)
+        throw new Error("acceptance adapter subprocess failed");
+    return { status: result.status, stdout: result.stdout };
+}
+async function defaultHostRequest(payload, socketPath, timeoutMs) {
+    return await new Promise((resolve, reject) => {
+        const socket = (0, node_net_1.createConnection)(socketPath);
+        let response = "";
+        const fail = () => {
+            socket.destroy();
+            reject(new Error("Sanctuary host acceptance operation failed"));
+        };
+        socket.setEncoding("utf8");
+        socket.setTimeout(timeoutMs, fail);
+        socket.on("error", fail);
+        socket.on("data", (chunk) => {
+            response += chunk;
+            if (Buffer.byteLength(response) > MAX_BROKER_RESPONSE)
+                fail();
+        });
+        socket.on("end", () => {
+            try {
+                const envelope = object(JSON.parse(response), "host broker response");
+                if (JSON.stringify(Object.keys(envelope).sort()) !== JSON.stringify(envelope.ok === true ? ["ok", "result"] : ["error", "ok"]))
+                    fail();
+                else if (envelope.ok !== true)
+                    fail();
+                else {
+                    resolve(envelope.result);
+                }
+            }
+            catch {
+                fail();
+            }
+        });
+        socket.end(`${JSON.stringify(payload)}\n`);
+    });
+}
+function acceptanceTelegramIdentity() {
+    const gateway = (0, sanctuary_authority_resident_1.openSanctuaryResidentAuthority)({}, {});
+    try {
+        return gateway.credentials;
+    }
+    finally {
+        gateway.authorityTransport.api.stop();
+    }
+}
+function createSanctuaryAcceptanceAdapterDependencies(secretFd = 3, options = {}) {
+    const keyDirectory = options.keyDirectory ?? KEY_DIRECTORY;
+    const adapterTimeoutMs = options.adapterTimeoutMs ?? ADAPTER_TIMEOUT_MS;
+    const hostBrokerSocket = options.hostBrokerSocket ?? HOST_BROKER_SOCKET;
+    const dependencies = {
+        gateway: () => (0, sanctuary_authority_resident_1.openSanctuaryResidentAuthority)({}, {}),
+        gatewayCursor: async () => {
+            const gateway = (0, sanctuary_authority_resident_1.openSanctuaryResidentAuthority)({}, {});
+            try {
+                const snapshot = await gateway.cursorSnapshot();
+                return { nextUpdateId: snapshot.cursor, progressDigest: snapshot.progressDigest };
+            }
+            finally {
+                gateway.authorityTransport.api.stop();
+            }
+        },
+        readKeyFiles: () => readKeyDirectory(keyDirectory),
+        readKeyRecords: () => readKeyRecords(keyDirectory),
+        readDescriptor: () => (0, node_fs_1.readFileSync)(secretFd, "utf8"),
+        execFile: (executable, args) => defaultExecFile(executable, args, adapterTimeoutMs),
+        fetch,
+        readFixedFile: (filePath) => (0, node_fs_1.readFileSync)(filePath, "utf8"),
+        refreshRuntime: runtime_credentials_1.refreshRuntimeCredentialConfig,
+        mergeRuntime: runtime_credentials_1.mergeRuntimeCredentialConfig,
+        refreshMachine: runtime_credentials_1.refreshMachineRuntimeCredentialConfig,
+        mergeMachine: runtime_credentials_1.mergeMachineRuntimeCredentialConfig,
+        callbackProbe: executeSanctuaryAcceptanceCallbackProbe,
+        callbackPlaybackSnapshot: (coordinateDigest) => callbackPlaybackSnapshot((0, identity_1.getAgentRoot)(TARGET_ID), coordinateDigest),
+        interactiveRuntime: executeSanctuaryInteractiveRuntimeOperation,
+        hostRequest: options.hostRequest ?? ((payload) => defaultHostRequest(payload, hostBrokerSocket, adapterTimeoutMs)),
+        telegramCredentials: acceptanceTelegramIdentity,
+        readLiveGrounding: readIndependentSanctuaryGrounding,
+        runProductionBoundaryProbe: runSanctuaryProductionBoundaryProbe,
+        providerRuntime: core_1.getProviderRuntime,
+    };
+    const healthDriver = createSanctuaryHealthAcceptanceScenarioDriver(dependencies.hostRequest);
+    const scenarioAgentRoot = options.scenarioCapture?.agentRoot ?? (0, identity_1.getAgentRoot)(TARGET_ID);
+    const interactiveDriver = createSanctuaryInteractiveAcceptanceScenarioDriver({
+        agentRoot: scenarioAgentRoot,
+        hostRequest: dependencies.hostRequest,
+    });
+    const denialDriver = createSanctuaryReadOnlyDenialScenarioDriver({
+        agentRoot: scenarioAgentRoot,
+        runProbe: (label, scenarioHandleDigest) => executeSanctuaryReadOnlyDenialProbe(label, scenarioHandleDigest, scenarioAgentRoot, dependencies),
+    });
+    dependencies.captureScenario = (0, sanctuary_acceptance_scenarios_1.createSanctuaryScenarioCapture)({
+        now: Date.now,
+        agentRoot: scenarioAgentRoot,
+        readFacts: (label, scenarioHandleDigest, readOptions) => readDefaultSanctuaryScenarioFacts(label, scenarioHandleDigest, dependencies, options.scenarioCapture?.agentRoot, readOptions),
+        healthDriver,
+        interactiveDriver,
+        denialDriver,
+        receiptRoot: options.scenarioCapture?.receiptRoot,
+        gateStatusPath: options.scenarioCapture?.gateStatusPath,
+    });
+    dependencies.finalizeScenarios = createSanctuaryAcceptanceScenarioFinalizer({
+        readActiveScenario: () => (0, sanctuary_acceptance_marker_1.readSanctuaryAcceptanceMarker)(TARGET_ID, scenarioAgentRoot),
+        recoverHealthScenario: healthDriver.recover,
+        finalizeInteractiveScenario: (label, scenarioHandleDigest) => {
+            interactiveDriver.complete(label, scenarioHandleDigest);
+            return "preserve";
+        },
+        finalizeLocal: () => (0, sanctuary_acceptance_scenarios_1.finalizeSanctuaryScenarioCapture)(options.scenarioCapture?.gateStatusPath, options.scenarioCapture?.receiptRoot, scenarioAgentRoot),
+    });
+    return dependencies;
+}
+function healthScenarioCoordinates(label, scenarioHandleDigest) {
+    if (!sanctuary_acceptance_harness_1.SANCTUARY_UNIT_16_EVIDENCE_LABELS.includes(label)
+        || !HEALTH_ACCEPTANCE_LABELS.has(label))
+        throw new Error("health probe label is invalid");
+    if (!SHA256.test(scenarioHandleDigest))
+        throw new Error("health probe scenario handle is invalid");
+    return { label: label, scenarioHandleDigest };
+}
+function ownerContainerSnapshot(value) {
+    const snapshot = object(value, "health probe owner snapshot");
+    exactKeys(snapshot, [
+        "schemaVersion", "containerId", "imageId", "running", "health", "user", "liveProcessUser", "processBindingDigest", "readOnlyRoot", "mountCount",
+        "mountsDigest", "mountsExact", "publishedPortCount", "networkMode", "securityExact", "writableKeyExposure",
+        "restartPolicy", "restartCount", "autostartExact", "updaterDisabled", "vaultUnlocked", "manualAuthRequired",
+        "recoveryMilestones",
+    ], "health probe owner snapshot");
+    const milestones = object(snapshot.recoveryMilestones, "health probe owner recovery milestones");
+    exactKeys(milestones, ["hostReady", "arrayReady", "dockerReady", "butlerReady", "tailscaleReady", "sshReady"], "health probe owner recovery milestones");
+    if (snapshot.schemaVersion !== 1 || typeof snapshot.containerId !== "string" || !SHA256.test(snapshot.containerId)
+        || typeof snapshot.imageId !== "string" || !/^sha256:[0-9a-f]{64}$/u.test(snapshot.imageId)
+        || typeof snapshot.running !== "boolean" || typeof snapshot.health !== "string" || !["healthy", "starting", "unhealthy", "missing"].includes(snapshot.health)
+        || typeof snapshot.user !== "string" || snapshot.user.length < 1 || snapshot.user.length > 64 || snapshot.liveProcessUser !== "10001:10001"
+        || typeof snapshot.processBindingDigest !== "string" || !SHA256.test(snapshot.processBindingDigest)
+        || typeof snapshot.readOnlyRoot !== "boolean" || !Number.isSafeInteger(snapshot.mountCount) || Number(snapshot.mountCount) < 0
+        || typeof snapshot.mountsDigest !== "string" || !SHA256.test(snapshot.mountsDigest) || typeof snapshot.mountsExact !== "boolean"
+        || !Number.isSafeInteger(snapshot.publishedPortCount) || Number(snapshot.publishedPortCount) < 0
+        || typeof snapshot.networkMode !== "string" || snapshot.networkMode.length < 1 || snapshot.networkMode.length > 64
+        || typeof snapshot.securityExact !== "boolean" || typeof snapshot.writableKeyExposure !== "boolean"
+        || typeof snapshot.restartPolicy !== "string" || snapshot.restartPolicy.length < 1 || snapshot.restartPolicy.length > 64
+        || !Number.isSafeInteger(snapshot.restartCount) || Number(snapshot.restartCount) < 0
+        || typeof snapshot.autostartExact !== "boolean" || typeof snapshot.updaterDisabled !== "boolean"
+        || typeof snapshot.vaultUnlocked !== "boolean" || typeof snapshot.manualAuthRequired !== "boolean"
+        || Object.values(milestones).some((entry) => typeof entry !== "boolean"))
+        throw new Error("health probe owner snapshot schema is invalid");
+    return snapshot;
+}
+function createSanctuaryHealthAcceptanceScenarioDriver(hostRequest) {
+    const payload = (operation, label, scenarioHandleDigest) => {
+        const coordinates = healthScenarioCoordinates(label, scenarioHandleDigest);
+        return { operation, targetId: TARGET_ID, ...coordinates };
+    };
+    return {
+        begin: async (label, scenarioHandleDigest) => {
+            const response = object(await hostRequest(payload("start_health_probe", label, scenarioHandleDigest)), "health probe start response");
+            exactKeys(response, ["state", "operationDigest"], "health probe start response");
+            if (response.state !== "started" || typeof response.operationDigest !== "string" || !SHA256.test(response.operationDigest)) {
+                throw new Error("health probe start response is invalid");
+            }
+        },
+        poll: async (label, scenarioHandleDigest) => {
+            const response = object(await hostRequest(payload("health_probe_status", label, scenarioHandleDigest)), "health probe status response");
+            if (response.state === "running") {
+                exactKeys(response, ["state"], "health probe status response");
+                return { state: "waiting" };
+            }
+            if (response.state === "complete") {
+                exactKeys(response, ["state", "containerSnapshot"], "health probe status response");
+                return { state: "ready", containerSnapshot: ownerContainerSnapshot(response.containerSnapshot) };
+            }
+            throw new Error("health probe status state is invalid");
+        },
+        recover: async (label, scenarioHandleDigest) => {
+            const response = object(await hostRequest(payload("recover_health_probe", label, scenarioHandleDigest)), "health probe recovery response");
+            exactKeys(response, ["recovered"], "health probe recovery response");
+            if (response.recovered !== true)
+                throw new Error("health probe recovery response is invalid");
+        },
+    };
+}
+function isInteractiveLabel(label) {
+    return label === "unit-16k-timeout-stale" || label === "unit-16l-duplicate-callback" || label === "unit-16m-restart-continuation";
+}
+function currentInteractiveProposal(records, label) {
+    const matches = records.filter(({ approval }) => (approval.state === "proposed" || (label === "unit-16k-timeout-stale" && approval.state === "expired")) && approval.toolName === "unraid_restart_container"
+        && approval.arguments.container === "calibre-web" && approval.transport === "telegram");
+    if (matches.length > 1)
+        throw new Error("interactive acceptance proposal is ambiguous");
+    return matches[0] ?? null;
+}
+function createSanctuaryInteractiveAcceptanceScenarioDriver(options) {
+    const receiptRoot = path.join(options.agentRoot, "state/acceptance/interactive-driver-receipts");
+    const receiptPath = (scenarioHandleDigest) => path.join(receiptRoot, `${scenarioHandleDigest}.json`);
+    const approvals = options.readApprovals ?? approval_store_1.readApprovalsByScenarioHandleDigest;
+    return {
+        async poll(label, scenarioHandleDigest) {
+            if (!isInteractiveLabel(label))
+                return { state: "waiting" };
+            const filePath = receiptPath(scenarioHandleDigest);
+            if ((0, node_fs_1.existsSync)(filePath)) {
+                const existing = object(JSON.parse((0, node_fs_1.readFileSync)(filePath, "utf8")), "interactive driver receipt");
+                if (existing.label !== label || existing.scenarioHandleDigest !== scenarioHandleDigest)
+                    throw new Error("interactive driver receipt binding mismatch");
+                if (existing.phase === "complete")
+                    return { state: "driven" };
+            }
+            const projection = currentInteractiveProposal(approvals(path.join(options.agentRoot, "state/approvals/approvals.sqlite"), scenarioHandleDigest), label);
+            if (!projection)
+                return { state: "waiting" };
+            const { approval } = projection;
+            if (!approval.suspendedSessionRevision || !SHA256.test(approval.checkpointDigest))
+                throw new Error("interactive acceptance checkpoint is invalid");
+            const operation = label === "unit-16k-timeout-stale" ? "drive_timeout_stale"
+                : label === "unit-16l-duplicate-callback" ? "drive_duplicate_callbacks" : "drive_restart_continuation";
+            const response = object(await options.hostRequest({ operation, targetId: TARGET_ID, label, scenarioHandleDigest }), "interactive scenario driver response");
+            if (label === "unit-16k-timeout-stale" && response.state === "waiting") {
+                exactKeys(response, ["state"], "interactive scenario driver response");
+                return { state: "waiting" };
+            }
+            if (label === "unit-16m-restart-continuation") {
+                if (response.state === "waiting") {
+                    exactKeys(response, ["state"], "interactive scenario driver response");
+                    return { state: "waiting" };
+                }
+                if (response.state === "failed") {
+                    exactKeys(response, ["state", "errorDigest"], "interactive scenario driver response");
+                    if (typeof response.errorDigest !== "string" || !SHA256.test(response.errorDigest))
+                        throw new Error("interactive scenario driver failure is invalid");
+                    throw new Error(`interactive scenario driver failed (${response.errorDigest})`);
+                }
+                exactKeys(response, ["state", "receipt"], "interactive scenario driver response");
+                if (response.state !== "complete" || !parseInteractiveDriverReceipt(JSON.stringify(response.receipt), label, scenarioHandleDigest)) {
+                    throw new Error("interactive scenario driver receipt is invalid");
+                }
+                return { state: "driven" };
+            }
+            parseInteractiveDriverReceipt(JSON.stringify(response), label, scenarioHandleDigest);
+            return { state: "driven" };
+        },
+        complete(label, scenarioHandleDigest) {
+            if (!isInteractiveLabel(label))
+                return "complete";
+            const filePath = receiptPath(scenarioHandleDigest);
+            if ((0, node_fs_1.existsSync)(filePath)) {
+                const existing = object(JSON.parse((0, node_fs_1.readFileSync)(filePath, "utf8")), "interactive driver receipt");
+                if (existing.label !== label || existing.scenarioHandleDigest !== scenarioHandleDigest)
+                    throw new Error("interactive driver receipt binding mismatch");
+                if (existing.phase !== "complete")
+                    return "preserve";
+            }
+            return "complete";
+        },
+        cleanup(label, scenarioHandleDigest) {
+            if (!isInteractiveLabel(label))
+                return;
+            const filePath = receiptPath(scenarioHandleDigest);
+            if (!(0, node_fs_1.existsSync)(filePath))
+                return;
+            const existing = object(JSON.parse((0, node_fs_1.readFileSync)(filePath, "utf8")), "interactive driver receipt");
+            if (existing.label !== label || existing.scenarioHandleDigest !== scenarioHandleDigest || existing.phase !== "complete") {
+                throw new Error("interactive driver receipt is not cleanup-ready");
+            }
+            (0, node_fs_1.unlinkSync)(filePath);
+            const directory = (0, node_fs_1.openSync)(receiptRoot, "r");
+            try {
+                (0, node_fs_1.fsyncSync)(directory);
+            }
+            finally {
+                (0, node_fs_1.closeSync)(directory);
+            }
+        },
+    };
+}
+function createSanctuaryAcceptanceScenarioFinalizer(dependencies) {
+    const appendErrorLeaves = (errors, error) => {
+        if (error instanceof AggregateError) {
+            for (const nested of error.errors)
+                appendErrorLeaves(errors, nested);
+        }
+        else
+            errors.push(error);
+    };
+    return async () => {
+        const errors = [];
+        let active = null;
+        try {
+            active = dependencies.readActiveScenario();
+        }
+        catch (error) {
+            appendErrorLeaves(errors, error);
+        }
+        if (active && HEALTH_ACCEPTANCE_LABELS.has(active.label)) {
+            try {
+                await dependencies.recoverHealthScenario(active.label, active.scenarioHandleDigest);
+            }
+            catch (error) {
+                appendErrorLeaves(errors, error);
+            }
+        }
+        let preserveInteractive = false;
+        if (active && isInteractiveLabel(active.label) && dependencies.finalizeInteractiveScenario) {
+            preserveInteractive = true;
+            try {
+                await dependencies.finalizeInteractiveScenario(active.label, active.scenarioHandleDigest);
+            }
+            catch (error) {
+                appendErrorLeaves(errors, error);
+            }
+        }
+        if (preserveInteractive)
+            errors.push(new Error("interactive scenario requires inspect-before-retry"));
+        else
+            try {
+                dependencies.finalizeLocal();
+            }
+            catch (error) {
+                appendErrorLeaves(errors, error);
+            }
+        if (errors.length > 0)
+            throw new AggregateError(errors, preserveInteractive
+                ? "Sanctuary scenario recovery and finalization failed: interactive scenario requires inspect-before-retry"
+                : "Sanctuary scenario recovery and finalization failed");
+    };
+}
+function optionalFixedFile(deps, filePath) {
+    try {
+        return deps.readFixedFile ? deps.readFixedFile(filePath) : (0, node_fs_1.readFileSync)(filePath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+function parsedJson(raw) {
+    if (raw === null)
+        return null;
+    return object(JSON.parse(raw), "scenario source");
+}
+async function projectTelegramAdmissions(agentRoot, credentials, identityKey) {
+    const admissionsRoot = path.join(agentRoot, "state", "senses", "telegram", "admissions");
+    const effectsRoot = path.join(agentRoot, "state", "telegram", "effects");
+    if (!(0, node_fs_1.existsSync)(admissionsRoot) || !(0, node_fs_1.existsSync)(effectsRoot) || !identityKey || !/^[A-Za-z0-9_-]{43}$/u.test(identityKey))
+        return [];
+    const admissionStore = new telegram_admission_1.FileTelegramAdmissionStore(admissionsRoot);
+    const effectStore = new telegram_effect_adapter_1.FileTelegramEffectJournal(effectsRoot);
+    try {
+        const effects = new Map(effectStore.list().map((artifact) => [artifact.id, artifact]));
+        const botId = credentials.botId;
+        const ownerSessionKey = `telegram:${(0, telegram_1.opaqueTelegramSubject)(identityKey, botId, credentials.authorizedUserId, credentials.authorizedChatId)}`;
+        const friendsRoot = path.join(agentRoot, "friends");
+        const friendStore = (0, node_fs_1.existsSync)(friendsRoot) ? new friends_1.FileFriendStore(friendsRoot) : null;
+        const owner = friendStore ? await friendStore.findByExternalId("telegram-user", credentials.authorizedUserId, botId) : null;
+        const exactSameBotIdentity = (friend, userId) => {
+            const bindings = friend.externalIds.filter((external) => external.provider === "telegram-user" && external.tenantId === botId);
+            return bindings.length === 1 && bindings[0].externalId === userId;
+        };
+        const ownerExact = Boolean(owner && exactSameBotIdentity(owner, credentials.authorizedUserId) && owner.trustLevel === "family" && owner.admissionState === "active"
+            && owner.initiativePolicy === "proactive" && owner.capabilityProfileId === "sanctuary-owner");
+        const projections = await Promise.all(admissionStore.list().map(async (record) => {
+            const acknowledgement = record.acknowledgementArtifactId ? effects.get(record.acknowledgementArtifactId) : undefined;
+            const ownerCard = record.ownerCardArtifactId ? effects.get(record.ownerCardArtifactId) : undefined;
+            const expectedButtons = [[
+                    { text: "Allow", callbackData: `admit:${record.id}:allow` },
+                    { text: "Deny", callbackData: `admit:${record.id}:deny` },
+                    { text: "Block", callbackData: `admit:${record.id}:block` },
+                ]];
+            const admittedFriend = friendStore ? await friendStore.findByExternalId("telegram-user", record.userId, record.botId) : null;
+            const acknowledgementExact = Boolean(acknowledgement?.idempotencyKey === `ack:${record.id}`
+                && acknowledgement.authorClass === "control" && acknowledgement.target.kind === "admission_gate"
+                && acknowledgement.target.admissionId === record.id && acknowledgement.target.botId === record.botId
+                && acknowledgement.target.userId === record.userId && acknowledgement.target.chatId === record.chatId
+                && acknowledgement.effect.kind === "admission_ack" && acknowledgement.effect.text === telegram_effect_adapter_1.FIXED_ADMISSION_ACKNOWLEDGEMENT
+                && acknowledgement.parts.every((part) => part.state === "accepted" || part.state === "session_recorded"));
+            const ownerCardExact = Boolean(ownerExact && owner && ownerCard?.idempotencyKey === `owner-card:${record.id}`
+                && ownerCard.authorClass === "control" && ownerCard.target.kind === "approved_relationship"
+                && ownerCard.target.friendId === owner.id && ownerCard.target.sessionKey === ownerSessionKey && ownerCard.target.requestId === record.id
+                && ownerCard.effect.kind === "card" && ownerCard.effect.text.startsWith("Unknown Telegram contact\n")
+                && ownerCard.effect.text.includes("The message is quarantined and has not been processed.")
+                && JSON.stringify(ownerCard.effect.buttons) === JSON.stringify(expectedButtons)
+                && ownerCard.parts.every((part) => part.state === "session_recorded"));
+            return {
+                admissionDigest: (0, telegram_1.sanctuaryTelegramTurnReceiptDigest)(identityKey, "sanctuary-telegram-turn-receipt-v3", "admission", `${record.id}\0${record.botId}\0${record.userId}\0${record.chatId}\0${record.updateId}\0${record.messageId}`),
+                status: record.status,
+                identityExact: record.botId === botId && record.userId === record.chatId && record.userId !== credentials.authorizedUserId,
+                acknowledgementExact,
+                ownerCardExact,
+                contentQuarantined: typeof record.quarantinedText === "string" && (0, node_crypto_1.createHash)("sha256").update(record.quarantinedText).digest("hex") === record.contentDigest,
+                relationshipAbsent: record.friendId === null && admittedFriend === null,
+                capturedAt: record.createdAt,
+                updatedAt: record.updatedAt,
+            };
+        }));
+        return projections.sort((left, right) => left.admissionDigest.localeCompare(right.admissionDigest));
+    }
+    finally {
+        admissionStore.close();
+        effectStore.close();
+    }
+}
+function canonicalIso(value) {
+    return typeof value === "string" && value.length <= 30 && Number.isFinite(Date.parse(value)) && new Date(Date.parse(value)).toISOString() === value;
+}
+function boundedLines(raw, label, limits) {
+    if (Buffer.byteLength(raw) > limits.bytes)
+        throw new Error(`${label} exceeds its bound`);
+    const lines = raw.split("\n").filter(Boolean);
+    if (lines.length > limits.rows || lines.some((line) => Buffer.byteLength(line) > limits.rowBytes))
+        throw new Error(`${label} exceeds its bound`);
+    return lines;
+}
+function parseRestartAttempts(raw, scenarioHandleDigest) {
+    const exactKeys = ["actionDigest", "afterState", "approvalId", "argumentDigest", "attemptId", "beforeState", "container", "mutationAcknowledged", "observedAt", "scenarioHandleDigest", "state"].sort();
+    return boundedLines(raw, "restart attempt ledger", { bytes: 4 * 1024 * 1024, rows: 500, rowBytes: 8 * 1024 }).flatMap((line) => {
+        const attempt = object(JSON.parse(line), "restart attempt");
+        const containerRecord = object(attempt.container, "restart target");
+        if (JSON.stringify(Object.keys(attempt).sort()) !== JSON.stringify(exactKeys)
+            || JSON.stringify(Object.keys(containerRecord).sort()) !== JSON.stringify(["id", "name"])
+            || typeof containerRecord.id !== "string" || containerRecord.id.length < 1 || containerRecord.id.length > 128
+            || typeof containerRecord.name !== "string" || containerRecord.name.length < 1 || containerRecord.name.length > 128
+            || !["attempt_not_started", "attempting", "succeeded", "attempted_or_indeterminate"].includes(String(attempt.state))
+            || !canonicalIso(attempt.observedAt) || !SHA256.test(String(attempt.actionDigest)) || !SHA256.test(String(attempt.argumentDigest))
+            || typeof attempt.scenarioHandleDigest !== "string" || !SHA256.test(attempt.scenarioHandleDigest)
+            || typeof attempt.approvalId !== "string" || attempt.approvalId.length < 1 || attempt.approvalId.length > 128
+            || typeof attempt.attemptId !== "string" || attempt.attemptId.length < 1 || attempt.attemptId.length > 128
+            || typeof attempt.beforeState !== "string" || attempt.beforeState.length > 64 || typeof attempt.mutationAcknowledged !== "boolean"
+            || (attempt.afterState !== null && (typeof attempt.afterState !== "string" || attempt.afterState.length > 64)))
+            throw new Error("restart attempt ledger row is invalid");
+        if (scenarioHandleDigest !== null && attempt.scenarioHandleDigest !== scenarioHandleDigest)
+            return [];
+        return [{ state: attempt.state, actionDigest: String(attempt.actionDigest), argumentDigest: String(attempt.argumentDigest), target: containerRecord.name, targetId: containerRecord.id, beforeState: attempt.beforeState, scenarioHandleDigest: attempt.scenarioHandleDigest, approvalId: attempt.approvalId, attemptId: attempt.attemptId, observedAt: Date.parse(attempt.observedAt), mutationAcknowledged: attempt.mutationAcknowledged, afterState: attempt.afterState }];
+    });
+}
+function parseHealthAcceptanceState(raw) {
+    if (raw === null)
+        return null;
+    if (Buffer.byteLength(raw) > 4 * 1024 * 1024)
+        throw new Error("Sanctuary health state exceeds its bound");
+    const health = object(JSON.parse(raw), "Sanctuary health state");
+    const rootKeys = ["deliveredReceipts", "incidents", "indeterminateDeliveries", "lastDigestDay", "outbox", "sweepReceipts", "updatedAt"].sort();
+    if (JSON.stringify(Object.keys(health).sort()) !== JSON.stringify(rootKeys)
+        || !health.incidents || typeof health.incidents !== "object" || Array.isArray(health.incidents)
+        || (health.lastDigestDay !== null && typeof health.lastDigestDay !== "string") || !canonicalIso(health.updatedAt)
+        || (health.outbox !== null && (typeof health.outbox !== "object" || Array.isArray(health.outbox)))
+        || !Array.isArray(health.indeterminateDeliveries))
+        throw new Error("Sanctuary health state schema is invalid");
+    if (!Array.isArray(health.deliveredReceipts) || health.deliveredReceipts.length > 100 || !health.deliveredReceipts.every((rawReceipt) => {
+        const receipt = object(rawReceipt, "health delivery receipt");
+        return JSON.stringify(Object.keys(receipt).sort()) === JSON.stringify(["deliveredAt", "deliveryId", "kind", "messageIds"])
+            && typeof receipt.deliveryId === "string" && receipt.deliveryId.length > 0 && receipt.deliveryId.length <= 128
+            && ["transition", "digest", "transition_and_digest", "legacy_unknown"].includes(String(receipt.kind)) && canonicalIso(receipt.deliveredAt)
+            && Array.isArray(receipt.messageIds) && receipt.messageIds.length > 0 && receipt.messageIds.length <= 100 && receipt.messageIds.every((id) => Number.isSafeInteger(id) && Number(id) > 0);
+    }))
+        throw new Error("Sanctuary health delivery receipts are invalid");
+    if (!Array.isArray(health.sweepReceipts) || health.sweepReceipts.length > 500 || !health.sweepReceipts.every((rawReceipt) => {
+        const receipt = object(rawReceipt, "health sweep receipt");
+        const expectedKeys = ["completedAt", "digestDue", "incidentDigest", "opened", "recovered", "startedAt", "sweepId", ...(receipt.deliveryId === undefined ? [] : ["deliveryId"]), ...(receipt.scenarioHandleDigest === undefined ? [] : ["scenarioHandleDigest"])].sort();
+        return JSON.stringify(Object.keys(receipt).sort()) === JSON.stringify(expectedKeys)
+            && typeof receipt.sweepId === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u.test(receipt.sweepId)
+            && canonicalIso(receipt.startedAt) && canonicalIso(receipt.completedAt) && typeof receipt.incidentDigest === "string" && SHA256.test(receipt.incidentDigest)
+            && Number.isSafeInteger(receipt.opened) && Number(receipt.opened) >= 0 && Number.isSafeInteger(receipt.recovered) && Number(receipt.recovered) >= 0 && typeof receipt.digestDue === "boolean"
+            && (receipt.deliveryId === undefined || (typeof receipt.deliveryId === "string" && receipt.deliveryId.length > 0 && receipt.deliveryId.length <= 128))
+            && (receipt.scenarioHandleDigest === undefined || (typeof receipt.scenarioHandleDigest === "string" && SHA256.test(receipt.scenarioHandleDigest)));
+    }))
+        throw new Error("Sanctuary health sweep receipts are invalid");
+    return health;
+}
+function buildPostbootIntegritySnapshot(input) {
+    const canonical = (value) => {
+        if (Array.isArray(value))
+            return `[${value.map(canonical).join(",")}]`;
+        if (value && typeof value === "object")
+            return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
+        return JSON.stringify(value);
+    };
+    const digest = (value) => (0, node_crypto_1.createHash)("sha256").update(canonical(value)).digest("hex");
+    const checkpoints = input.checkpointsRaw === null ? {} : object(JSON.parse(input.checkpointsRaw), "approval checkpoint state");
+    const approvalCheckpoints = Object.entries(checkpoints).map(([id, record]) => ({ idDigest: digest(id), recordDigest: digest(record) }))
+        .sort((left, right) => left.idDigest.localeCompare(right.idDigest));
+    const sweeps = (input.health?.sweepReceipts ?? []).map((row) => ({
+        idDigest: digest(row.sweepId), recordDigest: digest(row), scenarioHandleDigest: typeof row.scenarioHandleDigest === "string" ? row.scenarioHandleDigest : null,
+        deliveryIdDigest: typeof row.deliveryId === "string" ? digest(row.deliveryId) : null,
+    }));
+    const deliveries = (input.health?.deliveredReceipts ?? []).map((row) => ({ idDigest: digest(row.deliveryId), recordDigest: digest(row) }));
+    const scenarioRelevantEvents = new Set(["telegram.callback_settled", "telegram.update_dropped", "approval.acceptance_transition", "senses.sanctuary_read_receipt", "senses.telegram_approved_restart_end"]);
+    const restartAttempts = input.restartAttempts.map((row) => ({
+        idDigest: digest(row.attemptId), recordDigest: digest(row), state: row.state,
+    }));
+    return {
+        schemaVersion: "sanctuary-postboot-integrity-v2", activeScenarioHandleDigest: input.activeScenarioHandleDigest,
+        telegramNextUpdateId: input.telegramNextUpdateId, approvalCheckpoints,
+        approvalExecutionCount: new Set(restartAttempts.filter((row) => row.state !== "attempt_not_started").map((row) => row.idDigest)).size, restartAttempts,
+        fingerprintDigest: digest(input.cronRaw), sweeps, deliveries,
+        audits: input.auditLedgerEntries.map((row) => ({ idDigest: digest(row), recordDigest: digest(row), scenarioHandleDigest: typeof row.meta.scenarioHandleDigest === "string" ? row.meta.scenarioHandleDigest : null, scenarioRelevant: scenarioRelevantEvents.has(row.event) })),
+    };
+}
+function parseHealthProbeReceipt(raw, label, scenarioHandleDigest, identityKey) {
+    if (raw === null)
+        return undefined;
+    if (Buffer.byteLength(raw) > 128 * 1024)
+        throw new Error("Sanctuary health probe receipt exceeds its bound");
+    const receipt = object(JSON.parse(raw), "Sanctuary health probe receipt");
+    const exactKeys = ["acceptanceOnly", "beforeStateDigest", "clockMode", "cronDegradedAfter", "cronDegradedBefore", "cronFingerprintAfter", "cronFingerprintBefore", "cronRegisteredAfter", "cronRegisteredBefore", "deliveryCount", "effectiveNow", "fixtureSequenceDigest", "label", "ownerContainerDigestAfter", "ownerContainerDigestBefore", "ownerImageDigestAfter", "ownerImageDigestBefore", "phases", "privateTurnCount", "productionRestored", "productionScheduleChanged", "providerInvocationCount", "realCheckEquivalent", "restoredStateDigest", "scenarioHandleDigest", "schedulerReceipt", "schemaVersion", "snapshotAbsent", "socketAbsent", "workspaceAbsent"].sort();
+    const supportedLabel = label === "unit-16f-cron-fingerprint" || label === "unit-16g-health-transition" || label === "unit-16h-acceptance-delivery-probe";
+    const digestFields = ["ownerImageDigestBefore", "ownerImageDigestAfter", "ownerContainerDigestBefore", "ownerContainerDigestAfter", "beforeStateDigest", "restoredStateDigest", "cronFingerprintBefore", "cronFingerprintAfter", "fixtureSequenceDigest"];
+    const booleanFields = ["acceptanceOnly", "productionScheduleChanged", "cronRegisteredBefore", "cronRegisteredAfter", "cronDegradedBefore", "cronDegradedAfter", "workspaceAbsent", "socketAbsent", "snapshotAbsent", "realCheckEquivalent", "productionRestored"];
+    if (!supportedLabel || JSON.stringify(Object.keys(receipt).sort()) !== JSON.stringify(exactKeys) || receipt.schemaVersion !== "sanctuary-health-probe-receipt-v1"
+        || receipt.label !== label || receipt.scenarioHandleDigest !== scenarioHandleDigest || !SHA256.test(scenarioHandleDigest)
+        || !digestFields.every((field) => typeof receipt[field] === "string" && SHA256.test(receipt[field]))
+        || !booleanFields.every((field) => typeof receipt[field] === "boolean") || !canonicalIso(receipt.effectiveNow)
+        || (receipt.clockMode !== "ambient" && receipt.clockMode !== "local-daily-boundary")
+        || !Number.isSafeInteger(receipt.privateTurnCount) || Number(receipt.privateTurnCount) < 0 || Number(receipt.privateTurnCount) > 1_000
+        || !Number.isSafeInteger(receipt.providerInvocationCount) || Number(receipt.providerInvocationCount) < Number(receipt.privateTurnCount) || Number(receipt.providerInvocationCount) > 1_000
+        || !Number.isSafeInteger(receipt.deliveryCount) || Number(receipt.deliveryCount) < 0 || Number(receipt.deliveryCount) > 1_000
+        || !Array.isArray(receipt.phases) || receipt.phases.length < 1 || receipt.phases.length > 8)
+        throw new Error("Sanctuary health probe receipt schema is invalid");
+    const phases = receipt.phases.map((rawPhase, index) => {
+        const phase = object(rawPhase, "Sanctuary health probe phase");
+        const phaseKeys = ["deliveryKind", "deliveryReceiptDigest", "digestDue", "fixtureStatus", "name", "opened", "ordinal", "recovered", "sweepReceiptDigest", "trigger"].sort();
+        if (JSON.stringify(Object.keys(phase).sort()) !== JSON.stringify(phaseKeys) || phase.ordinal !== index + 1
+            || typeof phase.name !== "string" || phase.name.length < 1 || phase.name.length > 64 || (phase.trigger !== "cron" && phase.trigger !== "acceptance")
+            || (phase.fixtureStatus !== null && phase.fixtureStatus !== 200 && phase.fixtureStatus !== 503)
+            || !Number.isSafeInteger(phase.opened) || Number(phase.opened) < 0 || !Number.isSafeInteger(phase.recovered) || Number(phase.recovered) < 0
+            || typeof phase.digestDue !== "boolean" || (phase.deliveryKind !== null && !["transition", "digest", "transition_and_digest"].includes(String(phase.deliveryKind)))
+            || typeof phase.sweepReceiptDigest !== "string" || !SHA256.test(phase.sweepReceiptDigest)
+            || (phase.deliveryReceiptDigest !== null && (typeof phase.deliveryReceiptDigest !== "string" || !SHA256.test(phase.deliveryReceiptDigest))))
+            throw new Error("Sanctuary health probe phase is invalid");
+        return phase;
+    });
+    const fixtureSequence = phases.flatMap((phase) => phase.fixtureStatus === null ? [] : [phase.fixtureStatus]);
+    const expectedSequenceDigest = (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(fixtureSequence)).digest("hex");
+    const deliveryCount = phases.filter((phase) => phase.deliveryReceiptDigest !== null).length;
+    if (receipt.fixtureSequenceDigest !== expectedSequenceDigest || receipt.deliveryCount !== deliveryCount)
+        throw new Error("Sanctuary health probe receipt counters are invalid");
+    if (label === "unit-16f-cron-fingerprint") {
+        const scheduler = object(receipt.schedulerReceipt, "Sanctuary scheduler liveness receipt");
+        const schedulerKeys = ["after", "before", "deliveryDelta", "label", "nonReplay", "occurrenceId", "privateTurnCount", "providerInvocationCount", "receiptMac", "recordedAt", "runnerId", "scenarioHandleDigest", "schedulerOrigin", "schemaVersion", "supervisor", "sweep", "sweepDelta", "trigger"].sort();
+        const supervisor = object(scheduler.supervisor, "Sanctuary scheduler supervisor snapshot");
+        const supervisorKeys = ["args", "binaryPath", "childCount", "childPid", "crontabPath", "daemonPid", "healthy", "manifest", "namespace", "renderedCrontab", "schemaVersion"].sort();
+        const before = object(scheduler.before, "Sanctuary scheduler before cursor");
+        const after = object(scheduler.after, "Sanctuary scheduler after cursor");
+        const sweep = object(scheduler.sweep, "Sanctuary scheduler sweep");
+        if (!Array.isArray(supervisor.manifest) || supervisor.manifest.length !== 1)
+            throw new Error("Sanctuary scheduler liveness receipt is invalid");
+        const manifest = supervisor.manifest;
+        const manifestJob = object(manifest[0], "Sanctuary scheduler manifest job");
+        const origin = object(scheduler.schedulerOrigin, "Sanctuary scheduler origin");
+        const manifestKeys = ["agent", "command", "id", "lastRun", "schedule", "taskId", "taskPath"].sort();
+        if (!identityKey || !(0, sanctuary_scheduler_liveness_1.verifySanctuarySchedulerLivenessReceiptMac)(identityKey, scheduler)
+            || JSON.stringify(Object.keys(scheduler).sort()) !== JSON.stringify(schedulerKeys)
+            || scheduler.schemaVersion !== "sanctuary-scheduler-liveness-receipt-v1" || scheduler.label !== label || scheduler.scenarioHandleDigest !== scenarioHandleDigest
+            || scheduler.trigger !== "cron" || typeof scheduler.occurrenceId !== "string" || scheduler.occurrenceId.length === 0
+            || typeof scheduler.runnerId !== "string" || !/^[0-9a-f-]{36}$/u.test(scheduler.runnerId) || !canonicalIso(scheduler.recordedAt)
+            || JSON.stringify(Object.keys(before).sort()) !== JSON.stringify(["deliveryCount", "sweepCount"])
+            || JSON.stringify(Object.keys(after).sort()) !== JSON.stringify(["deliveryCount", "sweepCount"])
+            || !Number.isSafeInteger(before.sweepCount) || !Number.isSafeInteger(before.deliveryCount)
+            || after.sweepCount !== Number(before.sweepCount) + 1 || after.deliveryCount !== before.deliveryCount
+            || scheduler.sweepDelta !== 1 || scheduler.deliveryDelta !== 0 || scheduler.providerInvocationCount !== 0 || scheduler.privateTurnCount !== 0 || scheduler.nonReplay !== true
+            || JSON.stringify(Object.keys(sweep).sort()) !== JSON.stringify(["deliveryId", "digestDue", "opened", "recordDigest", "recovered"])
+            || typeof sweep.recordDigest !== "string" || !SHA256.test(sweep.recordDigest) || sweep.opened !== 0 || sweep.recovered !== 0 || sweep.digestDue !== false || sweep.deliveryId !== null
+            || JSON.stringify(Object.keys(supervisor).sort()) !== JSON.stringify(supervisorKeys) || supervisor.schemaVersion !== "supercronic-supervisor-snapshot-v1"
+            || !Number.isSafeInteger(supervisor.daemonPid) || Number(supervisor.daemonPid) !== 1 || supervisor.childCount !== 1 || !Number.isSafeInteger(supervisor.childPid) || Number(supervisor.childPid) <= 1 || supervisor.healthy !== true
+            || supervisor.binaryPath !== "/usr/local/bin/supercronic" || supervisor.crontabPath !== "/home/ouro/.ouro-cli/scheduler/sanctuary.crontab"
+            || JSON.stringify(supervisor.args) !== JSON.stringify(["-split-logs", "-inotify", "/home/ouro/.ouro-cli/scheduler/sanctuary.crontab"])
+            || supervisor.namespace !== "habit:sanctuary" || manifestJob.id !== "sanctuary:sanctuary-health" || manifestJob.agent !== "sanctuary"
+            || JSON.stringify(Object.keys(manifestJob).sort()) !== JSON.stringify(manifestKeys)
+            || manifestJob.taskId !== "sanctuary-health" || manifestJob.schedule !== "*/15 * * * *" || sweep.recordDigest !== phases[0]?.sweepReceiptDigest
+            || manifestJob.taskPath !== "/home/ouro/AgentBundles/sanctuary.ouro/habits/sanctuary-health.md"
+            || manifestJob.command !== "/usr/local/bin/node /opt/ouro/dist/heart/daemon/ouro-entry.js poke sanctuary --habit sanctuary-health --trigger cron"
+            || JSON.stringify(Object.keys(origin).sort()) !== JSON.stringify(["invocationPid", "invocationStartTime", "occurrenceId", "parentPid", "parentStartTime", "proofMac", "scenarioHandleDigest", "schedulerRunId", "slot"].sort())
+            || origin.parentPid !== supervisor.childPid || typeof origin.slot !== "string" || scheduler.occurrenceId !== `cron:${origin.slot}` || origin.occurrenceId !== scheduler.occurrenceId
+            || origin.scenarioHandleDigest !== scenarioHandleDigest
+            || typeof origin.schedulerRunId !== "string" || !/^[0-9a-f-]{36}$/u.test(origin.schedulerRunId) || typeof origin.proofMac !== "string" || !SHA256.test(origin.proofMac))
+            throw new Error("Sanctuary scheduler liveness receipt is invalid");
+    }
+    else if (receipt.schedulerReceipt !== null)
+        throw new Error("Sanctuary health probe has an unexpected scheduler receipt");
+    if (receipt.ownerImageDigestBefore !== receipt.ownerImageDigestAfter || receipt.ownerContainerDigestBefore !== receipt.ownerContainerDigestAfter
+        || (label !== "unit-16f-cron-fingerprint" && receipt.beforeStateDigest !== receipt.restoredStateDigest) || receipt.cronFingerprintBefore !== receipt.cronFingerprintAfter
+        || receipt.cronRegisteredBefore !== true || receipt.cronRegisteredAfter !== true || receipt.cronDegradedBefore !== false || receipt.cronDegradedAfter !== false
+        || receipt.acceptanceOnly !== true || receipt.productionScheduleChanged !== false || receipt.workspaceAbsent !== true || receipt.socketAbsent !== true || receipt.snapshotAbsent !== true || receipt.realCheckEquivalent !== true || receipt.productionRestored !== true) {
+        throw new Error("Sanctuary health probe did not restore its exact production owner and state");
+    }
+    if (label === "unit-16h-acceptance-delivery-probe") {
+        const effective = new Date(receipt.effectiveNow);
+        const parts = new Intl.DateTimeFormat("en-US", { timeZone: "America/Los_Angeles", hour: "2-digit", minute: "2-digit", second: "2-digit", hourCycle: "h23" }).formatToParts(effective);
+        const part = (type) => Number(parts.find((entry) => entry.type === type).value);
+        if (receipt.clockMode !== "local-daily-boundary" || part("hour") !== 9 || part("minute") !== 0 || part("second") !== 0 || effective.getUTCMilliseconds() !== 0)
+            throw new Error("Sanctuary health digest clock is not the exact local daily boundary");
+    }
+    else if (receipt.clockMode !== "ambient")
+        throw new Error("Sanctuary health probe clock mode is invalid");
+    const { schemaVersion: _schemaVersion, ...validated } = receipt;
+    return { ...validated, phases };
+}
+function auditContainsSensitiveMaterial(raw, credentials) {
+    const knownValues = credentials ? [credentials.botToken ?? "", credentials.authorizedUserId, credentials.authorizedChatId] : [];
+    return knownValues.some((value) => value.length > 0 && raw.includes(value))
+        || /\b\d{5,16}:[A-Za-z0-9_-]{20,}\b/u.test(raw)
+        || /"(?:authorized_?user_?id|authorized_?chat_?id|transport_?user_?id|transport_?chat_?id|user_?id|chat_?id|update_?id|message_?id)"\s*:\s*"?\d{5,16}"?/iu.test(raw)
+        || /"(?:botToken|apiKey|password|secret)"\s*:\s*"(?!\[REDACTED\])[^"\n]+"/u.test(raw)
+        || /\b(?:bearer\s+|sk-|AIza|xox[baprs]-)[A-Za-z0-9_-]{10,}\b/iu.test(raw)
+        || /\b(?:api[_ -]?key|token|secret|password)\s*[:=]\s*(?!\[REDACTED\])\S{8,}/iu.test(raw);
+}
+function millisecondsAfterLocalNine(timestamp) {
+    const parts = new Intl.DateTimeFormat("en-US", { timeZone: "America/Los_Angeles", hour: "2-digit", minute: "2-digit", second: "2-digit", hourCycle: "h23" }).formatToParts(new Date(timestamp));
+    const value = (type) => Number(parts.find((part) => part.type === type).value);
+    const milliseconds = ((value("hour") - 9) * 60 * 60 + value("minute") * 60 + value("second")) * 1_000;
+    return milliseconds >= 0 ? milliseconds : null;
+}
+function canonicalSanctuaryHealthCronRegistered(raw) {
+    const lines = raw.split(/\r?\n/u);
+    const marker = "# ouro:habit:sanctuary:sanctuary:sanctuary-health";
+    const command = "*/15 * * * * /usr/local/bin/node /opt/ouro/dist/heart/daemon/ouro-entry.js poke sanctuary --habit sanctuary-health --trigger cron";
+    const index = lines.indexOf(marker);
+    return index >= 0 && lines[index + 1] === command;
+}
+function readBoundedIdentitySurfaces(agentRoot) {
+    const roots = [
+        pathFor(agentRoot, "state/senses/telegram/identity-subjects.json"),
+        pathFor(agentRoot, "friends"),
+        pathFor(agentRoot, "state/sessions"),
+        pathFor(agentRoot, "state/pending"),
+        pathFor(agentRoot, "state/pending-returns"),
+        pathFor(agentRoot, "state/daemon/logs"),
+    ];
+    const records = [];
+    let totalBytes = 0;
+    let visitedFiles = 0;
+    const visit = (target, depth) => {
+        if (depth > 6)
+            throw new Error("identity surface audit exceeds its depth bound");
+        try {
+            const entries = (0, node_fs_1.readdirSync)(target, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name));
+            for (const entry of entries) {
+                if (entry.isSymbolicLink())
+                    throw new Error("identity surface audit refuses symbolic links");
+                const child = pathFor(target, entry.name);
+                if (entry.isDirectory())
+                    visit(child, depth + 1);
+                else if (entry.isFile()) {
+                    visitedFiles += 1;
+                    if (visitedFiles > 2_000)
+                        throw new Error("identity surface audit exceeds its file-count bound");
+                    const raw = (0, node_fs_1.readFileSync)(child, "utf8");
+                    totalBytes += Buffer.byteLength(raw);
+                    if (totalBytes > 16 * 1024 * 1024 || Buffer.byteLength(raw) > 1024 * 1024)
+                        throw new Error("identity surface audit exceeds its bound");
+                    if (entry.name.endsWith(".json"))
+                        JSON.parse(raw);
+                    records.push(path.relative(agentRoot, child), raw);
+                }
+                else
+                    throw new Error("identity surface audit found an unsupported filesystem entry");
+            }
+        }
+        catch (error) {
+            if (error.code === "ENOENT" || error.code === "ENOTDIR") {
+                try {
+                    const raw = (0, node_fs_1.readFileSync)(target, "utf8");
+                    totalBytes += Buffer.byteLength(raw);
+                    if (totalBytes > 16 * 1024 * 1024 || Buffer.byteLength(raw) > 1024 * 1024)
+                        throw new Error("identity surface audit exceeds its bound");
+                    JSON.parse(raw);
+                    records.push(path.relative(agentRoot, target), raw);
+                }
+                catch (fileError) {
+                    if (fileError.code !== "ENOENT")
+                        throw fileError;
+                }
+            }
+            else
+                throw error;
+        }
+    };
+    for (const root of roots)
+        visit(root, 0);
+    return records;
+}
+function parseTelegramTurnReceipts(raw, scenarioHandleDigest, identityKey) {
+    if (Buffer.byteLength(raw) > 4 * 1024 * 1024)
+        throw new Error("Telegram turn receipt ledger exceeds its bound");
+    const lines = raw.split("\n").filter(Boolean);
+    if (lines.length > 500 || lines.some((line) => Buffer.byteLength(line) > 16 * 1024))
+        throw new Error("Telegram turn receipt ledger exceeds its bound");
+    return lines.flatMap((line) => {
+        const receipt = object(JSON.parse(line), "Telegram turn receipt");
+        const grounded = receipt.schemaVersion === "sanctuary-telegram-turn-receipt-v4";
+        const exactKeys = ["completedAt", "deliveries", "deliveryCount", "errorCategory", "providerInvocationCount", "responseDigest", "scenarioHandleDigest", "schemaVersion", "sequenceDigest", "status", "toolInvocationCount", "toolResultDigests", "updateDigest", ...(grounded ? ["receiptMac", "toolGroundings"] : [])].sort();
+        const deliveries = receipt.deliveries;
+        const authenticatedDeliveries = grounded && typeof identityKey === "string" && /^[A-Za-z0-9_-]{43}$/u.test(identityKey) && Array.isArray(deliveries)
+            && deliveries.every((value) => {
+                const delivery = object(value, "Telegram authenticated delivery receipt");
+                return typeof delivery.redactedText === "string" && delivery.chunkDigest === (0, telegram_1.sanctuaryTelegramTurnReceiptDigest)(identityKey, "sanctuary-telegram-turn-receipt-v4", "chunk", delivery.redactedText);
+            })
+            && receipt.responseDigest === (0, telegram_1.sanctuaryTelegramTurnReceiptDigest)(identityKey, "sanctuary-telegram-turn-receipt-v4", "response", JSON.stringify(deliveries))
+            && receipt.receiptMac === (0, telegram_1.sanctuaryTelegramTurnReceiptMac)(identityKey, receipt);
+        if (JSON.stringify(Object.keys(receipt).sort()) !== JSON.stringify(exactKeys)
+            || (!grounded && receipt.schemaVersion !== "sanctuary-telegram-turn-receipt-v3")
+            || typeof receipt.scenarioHandleDigest !== "string" || !SHA256.test(receipt.scenarioHandleDigest)
+            || (receipt.status !== "success" && receipt.status !== "error")
+            || (receipt.status === "success" ? receipt.errorCategory !== null : typeof receipt.errorCategory !== "string" || receipt.errorCategory.length < 1 || receipt.errorCategory.length > 128)
+            || ![receipt.updateDigest, receipt.sequenceDigest, receipt.responseDigest].every((value) => typeof value === "string" && SHA256.test(value))
+            || !Array.isArray(receipt.toolResultDigests) || receipt.toolResultDigests.length > 100 || !receipt.toolResultDigests.every((value) => typeof value === "string" && SHA256.test(value))
+            || !Array.isArray(deliveries) || deliveries.length > 100 || !deliveries.every((value) => {
+            const delivery = object(value, "Telegram delivery receipt");
+            return JSON.stringify(Object.keys(delivery).sort()) === JSON.stringify(grounded ? ["chunkDigest", "messageIdDigest", "redactedText", "utf16Units"] : ["chunkDigest", "messageIdDigest"])
+                && typeof delivery.messageIdDigest === "string" && SHA256.test(delivery.messageIdDigest)
+                && typeof delivery.chunkDigest === "string" && SHA256.test(delivery.chunkDigest)
+                && (!grounded || (typeof delivery.redactedText === "string" && delivery.redactedText.length === delivery.utf16Units && Number(delivery.utf16Units) <= 1_200));
+        })
+            || (grounded && !authenticatedDeliveries)
+            || (grounded && (typeof receipt.receiptMac !== "string" || !SHA256.test(receipt.receiptMac)))
+            || (grounded && (!Array.isArray(receipt.toolGroundings) || receipt.toolGroundings.length !== 1 || !receipt.toolGroundings.every((raw) => {
+                const grounding = object(raw, "Telegram tool grounding");
+                if (JSON.stringify(Object.keys(grounding).sort()) !== JSON.stringify(["facts", "groundingDigest", "observedAt", "resultDigest", "sourceIdentityDigest", "toolName"]) || (grounding.toolName !== "unraid_get_system" && grounding.toolName !== "unraid_get_storage")
+                    || typeof grounding.resultDigest !== "string" || !SHA256.test(grounding.resultDigest) || typeof grounding.groundingDigest !== "string" || !SHA256.test(grounding.groundingDigest)
+                    || typeof grounding.sourceIdentityDigest !== "string" || !SHA256.test(grounding.sourceIdentityDigest) || typeof grounding.observedAt !== "string" || !Number.isFinite(Date.parse(grounding.observedAt)) || new Date(Date.parse(grounding.observedAt)).toISOString() !== grounding.observedAt
+                    || !grounding.facts || typeof grounding.facts !== "object" || Array.isArray(grounding.facts))
+                    return false;
+                return (0, sanctuary_grounding_1.sanctuaryGroundingDigest)(grounding.facts) === grounding.groundingDigest && receipt.toolResultDigests.includes(grounding.resultDigest);
+            })))
+            || ![receipt.providerInvocationCount, receipt.toolInvocationCount].every((value) => Number.isSafeInteger(value) && Number(value) >= 0 && Number(value) <= 1_000)
+            || !Number.isSafeInteger(receipt.deliveryCount) || receipt.deliveryCount !== deliveries.length
+            || typeof receipt.completedAt !== "string" || receipt.completedAt.length > 30 || !Number.isFinite(Date.parse(receipt.completedAt)) || new Date(Date.parse(receipt.completedAt)).toISOString() !== receipt.completedAt) {
+            throw new Error("Telegram turn receipt ledger row is invalid");
+        }
+        if (receipt.scenarioHandleDigest !== scenarioHandleDigest)
+            return [];
+        const responseText = grounded ? deliveries.map((delivery) => String(delivery.redactedText)).join("") : undefined;
+        const toolGroundings = grounded ? structuredClone(receipt.toolGroundings) : undefined;
+        return [{
+                status: receipt.status, updateDigest: String(receipt.updateDigest), sequenceDigest: String(receipt.sequenceDigest), responseDigest: String(receipt.responseDigest),
+                toolResultDigests: receipt.toolResultDigests, providerTurnCount: Number(receipt.providerInvocationCount),
+                toolInvocationCount: Number(receipt.toolInvocationCount), deliveryCount: Number(receipt.deliveryCount),
+                telegramMessageIdDigests: deliveries.map((delivery) => String(delivery.messageIdDigest)), completedAt: Date.parse(receipt.completedAt),
+                ...(grounded ? { responseText, responseUtf16Units: responseText.length, toolGroundings } : {}),
+            }];
+    });
+}
+async function readIndependentSanctuaryGrounding(toolName) {
+    const sanctuary = (0, sanctuary_runtime_1.createSanctuaryToolContext)(TARGET_ID).sanctuary;
+    const result = toolName === "unraid_get_system" ? await sanctuary.getSystem() : await sanctuary.getStorage();
+    const facts = (0, sanctuary_grounding_1.projectSanctuaryGrounding)(toolName, result);
+    const sourceIdentityDigest = result.data?.sourceIdentityDigest;
+    if (typeof sourceIdentityDigest !== "string" || !SHA256.test(sourceIdentityDigest))
+        throw new Error("independent Sanctuary source identity is unavailable");
+    return { toolName, groundingDigest: (0, sanctuary_grounding_1.sanctuaryGroundingDigest)(facts), sourceIdentityDigest, observedAt: new Date().toISOString(), facts };
+}
+function canonicalDockerIdFromUnraidPrefixedId(value) {
+    if (typeof value !== "string" || !/^[0-9a-f]{64}:[0-9a-f]{64}$/u.test(value))
+        throw new Error("Unraid Docker PrefixedID is invalid");
+    return value.slice(65);
+}
+function containmentToolContext(agentRoot, profileId) {
+    const profile = (0, relationship_authorization_1.loadRelationshipCapabilityRegistry)(agentRoot).profiles[profileId];
+    if (!profile)
+        throw new Error("Sanctuary containment profile is missing");
+    return {
+        signin: async () => undefined, agentName: TARGET_ID, agentRoot,
+        relationshipAuthorization: {
+            profileId, authorizedContextScopes: profile.contextScopes, advertisedToolNames: profile.toolNames,
+            // This request-bound subject audits the profile contract; it is not a persisted Friend or grant.
+            authorizeTool: async (name) => (0, relationship_authorization_1.authorizeRelationshipAccess)({
+                relationship: { friendId: "sanctuary-containment-probe", trustLevel: profileId === "sanctuary-household" ? "friend" : "family", admissionState: "active", initiativePolicy: "reactive_only", capabilityProfileId: profileId },
+                profiles: Object.values((0, relationship_authorization_1.loadRelationshipCapabilityRegistry)(agentRoot).profiles),
+                request: { kind: "tool", name, requestId: "sanctuary-containment-probe", returnTargetFriendId: "sanctuary-containment-probe" },
+                activeRequestId: "sanctuary-containment-probe", requestPhase: "inbound",
+            }),
+        },
+    };
+}
+async function runSanctuaryProductionBoundaryProbe(input) {
+    const excludedNames = ["vault_get", "mcp_call", "exec", "credential_get", ...(input.profileId === "sanctuary-owner" ? [] : tools_1.SANCTUARY_OWNER_ADDITIONS)];
+    const inner = input.profileId === "sanctuary-event";
+    const terminal = inner ? "rest" : "settle";
+    const turns = [
+        { content: "", toolCalls: excludedNames.map((name, index) => ({ id: `sanctuary-excluded-${index}`, name, arguments: "{}" })), outputItems: [] },
+        { content: "", toolCalls: [{ id: "sanctuary-valid-system", name: "unraid_get_system", arguments: "{}" }], outputItems: [] },
+        { content: "", toolCalls: [{ id: "sanctuary-boundary-terminal", name: terminal, arguments: JSON.stringify(inner ? { note: "boundary complete" } : { answer: "boundary complete", intent: "complete" }) }], outputItems: [] },
+    ];
+    let turn = 0;
+    const controlOutputs = [];
+    const providerRuntime = {
+        ...input.providerRuntime, client: null,
+        streamTurn: async () => turns[turn++] ?? (() => { throw new Error("production boundary probe exceeded its turn budget"); })(),
+        appendToolOutput: (callId, output) => { if (callId === "sanctuary-valid-system")
+            controlOutputs.push(output); }, resetTurnState: () => undefined, ping: async () => undefined, classifyError: () => "unknown",
+    };
+    const receipts = [];
+    const sanctuary = (0, sanctuary_runtime_1.createSanctuaryToolContext)(TARGET_ID).sanctuary;
+    const context = containmentToolContext(input.agentRoot, input.profileId);
+    const relationship = context.relationshipAuthorization;
+    const poisonedContext = { ...context, sanctuary, relationshipAuthorization: {
+            ...relationship, advertisedToolNames: [...relationship.advertisedToolNames, ...excludedNames, "mcp__containment_poison"],
+        } };
+    const observed = await (0, sanctuary_runtime_1.runWithSanctuaryToolReceiptCollection)(() => (0, core_1.runAgent)([{ role: "user", content: "Run the bounded production tool authorization probe." }], {
+        onModelStart: () => undefined, onModelStreamStart: () => undefined, onTextChunk: () => undefined, onReasoningChunk: () => undefined,
+        onToolStart: () => undefined, onToolEnd: () => undefined, onError: () => undefined, onClearText: () => undefined,
+    }, inner ? "inner" : "telegram", undefined, {
+        skipKeptNotes: true, providerRuntimeOverride: providerRuntime, toolBoundaryObserver: (receipt) => receipts.push(receipt),
+        toolContext: poisonedContext,
+    }));
+    const controlReceipts = receipts.filter((receipt) => receipt.name === "unraid_get_system");
+    if (observed.result.outcome !== (inner ? "rested" : "settled") || controlReceipts.length !== 1
+        || controlReceipts[0].reason !== "dispatched" || !controlReceipts[0].invoked || controlReceipts[0].sideEffect
+        || observed.toolResultDigests.length !== 1 || controlOutputs.length !== 1
+        || (0, node_crypto_1.createHash)("sha256").update(controlOutputs[0]).digest("hex") !== observed.toolResultDigests[0]) {
+        throw new Error("production boundary valid control did not dispatch with one live Sanctuary read receipt");
+    }
+    const controlResult = object(JSON.parse(controlOutputs[0]), "production boundary control result");
+    const controlData = object(controlResult.data, "production boundary control data");
+    if (controlResult.ok !== true || typeof controlData.sourceIdentityDigest !== "string" || !SHA256.test(controlData.sourceIdentityDigest)) {
+        throw new Error("production boundary valid control result is invalid");
+    }
+    return receipts.filter((receipt) => receipt.name !== terminal);
+}
+function parseInteractiveDriverReceipt(raw, label, scenarioHandleDigest) {
+    if (raw === null)
+        return undefined;
+    const receipt = object(JSON.parse(raw), "interactive driver receipt");
+    const expectedSchema = label === "unit-16k-timeout-stale" ? "sanctuary-timeout-stale-driver-receipt-v1" : "sanctuary-interactive-driver-receipt-v2";
+    if (receipt.schemaVersion !== expectedSchema || receipt.phase !== "complete"
+        || receipt.label !== label || receipt.scenarioHandleDigest !== scenarioHandleDigest)
+        throw new Error("interactive driver receipt binding is invalid");
+    const common = ["schemaVersion", "phase", "label", "scenarioHandleDigest", "approvalIdDigest", "checkpointDigest", "suspendedSessionRevisionDigest", "approvalEpochBefore"];
+    const digests = [receipt.approvalIdDigest, receipt.checkpointDigest, receipt.suspendedSessionRevisionDigest];
+    if (!digests.every((value) => typeof value === "string" && SHA256.test(value)) || !Number.isSafeInteger(receipt.approvalEpochBefore) || Number(receipt.approvalEpochBefore) < 0) {
+        throw new Error("interactive driver receipt common coordinates are invalid");
+    }
+    if (label === "unit-16k-timeout-stale") {
+        exactKeys(receipt, [...common, "callbackAttempts", "distinctQueryCount", "callbackDataDigest", "settledCount", "claimCount", "mutationCount", "staleAcknowledged", "promptTerminal"], "timeout stale driver receipt");
+        if (receipt.callbackAttempts !== 1 || receipt.distinctQueryCount !== 1 || typeof receipt.callbackDataDigest !== "string" || !SHA256.test(receipt.callbackDataDigest)
+            || receipt.settledCount !== 1 || receipt.claimCount !== 0 || receipt.mutationCount !== 0 || receipt.staleAcknowledged !== true || receipt.promptTerminal !== true) {
+            throw new Error("timeout stale driver receipt is invalid");
+        }
+    }
+    else if (label === "unit-16l-duplicate-callback") {
+        exactKeys(receipt, [...common, "callbackAttempts", "distinctQueryCount", "callbackDataDigest", "barrierObserved", "settledCount", "claimCount", "mutationCount", "staleReplayAttempts", "staleReplaySettled", "staleReplayMutationCount", "promptTerminal", "writeCredentialObserved"], "duplicate callback driver receipt");
+        if (receipt.callbackAttempts !== 2 || receipt.distinctQueryCount !== 2 || typeof receipt.callbackDataDigest !== "string" || !SHA256.test(receipt.callbackDataDigest)
+            || receipt.barrierObserved !== true || receipt.settledCount !== 2 || receipt.claimCount !== 1 || receipt.mutationCount !== 1
+            || receipt.staleReplayAttempts !== 1 || receipt.staleReplaySettled !== true || receipt.staleReplayMutationCount !== 0
+            || receipt.promptTerminal !== true || receipt.writeCredentialObserved !== false)
+            throw new Error("duplicate callback driver receipt is invalid");
+    }
+    else if (label === "unit-16m-restart-continuation") {
+        exactKeys(receipt, [...common, "approvalEpochAfterRestart", "continuationEpochAfter", "ownerImageDigest", "ownerContainerDigest", "restartCountBefore", "restartCountAfter", "pendingDigestBefore", "pendingDigestAfter", "pendingRestored", "callbackAttempts", "mutationCount", "indeterminateRecoveryObserved", "attemptedRecoveryReopened", "attemptedRecordDigest", "recoveredRecordDigest", "indeterminateRetryCount"], "restart continuation driver receipt");
+        if (![receipt.ownerImageDigest, receipt.ownerContainerDigest, receipt.pendingDigestBefore, receipt.pendingDigestAfter, receipt.attemptedRecordDigest, receipt.recoveredRecordDigest].every((value) => typeof value === "string" && SHA256.test(value))
+            || ![receipt.approvalEpochAfterRestart, receipt.continuationEpochAfter, receipt.restartCountBefore, receipt.restartCountAfter].every((value) => Number.isSafeInteger(value) && Number(value) >= 0)
+            || receipt.pendingRestored !== true || receipt.callbackAttempts !== 1 || receipt.mutationCount !== 1
+            || receipt.indeterminateRecoveryObserved !== true || receipt.attemptedRecoveryReopened !== true
+            || receipt.attemptedRecordDigest === receipt.recoveredRecordDigest || receipt.indeterminateRetryCount !== 0)
+            throw new Error("restart continuation driver receipt is invalid");
+    }
+    else
+        return undefined;
+    const { phase: _phase, ...validated } = receipt;
+    return validated;
+}
+function parseReadOnlyDenialReceipt(raw, label, scenarioHandleDigest) {
+    if (raw === null)
+        return undefined;
+    const receipt = object(JSON.parse(raw), "read-only denial receipt");
+    exactKeys(receipt, ["schemaVersion", "phase", "label", "scenarioHandleDigest", "operation", "targetDigest", "attemptCount", "httpStatus", "errorCode", "before", "after"], "read-only denial receipt");
+    const expectedOperation = label === "unit-16e-1-stop-denial" ? "stop" : label === "unit-16e-2-restart-denial" ? "restart" : null;
+    if (receipt.schemaVersion !== "sanctuary-read-only-denial-receipt-v1" || receipt.phase !== "complete" || receipt.label !== label
+        || receipt.scenarioHandleDigest !== scenarioHandleDigest || expectedOperation === null || receipt.operation !== expectedOperation
+        || typeof receipt.targetDigest !== "string" || !SHA256.test(receipt.targetDigest) || receipt.attemptCount !== 1
+        || ![200, 401, 403].includes(Number(receipt.httpStatus)) || (receipt.errorCode !== "FORBIDDEN" && receipt.errorCode !== "PERMISSION_DENIED")) {
+        throw new Error("read-only denial receipt binding is invalid");
+    }
+    const boundaryKeys = ["ownerSnapshotDigest", "targetSnapshotDigest", "targetRestartCount", "targetContainerIdDigest", "auditCursorDigest", "providerUsageCursorDigest", "sessionCursorDigest", "toolActionCursorDigest"];
+    const parseBoundary = (rawBoundary, boundaryLabel) => {
+        const boundary = object(rawBoundary, boundaryLabel);
+        exactKeys(boundary, boundaryKeys, boundaryLabel);
+        if (![boundary.ownerSnapshotDigest, boundary.targetSnapshotDigest, boundary.targetContainerIdDigest, boundary.auditCursorDigest, boundary.providerUsageCursorDigest, boundary.sessionCursorDigest, boundary.toolActionCursorDigest]
+            .every((value) => typeof value === "string" && SHA256.test(value)) || !Number.isSafeInteger(boundary.targetRestartCount) || Number(boundary.targetRestartCount) < 0) {
+            throw new Error(`${boundaryLabel} is invalid`);
+        }
+        return boundary;
+    };
+    const before = parseBoundary(receipt.before, "read-only denial before boundary");
+    const after = parseBoundary(receipt.after, "read-only denial after boundary");
+    if (receipt.targetDigest !== before.targetContainerIdDigest || receipt.targetDigest !== after.targetContainerIdDigest)
+        throw new Error("read-only denial target binding is invalid");
+    if (JSON.stringify(before) !== JSON.stringify(after))
+        throw new Error("read-only denial boundary drift was observed");
+    return receipt;
+}
+function durablePrivateJson(filePath, value) {
+    const directory = path.dirname(filePath);
+    (0, node_fs_1.mkdirSync)(directory, { recursive: true, mode: 0o700 });
+    const directoryFd = (0, node_fs_1.openSync)(directory, node_fs_1.constants.O_RDONLY | node_fs_1.constants.O_DIRECTORY | node_fs_1.constants.O_NOFOLLOW);
+    const temporary = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    try {
+        const fileFd = (0, node_fs_1.openSync)(temporary, node_fs_1.constants.O_WRONLY | node_fs_1.constants.O_CREAT | node_fs_1.constants.O_EXCL | node_fs_1.constants.O_NOFOLLOW, 0o600);
+        try {
+            (0, node_fs_1.writeFileSync)(fileFd, `${JSON.stringify(value)}\n`);
+            (0, node_fs_1.fsyncSync)(fileFd);
+        }
+        finally {
+            (0, node_fs_1.closeSync)(fileFd);
+        }
+        (0, node_fs_1.renameSync)(temporary, filePath);
+        (0, node_fs_1.fsyncSync)(directoryFd);
+    }
+    finally {
+        (0, node_fs_1.rmSync)(temporary, { force: true });
+        (0, node_fs_1.closeSync)(directoryFd);
+    }
+}
+function createSanctuaryReadOnlyDenialScenarioDriver(options) {
+    const receiptPath = (scenarioHandleDigest) => pathFor(options.agentRoot, `state/acceptance/denial-receipts/${scenarioHandleDigest}.json`);
+    const attemptPath = (scenarioHandleDigest) => pathFor(options.agentRoot, `state/acceptance/denial-attempts/${scenarioHandleDigest}.json`);
+    const attemptsRoot = pathFor(options.agentRoot, "state/acceptance/denial-attempts");
+    const assertNoIndeterminateAttempt = (label) => {
+        try {
+            const entries = (0, node_fs_1.readdirSync)(attemptsRoot, { withFileTypes: true });
+            if (entries.length > 100)
+                throw new Error("read-only denial attempt inventory exceeds its bound");
+            for (const entry of entries) {
+                if (!entry.isFile() || !entry.name.endsWith(".json"))
+                    throw new Error("read-only denial attempt inventory is invalid");
+                const attempt = object(JSON.parse((0, node_fs_1.readFileSync)(pathFor(attemptsRoot, entry.name), "utf8")), "read-only denial attempt");
+                exactKeys(attempt, ["schemaVersion", "phase", "label", "scenarioHandleDigest"], "read-only denial attempt");
+                if (attempt.schemaVersion !== "sanctuary-read-only-denial-attempt-v1" || attempt.phase !== "attempting"
+                    || typeof attempt.scenarioHandleDigest !== "string" || !SHA256.test(attempt.scenarioHandleDigest))
+                    throw new Error("read-only denial attempt is invalid");
+                if (attempt.label === label)
+                    throw new Error("read-only denial attempt is attempted or indeterminate; inspect-before-retry is required");
+            }
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    };
+    return {
+        async poll(rawLabel, scenarioHandleDigest) {
+            if (rawLabel !== "unit-16e-1-stop-denial" && rawLabel !== "unit-16e-2-restart-denial")
+                throw new Error("read-only denial label is invalid");
+            const label = rawLabel;
+            const existingReceipt = receiptPath(scenarioHandleDigest);
+            if ((0, node_fs_1.existsSync)(existingReceipt)) {
+                parseReadOnlyDenialReceipt((0, node_fs_1.readFileSync)(existingReceipt, "utf8"), label, scenarioHandleDigest);
+                return { state: "driven" };
+            }
+            assertNoIndeterminateAttempt(label);
+            const attempt = attemptPath(scenarioHandleDigest);
+            durablePrivateJson(attempt, { schemaVersion: "sanctuary-read-only-denial-attempt-v1", phase: "attempting", label, scenarioHandleDigest });
+            const receipt = await options.runProbe(label, scenarioHandleDigest);
+            parseReadOnlyDenialReceipt(JSON.stringify(receipt), label, scenarioHandleDigest);
+            durablePrivateJson(existingReceipt, receipt);
+            return { state: "driven" };
+        },
+        complete(_label, scenarioHandleDigest) {
+            for (const filePath of [receiptPath(scenarioHandleDigest), attemptPath(scenarioHandleDigest)])
+                if ((0, node_fs_1.existsSync)(filePath))
+                    (0, node_fs_1.unlinkSync)(filePath);
+        },
+    };
+}
+function digestOptionalFiles(filePaths) {
+    const digest = (0, node_crypto_1.createHash)("sha256");
+    for (const filePath of filePaths) {
+        digest.update(filePath);
+        try {
+            digest.update((0, node_fs_1.readFileSync)(filePath));
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+            digest.update("[absent]");
+        }
+    }
+    return digest.digest("hex");
+}
+async function captureReadOnlyDenialBoundary(agentRoot, deps) {
+    const ownerSnapshot = object(await dependency(deps.hostRequest, "Sanctuary host broker")({ operation: "container_snapshot", targetId: TARGET_ID }), "denial owner snapshot");
+    const targetSnapshot = object(await dependency(deps.hostRequest, "Sanctuary host broker")({ operation: "denial_target_snapshot", targetId: TARGET_ID }), "denial target snapshot");
+    exactKeys(targetSnapshot, ["containerIdDigest", "imageDigest", "running", "status", "restartCount", "startedAtDigest"], "denial target snapshot");
+    if (![targetSnapshot.containerIdDigest, targetSnapshot.imageDigest, targetSnapshot.startedAtDigest].every((value) => typeof value === "string" && SHA256.test(value))
+        || typeof targetSnapshot.running !== "boolean" || typeof targetSnapshot.status !== "string"
+        || !Number.isSafeInteger(targetSnapshot.restartCount) || Number(targetSnapshot.restartCount) < 0)
+        throw new Error("denial target snapshot is invalid");
+    const auditPath = TELEGRAM_AUDIT;
+    const providerPath = pathFor(agentRoot, "state/acceptance/telegram-turns.ndjson");
+    const toolPath = pathFor(agentRoot, "state/acceptance/restart-attempts.ndjson");
+    const approvalDatabase = pathFor(agentRoot, "state/approvals/approvals.sqlite");
+    return {
+        ownerSnapshotDigest: (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(ownerSnapshot)).digest("hex"),
+        targetSnapshotDigest: (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(targetSnapshot)).digest("hex"),
+        targetRestartCount: Number(targetSnapshot.restartCount),
+        targetContainerIdDigest: String(targetSnapshot.containerIdDigest),
+        auditCursorDigest: digestOptionalFiles([auditPath, TELEGRAM_AUDIT_HEAD]),
+        providerUsageCursorDigest: digestOptionalFiles([providerPath]),
+        sessionCursorDigest: (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(readBoundedIdentitySurfaces(agentRoot))).digest("hex"),
+        toolActionCursorDigest: digestOptionalFiles([toolPath, approvalDatabase, `${approvalDatabase}-wal`, `${approvalDatabase}-shm`]),
+    };
+}
+async function executeSanctuaryReadOnlyDenialProbe(label, scenarioHandleDigest, agentRoot, deps) {
+    const runtime = (0, runtime_credentials_1.readMachineRuntimeCredentialConfig)(TARGET_ID);
+    if (!runtime.ok)
+        throw new Error("read-only denial probe requires an unlocked machine runtime credential");
+    const endpoint = exactLoopbackGraphqlEndpoint(runtime.config.unraidGraphqlUrl);
+    const readKey = text(runtime.config.unraidReadApiKey, "read-only Unraid credential");
+    const topologyQuery = "query AcceptanceDenialTarget { docker { containers(skipCache: true) { id names state status } } }";
+    const topologyResponse = await deps.fetch(endpoint.href, { method: "POST", headers: { "content-type": "application/json", "x-api-key": readKey }, body: JSON.stringify({ query: topologyQuery, variables: {} }), signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS) });
+    const topologyEnvelope = object(await topologyResponse.json(), "read-only denial target response");
+    const docker = object(object(topologyEnvelope.data, "read-only denial target data").docker, "read-only denial target docker");
+    if (!Array.isArray(docker.containers))
+        throw new Error("read-only denial target list is invalid");
+    const matches = docker.containers.map((entry) => object(entry, "read-only denial target"))
+        .filter((entry) => Array.isArray(entry.names) && entry.names.some((name) => name === "calibre-web" || name === "/calibre-web"));
+    if (matches.length !== 1 || typeof matches[0].id !== "string")
+        throw new Error("read-only denial target is absent or ambiguous");
+    const targetId = text(matches[0].id, "read-only denial target id");
+    const canonicalTargetId = canonicalDockerIdFromUnraidPrefixedId(targetId);
+    const before = await captureReadOnlyDenialBoundary(agentRoot, deps);
+    if (before.targetContainerIdDigest !== (0, node_crypto_1.createHash)("sha256").update(canonicalTargetId).digest("hex"))
+        throw new Error("read-only denial target identity is invalid");
+    const query = label === "unit-16e-1-stop-denial"
+        ? "mutation AcceptanceStopDenial($id: PrefixedID!) { docker { stop(id: $id) { id } } }"
+        : WRITE_PROBE;
+    const response = await deps.fetch(endpoint.href, { method: "POST", headers: { "content-type": "application/json", "x-api-key": readKey }, body: JSON.stringify({ query, variables: { id: targetId } }), signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS) });
+    const envelope = object(await response.json(), "read-only mutation denial response");
+    const codes = Array.isArray(envelope.errors) ? envelope.errors.map((raw) => object(raw, "read-only denial error")).flatMap((error) => {
+        const extensions = error.extensions && typeof error.extensions === "object" && !Array.isArray(error.extensions) ? error.extensions : {};
+        return typeof extensions.code === "string" ? [extensions.code] : [];
+    }) : [];
+    const errorCode = codes.includes("FORBIDDEN") ? "FORBIDDEN" : codes.includes("PERMISSION_DENIED") ? "PERMISSION_DENIED" : "UNCLASSIFIED";
+    const after = await captureReadOnlyDenialBoundary(agentRoot, deps);
+    if (after.targetContainerIdDigest !== (0, node_crypto_1.createHash)("sha256").update(canonicalTargetId).digest("hex"))
+        throw new Error("read-only denial target identity drifted");
+    return {
+        schemaVersion: "sanctuary-read-only-denial-receipt-v1", phase: "complete", label, scenarioHandleDigest,
+        operation: label === "unit-16e-1-stop-denial" ? "stop" : "restart",
+        targetDigest: (0, node_crypto_1.createHash)("sha256").update(canonicalTargetId).digest("hex"), attemptCount: 1,
+        httpStatus: response.status, errorCode, before, after,
+    };
+}
+async function readDefaultSanctuaryScenarioFacts(label, scenarioHandleDigest, deps, configuredAgentRoot = (0, identity_1.getAgentRoot)(TARGET_ID), options = {}) {
+    if (options.skipContainerSnapshot === true && options.containerSnapshot !== undefined)
+        throw new Error("container snapshot options are mutually exclusive");
+    const agentRoot = configuredAgentRoot;
+    const identityRaw = optionalFixedFile(deps, pathFor(agentRoot, "state/senses/telegram/identity.key"));
+    const auditRaw = optionalFixedFile(deps, TELEGRAM_AUDIT);
+    const auditHeadRaw = optionalFixedFile(deps, TELEGRAM_AUDIT_HEAD);
+    const gatewayCursor = await readGatewayCursor(deps);
+    const checkpointsRaw = optionalFixedFile(deps, pathFor(agentRoot, "state/approvals/checkpoints.json"));
+    const restartAttemptsRaw = optionalFixedFile(deps, pathFor(agentRoot, "state/acceptance/restart-attempts.ndjson")) ?? "";
+    const telegramTurnsRaw = optionalFixedFile(deps, pathFor(agentRoot, "state/acceptance/telegram-turns.ndjson")) ?? "";
+    const cronRaw = optionalFixedFile(deps, "/home/ouro/.ouro-cli/scheduler/sanctuary.crontab");
+    const healthRaw = optionalFixedFile(deps, pathFor(agentRoot, "state/health/sanctuary-health.json"));
+    const healthProbeRaw = optionalFixedFile(deps, pathFor(agentRoot, `state/acceptance/health-probe-receipts/${scenarioHandleDigest}.json`));
+    const interactiveDriverRaw = optionalFixedFile(deps, pathFor(agentRoot, `state/acceptance/interactive-driver-receipts/${scenarioHandleDigest}.json`));
+    const denialReceiptRaw = optionalFixedFile(deps, pathFor(agentRoot, `state/acceptance/denial-receipts/${scenarioHandleDigest}.json`));
+    const agentConfig = parsedJson(optionalFixedFile(deps, pathFor(agentRoot, "agent.json")));
+    const readinessPolicy = parsedJson(optionalFixedFile(deps, pathFor(agentRoot, "provider-readiness.json")));
+    const rebootRaw = optionalFixedFile(deps, "/evidence/reboot.json");
+    const expectedImageId = optionalFixedFile(deps, IMAGE_DIGEST_FILE)?.trim();
+    let stopDenied = false;
+    let restartDenied = false;
+    let denialAuditCount = 0;
+    let denialStateUnchanged = false;
+    let denialProbeCompleted = false;
+    const denialReceipt = parseReadOnlyDenialReceipt(denialReceiptRaw, label, scenarioHandleDigest);
+    if (denialReceipt) {
+        denialStateUnchanged = JSON.stringify(denialReceipt.before) === JSON.stringify(denialReceipt.after);
+        denialProbeCompleted = true;
+        denialAuditCount = denialReceipt.attemptCount;
+        if (label === "unit-16e-1-stop-denial")
+            stopDenied = true;
+        else
+            restartDenied = true;
+    }
+    if ((auditRaw === null) !== (auditHeadRaw === null))
+        throw new Error("Telegram audit ledger/head presence mismatch");
+    if (auditRaw !== null && (!identityRaw || !/^[A-Za-z0-9_-]{43}\n?$/u.test(identityRaw)))
+        throw new Error("Telegram audit ledger identity key is unavailable");
+    const auditLedgerEntries = auditRaw === null ? [] : (0, telegram_audit_ledger_1.verifyTelegramAuditLedger)({
+        ledgerRaw: auditRaw,
+        headRaw: auditHeadRaw,
+        identityKey: identityRaw.trim(),
+    });
+    const auditEntries = auditLedgerEntries.filter((entry) => entry.meta.scenarioHandleDigest === scenarioHandleDigest);
+    let approvalRecords = [];
+    const approvalDatabasePath = pathFor(agentRoot, "state/approvals/approvals.sqlite");
+    if ((0, node_fs_1.existsSync)(approvalDatabasePath))
+        approvalRecords = (0, approval_store_1.readApprovalsByScenarioHandleDigest)(approvalDatabasePath, scenarioHandleDigest);
+    const approvals = approvalRecords.map(({ approval: record, continuation }) => {
+        const boundEvents = auditEntries.filter((entry) => entry.meta.approvalId === record.approvalId);
+        const terminalized = boundEvents.some((entry) => entry.event === "telegram.approval_prompt_terminalized" && entry.meta.buttonsRemoved === true);
+        const callbackEvents = boundEvents.filter((entry) => entry.event === "telegram.callback_settled" || entry.event === "telegram.callback_recovery_settled");
+        const staleCallbackEvents = boundEvents.filter((entry) => entry.event === "telegram.approval_stale_callback_settled");
+        const claimCount = boundEvents.filter((entry) => entry.event === "approval.acceptance_transition" && entry.meta.state === "claimed").length;
+        const restartExecutionCount = boundEvents.filter((entry) => entry.event === "senses.telegram_approved_restart_end").length;
+        const resultDigest = (0, node_crypto_1.createHash)("sha256").update(JSON.stringify({ state: record.state, result: record.result })).digest("hex");
+        let resultTargetId = null;
+        if (record.toolName === "unraid_restart_container" && record.state === "succeeded") {
+            let parsed;
+            try {
+                parsed = JSON.parse(text(record.result, "approved restart result"));
+            }
+            catch {
+                throw new Error("approved restart result binding is invalid");
+            }
+            const result = object(parsed, "approved restart result");
+            const data = object(result.data, "approved restart result data");
+            const container = object(data.container, "approved restart result container");
+            if (result.ok !== true || container.name !== "calibre-web" || typeof data.beforeState !== "string" || typeof data.afterState !== "string"
+                || data.observedRestart !== true || data.degraded !== false)
+                throw new Error("approved restart result binding is invalid");
+            resultTargetId = text(container.id, "approved restart result target id");
+            if (resultTargetId.length > 128)
+                throw new Error("approved restart result binding is invalid");
+        }
+        return ({
+            approvalId: record.approvalId,
+            state: record.state,
+            toolName: record.toolName,
+            createdAt: Date.parse(record.createdAt),
+            expiresAt: Date.parse(record.expiresAt),
+            updatedAt: Date.parse(record.updatedAt),
+            attempted: record.attemptedAt !== null,
+            continuationCompleted: continuation?.continuationState === "completed",
+            buttonsRemoved: terminalized,
+            terminalPrompt: terminalized,
+            callbackCount: callbackEvents.length,
+            settledCount: callbackEvents.length,
+            claimCount,
+            replayMutationCount: Math.max(0, restartExecutionCount - (record.state === "succeeded" ? 1 : 0)),
+            staleAcknowledged: [...callbackEvents, ...staleCallbackEvents].some((entry) => entry.meta.acknowledged === true && (entry.meta.reason === "stale_callback" || entry.meta.reason === "expired")),
+            argumentDigest: record.argumentDigest,
+            target: typeof record.arguments.container === "string" ? record.arguments.container : null,
+            resultDigest,
+            resultTargetId,
+            checkpointDigest: record.checkpointDigest,
+            approvalEpoch: record.epoch,
+            continuationEpoch: continuation?.continuationEpoch ?? null,
+            continuationState: continuation?.continuationState ?? null,
+            suspendedSessionRevision: record.suspendedSessionRevision,
+        });
+    });
+    const restartAttempts = parseRestartAttempts(restartAttemptsRaw, scenarioHandleDigest);
+    const telegramTurns = parseTelegramTurnReceipts(telegramTurnsRaw, scenarioHandleDigest, identityRaw?.trim() ?? null);
+    const telegramNextUpdateId = gatewayCursor.nextUpdateId;
+    const groundingTool = label === "unit-16d-whats-up" ? "unraid_get_system" : label === "unit-16d-1-space" ? "unraid_get_storage" : null;
+    const liveGrounding = groundingTool && deps.readLiveGrounding ? await deps.readLiveGrounding(groundingTool) : undefined;
+    let identity;
+    if (APPROVAL_EVIDENCE_LABELS.has(label) && (!identityRaw || !/^[A-Za-z0-9_-]{43}\n?$/u.test(identityRaw))) {
+        throw new Error("Telegram approval identity key is missing or malformed");
+    }
+    if (identityRaw && /^[A-Za-z0-9_-]{43}\n?$/u.test(identityRaw)) {
+        const credentials = deps.telegramCredentials ? deps.telegramCredentials() : acceptanceTelegramIdentity();
+        const identityKey = identityRaw.trim();
+        const auditSchema = label === "unit-16d-whats-up" || label === "unit-16d-1-space" ? "sanctuary-telegram-turn-receipt-v4" : "sanctuary-telegram-turn-receipt-v3";
+        for (const entry of auditEntries.filter((candidate) => candidate.event === "senses.telegram_turn_start" || candidate.event === "senses.telegram_turn_end" || candidate.event === "senses.telegram_turn_error")) {
+            if (typeof entry.meta.lifecycleMac !== "string" || !SHA256.test(entry.meta.lifecycleMac)
+                || entry.meta.lifecycleMac !== (0, telegram_1.sanctuaryTelegramAuditLifecycleMac)(identityKey, auditSchema, entry.event, entry.meta)) {
+                throw new Error("Telegram audit lifecycle MAC is invalid");
+            }
+        }
+        const approvalEvidenceKeys = {
+            "senses.telegram_approval_prompt_bound": [["actionDigest", "approvalId", "boundAt", "checkpointDigest", "evidenceMac", "messageIdDigest", "scenarioHandleDigest", "suspendedSessionRevisionDigest", "targetDigest"]],
+            "telegram.callback_settled": [["accepted", "acknowledged", "acknowledgementState", "actionDigest", "approvalId", "boundAt", "callbackAt", "checkpointDigest", "decisionAttemptDigest", "evidenceMac", "messageIdDigest", "reason", "scenarioHandleDigest", "suspendedSessionRevisionDigest", "targetDigest"]],
+            "telegram.callback_recovery_settled": [["accepted", "acknowledgementState", "actionDigest", "approvalId", "boundAt", "callbackAt", "checkpointDigest", "decisionAttemptDigest", "evidenceMac", "messageIdDigest", "reason", "recoveredAt", "scenarioHandleDigest", "suspendedSessionRevisionDigest", "targetDigest"]],
+            "telegram.approval_stale_callback_settled": [["accepted", "acknowledged", "actionDigest", "approvalId", "boundAt", "checkpointDigest", "evidenceMac", "messageIdDigest", "reason", "scenarioHandleDigest", "staleAt", "suspendedSessionRevisionDigest", "targetDigest"]],
+            "telegram.approval_expiry_observed": [["actionDigest", "approvalId", "boundAt", "checkpointDigest", "evidenceMac", "expiryDeadlineAt", "expiryObservationSchemaVersion", "expiryObservedAt", "messageIdDigest", "scenarioHandleDigest", "suspendedSessionRevisionDigest", "targetDigest"]],
+            "telegram.approval_prompt_terminalized": [
+                ["actionDigest", "approvalId", "boundAt", "buttonsRemoved", "checkpointDigest", "evidenceMac", "messageIdDigest", "scenarioHandleDigest", "suspendedSessionRevisionDigest", "targetDigest", "terminalEditStartedAt", "terminalizedAt"],
+                ["actionDigest", "approvalId", "boundAt", "buttonsRemoved", "checkpointDigest", "evidenceMac", "expiryDeadlineAt", "expiryObservedAt", "messageIdDigest", "scenarioHandleDigest", "suspendedSessionRevisionDigest", "targetDigest", "terminalEditStartedAt", "terminalizedAt"],
+            ],
+            "senses.telegram_approval_continuation_delivered": [["actionDigest", "approvalId", "boundAt", "checkpointDigest", "deliveredAt", "deliveryDigest", "deliveryMessageIdDigest", "evidenceMac", "messageIdDigest", "resultDigest", "scenarioHandleDigest", "suspendedSessionRevisionDigest", "targetDigest"]],
+        };
+        for (const entry of auditEntries.filter((candidate) => candidate.event in approvalEvidenceKeys
+            && candidate.meta.scenarioHandleDigest === scenarioHandleDigest && typeof candidate.meta.approvalId === "string")) {
+            if (!approvalEvidenceKeys[entry.event].some((keys) => JSON.stringify(Object.keys(entry.meta).sort()) === JSON.stringify([...keys].sort()))
+                || typeof entry.meta.evidenceMac !== "string" || !SHA256.test(entry.meta.evidenceMac)
+                || entry.meta.evidenceMac !== (0, telegram_1.sanctuaryTelegramApprovalEvidenceMac)(identityKey, entry.event, entry.meta)) {
+                throw new Error("Telegram approval evidence MAC is invalid");
+            }
+        }
+        // Unknown admission needs the same surfaces for its zero-work digest.
+        if (sanctuary_acceptance_harness_1.SANCTUARY_SCENARIO_SOURCES[label].includes("identity-surface-audit") || label === "unit-16d-2-unknown-admission") {
+            const expectedSubject = (0, telegram_1.opaqueTelegramSubject)(identityKey, credentials.botId, credentials.authorizedUserId, credentials.authorizedChatId);
+            const observedSubjects = auditEntries.flatMap((entry) => typeof entry.meta.subject === "string" ? [entry.meta.subject] : []);
+            const approvalSubjects = approvalRecords.map((projection) => projection.approval).filter((record) => record.transport === "telegram").map((record) => record.requesterId);
+            const rawValues = [...new Set([credentials.authorizedUserId, credentials.authorizedChatId])];
+            const persistedIdentitySurfaces = readBoundedIdentitySurfaces(agentRoot);
+            const surfacePairs = Array.from({ length: Math.floor(persistedIdentitySurfaces.length / 2) }, (_, index) => ({
+                relativePath: persistedIdentitySurfaces[index * 2],
+                raw: persistedIdentitySurfaces[index * 2 + 1],
+            }));
+            const canonicalSessionPath = path.join("state", "sessions", `telegram-user:${expectedSubject}`, "telegram", `telegram_${expectedSubject}.json`);
+            const canonicalSessionCount = surfacePairs.filter(({ relativePath, raw }) => {
+                if (relativePath !== canonicalSessionPath)
+                    return false;
+                object(JSON.parse(raw), "canonical Telegram session");
+                return true;
+            }).length;
+            const sessionSurfaceDigest = (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(surfacePairs.filter(({ relativePath }) => relativePath === path.join("state", "senses", "telegram", "identity-subjects.json")
+                || relativePath.startsWith(`state${path.sep}sessions${path.sep}`)
+                || relativePath.startsWith(`state${path.sep}pending${path.sep}`)
+                || relativePath.startsWith(`state${path.sep}pending-returns${path.sep}`)))).digest("hex");
+            const friendSurfaceDigest = (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(surfacePairs.filter(({ relativePath }) => relativePath.startsWith(`friends${path.sep}`)))).digest("hex");
+            const canonicalFriendCount = surfacePairs.reduce((count, { relativePath, raw }) => {
+                if (!relativePath.startsWith(`friends${path.sep}`) || !relativePath.endsWith(".json"))
+                    return count;
+                const record = object(JSON.parse(raw), "Telegram Friend identity");
+                if (!Array.isArray(record.externalIds))
+                    return count;
+                return count + record.externalIds.filter((value) => {
+                    const identity = object(value, "Telegram Friend external identity");
+                    return identity.provider === "telegram-user" && identity.externalId === expectedSubject;
+                }).length;
+            }, 0);
+            const surfaceRecords = [...persistedIdentitySurfaces, auditRaw ?? "", auditHeadRaw ?? "", JSON.stringify(approvalRecords)];
+            const surfaceSubjects = surfaceRecords.flatMap((raw) => raw.match(/tg_[A-Za-z0-9_-]{43}/gu) ?? []);
+            const structuredRawId = /"(?:authorizedUserId|authorizedChatId|transportUserId|transportChatId|userId|chatId|updateId|messageId)"\s*:\s*"?\d{1,20}"?/gu;
+            const rawLeakCount = surfaceRecords.reduce((count, raw) => count + rawValues.filter((value) => raw.includes(value)).length + (raw.match(structuredRawId)?.length ?? 0) + Number(auditContainsSensitiveMaterial(raw)), 0);
+            const mismatchCount = [...surfaceSubjects, ...observedSubjects, ...approvalSubjects].filter((subject) => subject !== expectedSubject).length;
+            identity = {
+                keyPresent: true,
+                subjectOpaque: /^tg_[A-Za-z0-9_-]{43}$/u.test(expectedSubject)
+                    && mismatchCount === 0,
+                rawIdentityAbsent: rawLeakCount === 0,
+                liveSubjectObserved: observedSubjects.includes(expectedSubject) && telegramTurns.some((turn) => turn.status === "success"),
+                inspectedRecordCount: surfaceRecords.length,
+                opaqueSubjectCount: [...surfaceSubjects, ...observedSubjects, ...approvalSubjects].filter((subject) => subject === expectedSubject).length,
+                mismatchCount,
+                rawLeakCount,
+                canonicalSessionCount,
+                canonicalFriendCount,
+                sessionSurfaceDigest,
+                friendSurfaceDigest,
+                surfaceDigest: (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(surfaceRecords)).digest("hex"),
+            };
+        }
+    }
+    const container = options.skipContainerSnapshot === true
+        ? null
+        : options.containerSnapshot !== undefined
+            ? ownerContainerSnapshot(options.containerSnapshot)
+            : deps.hostRequest ? object(await deps.hostRequest({ operation: "container_snapshot", targetId: TARGET_ID }), "container snapshot") : null;
+    const rebootCheckpoint = parsedJson(rebootRaw);
+    let reboot;
+    if (rebootCheckpoint?.operation === "reboot" && rebootCheckpoint.phase === "preflight" && rebootCheckpoint.targetId === TARGET_ID
+        && typeof rebootCheckpoint.idempotencyDigest === "string" && SHA256.test(rebootCheckpoint.idempotencyDigest)
+        && typeof rebootCheckpoint.processBindingDigest === "string" && SHA256.test(rebootCheckpoint.processBindingDigest)
+        && Number.isSafeInteger(rebootCheckpoint.unrelatedHostOperations) && Number(rebootCheckpoint.unrelatedHostOperations) >= 0) {
+        reboot = {
+            phase: "preflight", requestDigest: rebootCheckpoint.idempotencyDigest, processBindingDigest: rebootCheckpoint.processBindingDigest, requestCount: 0, checkpointPersisted: true, unrelatedHostOperations: Number(rebootCheckpoint.unrelatedHostOperations),
+            bootIdentityChanged: false, hostReady: false, arrayReady: false, dockerReady: false, butlerReady: false, tailscaleReady: false, sshReady: false,
+        };
+    }
+    else if (rebootCheckpoint?.operation === "reboot" && ["requested", "complete"].includes(String(rebootCheckpoint.phase))
+        && typeof rebootCheckpoint.requestId === "string" && SHA256.test(rebootCheckpoint.requestId)
+        && typeof rebootCheckpoint.prebootDigest === "string" && SHA256.test(rebootCheckpoint.prebootDigest)
+        && typeof rebootCheckpoint.processBindingDigest === "string" && SHA256.test(rebootCheckpoint.processBindingDigest)
+        && Number.isSafeInteger(rebootCheckpoint.unrelatedHostOperations) && Number(rebootCheckpoint.unrelatedHostOperations) >= 0) {
+        const milestones = container && container.recoveryMilestones && typeof container.recoveryMilestones === "object" && !Array.isArray(container.recoveryMilestones)
+            ? container.recoveryMilestones : {};
+        const complete = rebootCheckpoint.phase === "complete" && typeof rebootCheckpoint.postbootDigest === "string" && SHA256.test(rebootCheckpoint.postbootDigest);
+        reboot = {
+            phase: rebootCheckpoint.phase, requestDigest: (0, node_crypto_1.createHash)("sha256").update(rebootCheckpoint.requestId).digest("hex"), processBindingDigest: rebootCheckpoint.processBindingDigest, requestCount: 1, checkpointPersisted: true, unrelatedHostOperations: Number(rebootCheckpoint.unrelatedHostOperations),
+            bootIdentityChanged: complete && rebootCheckpoint.postbootDigest !== rebootCheckpoint.prebootDigest,
+            hostReady: milestones.hostReady === true, arrayReady: milestones.arrayReady === true, dockerReady: milestones.dockerReady === true,
+            butlerReady: milestones.butlerReady === true, tailscaleReady: milestones.tailscaleReady === true, sshReady: milestones.sshReady === true,
+        };
+    }
+    const health = parseHealthAcceptanceState(healthRaw);
+    const activeMarker = (0, sanctuary_acceptance_marker_1.readSanctuaryAcceptanceMarker)(TARGET_ID, agentRoot);
+    const postbootIntegrity = buildPostbootIntegritySnapshot({ telegramNextUpdateId, checkpointsRaw, restartAttempts: parseRestartAttempts(restartAttemptsRaw, null), cronRaw, health, auditLedgerEntries, activeScenarioHandleDigest: activeMarker?.scenarioHandleDigest ?? null });
+    const prebootIntegrity = rebootCheckpoint && typeof rebootCheckpoint.prebootIntegrity === "object" && !Array.isArray(rebootCheckpoint.prebootIntegrity)
+        ? rebootCheckpoint.prebootIntegrity : undefined;
+    const healthProbe = parseHealthProbeReceipt(healthProbeRaw, label, scenarioHandleDigest, identityRaw?.trim() ?? null);
+    const interactiveDriver = parseInteractiveDriverReceipt(interactiveDriverRaw, label, scenarioHandleDigest);
+    const healthSweeps = health ? health.sweepReceipts.filter((receipt) => receipt.scenarioHandleDigest === scenarioHandleDigest) : [];
+    const healthDeliveries = health ? health.deliveredReceipts : [];
+    const scenarioDeliveryIds = new Set(healthSweeps.flatMap((receipt) => typeof receipt.deliveryId === "string" ? [receipt.deliveryId] : []));
+    const scenarioDeliveries = healthDeliveries.filter((receipt) => typeof receipt.deliveryId === "string" && scenarioDeliveryIds.has(receipt.deliveryId));
+    const digestSweep = healthSweeps.findLast((receipt) => receipt.digestDue === true && typeof receipt.completedAt === "string");
+    const digestFiredWithinMs = digestSweep ? millisecondsAfterLocalNine(Date.parse(String(digestSweep.completedAt))) : null;
+    let liveProvider;
+    if (agentConfig && readinessPolicy && Array.isArray(readinessPolicy.providers)) {
+        const outwardConfig = object(agentConfig.humanFacing, "outward provider");
+        const innerConfig = object(agentConfig.agentFacing, "inner provider");
+        const readinessProviders = readinessPolicy.providers.map((entry) => object(entry, "provider readiness candidate"));
+        const minimaxReadiness = readinessProviders.find((entry) => entry.provider === "minimax");
+        if (minimaxReadiness && outwardConfig.provider === "minimax" && innerConfig.provider === "minimax") {
+            const readCredential = deps.readProviderCredential ?? provider_credentials_1.readProviderCredentialRecord;
+            const checkProvider = deps.providerPing ?? provider_ping_1.pingProvider;
+            const minimaxRecord = await readCredential(TARGET_ID, "minimax", { refreshIfMissing: false });
+            const outwardModel = text(outwardConfig.model, "outward model");
+            const innerModel = text(innerConfig.model, "inner model");
+            const minimaxConfig = minimaxRecord.ok ? { ...minimaxRecord.record.credentials, ...minimaxRecord.record.config } : null;
+            const unavailablePing = { ok: false, classification: "auth-failure", message: "credential unavailable", attempts: [] };
+            const outwardPing = minimaxConfig ? await checkProvider("minimax", minimaxConfig, { model: outwardModel, timeoutMs: 10_000 }) : unavailablePing;
+            const innerPing = minimaxConfig ? await checkProvider("minimax", minimaxConfig, { model: innerModel, timeoutMs: 10_000 }) : unavailablePing;
+            const pingReceipts = [
+                { lane: "outward", provider: "minimax", model: outwardModel, credentialRevision: minimaxRecord.ok ? minimaxRecord.record.revision : null, ok: outwardPing.ok, attempts: outwardPing.attempts?.map(({ provider, model, operation, ok }) => ({ provider, model, operation, ok })) ?? [] },
+                { lane: "inner", provider: "minimax", model: innerModel, credentialRevision: minimaxRecord.ok ? minimaxRecord.record.revision : null, ok: innerPing.ok, attempts: innerPing.attempts?.map(({ provider, model, operation, ok }) => ({ provider, model, operation, ok })) ?? [] },
+            ];
+            const requestSemanticsExact = pingReceipts.every((receipt) => receipt.ok && receipt.attempts.length >= 1 && receipt.attempts.length <= 3
+                && receipt.attempts.every((attempt) => attempt.provider === receipt.provider && attempt.model === receipt.model && attempt.operation === "ping" && typeof attempt.ok === "boolean")
+                && receipt.attempts.at(-1)?.ok === true);
+            const fallbackAttemptCount = pingReceipts.reduce((count, receipt) => count + receipt.attempts.filter((attempt) => attempt.provider !== receipt.provider || attempt.model !== receipt.model).length, 0);
+            const minimaxCredentials = minimaxRecord.ok ? minimaxRecord.record.credentials : {};
+            let exactContract = { laneSelectionExact: false, vaultCoordinatesExact: false, singleCredentialExact: false };
+            if (typeof minimaxCredentials.apiKey === "string") {
+                const input = {
+                    outward: { provider: text(outwardConfig.provider, "outward provider"), model: outwardModel },
+                    inner: { provider: text(innerConfig.provider, "inner provider"), model: innerModel },
+                    minimax: { vaultItem: typeof minimaxReadiness?.vaultItem === "string" ? minimaxReadiness.vaultItem : "", apiKey: minimaxCredentials.apiKey },
+                    selectionPolicy: text(readinessPolicy.selectionPolicy, "provider selection policy"),
+                };
+                exactContract = evaluateSanctuaryProviderReadinessContract(input);
+            }
+            liveProvider = {
+                outwardReady: outwardPing.ok,
+                innerReady: innerPing.ok,
+                silentFallback: readinessPolicy.selectionPolicy !== "explicit-same-lane-only",
+                credentialRevisionsPresent: minimaxRecord.ok && Boolean(minimaxRecord.record.revision),
+                requestSemanticsExact,
+                fallbackAttemptCount,
+                ...exactContract,
+                pingReceipts,
+            };
+        }
+    }
+    let containment;
+    if (label === "unit-16e-containment-audit" || label === "unit-16d-2-unknown-admission") {
+        const inventoryEnvelope = object(await dependency(deps.hostRequest, "Sanctuary host broker")({ operation: "inventory_keys", targetServerId: TARGET_SERVER_ID }), "containment key inventory");
+        if (!Array.isArray(inventoryEnvelope.keys))
+            throw new Error("containment key inventory is invalid");
+        const rawInventory = inventoryEnvelope.keys.map((entry) => object(entry, "containment key record"));
+        const inventory = rawInventory.map(normalizeKey);
+        const redactedInventory = inventory.map((record) => ({
+            idDigest: (0, node_crypto_1.createHash)("sha256").update(record.id).digest("hex"),
+            name: record.name,
+            permissions: flattenedPermissions(record),
+            roles: [...record.roles].sort(),
+        })).sort((left, right) => left.name.localeCompare(right.name));
+        const readRecord = inventory.find((record) => record.name === "Butler RO");
+        const writeRecord = inventory.find((record) => record.name === "Butler RW");
+        const rawProfiles = (0, node_fs_1.readFileSync)(path.join(agentRoot, "tool-profiles.json"), "utf8");
+        const packagedProfiles = (0, node_fs_1.readFileSync)(path.resolve(__dirname, "../../../deploy/unraid/sanctuary.ouro/tool-profiles.json"), "utf8");
+        if (!(0, node_util_1.isDeepStrictEqual)(JSON.parse(rawProfiles), JSON.parse(packagedProfiles)))
+            throw new Error("Sanctuary containment profiles do not match the verified package");
+        const relationshipRegistry = (0, relationship_authorization_1.loadRelationshipCapabilityRegistry)(agentRoot);
+        const digest = (value) => (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(value)).digest("hex");
+        const boundaryFor = async (profileId) => {
+            const profile = relationshipRegistry.profiles[profileId];
+            const inner = profileId === "sanctuary-event";
+            const runtime = await dependency(deps.providerRuntime, "current provider runtime")(inner ? "agent" : "human", { agentName: TARGET_ID, agentRoot });
+            const context = containmentToolContext(agentRoot, profileId);
+            const select = (toolContext) => (0, tools_1.selectToolsForChannel)((0, friends_1.getChannelCapabilities)(inner ? "inner" : "telegram"), undefined, undefined, runtime.capabilities, undefined, undefined, toolContext);
+            const selection = select(context);
+            const schemas = (0, tools_1.toolSelectionSchemas)(selection);
+            const schemaToolNames = schemas.map((tool) => tool.function.name);
+            const expectedNames = profile.toolNames.filter((name) => name !== "sanctuary_host_execute" && !tools_1.SANCTUARY_MCP_PROVIDED_TOOLS.has(name) && (inner || name !== "rest") && (name !== "set_reasoning_effort" || runtime.capabilities.has("reasoning-effort")));
+            const excludedNames = ["vault_get", "mcp_call", "exec", "credential_get", ...(profileId === "sanctuary-owner" ? [] : tools_1.SANCTUARY_OWNER_ADDITIONS)];
+            const poisoned = select({ ...context, relationshipAuthorization: {
+                    ...context.relationshipAuthorization, advertisedToolNames: [...profile.toolNames, ...excludedNames, "mcp__containment_poison"],
+                } });
+            const productionBoundaryReceipts = await dependency(deps.runProductionBoundaryProbe, "production tool boundary probe")({ agentRoot, profileId, providerRuntime: runtime });
+            const excludedAttempts = productionBoundaryReceipts.filter((receipt) => receipt.name !== "unraid_get_system");
+            return {
+                profileId, profileVersion: profile.version, profileDigest: digest(profile), profileToolNames: profile.toolNames,
+                providerCapabilities: [...runtime.capabilities], schemaDigest: digest(schemas), schemaToolNames,
+                ordinaryDefinitionCount: selection.ordinary.length, engineSchemaCount: selection.engine.length,
+                profileExact: true, schemasExact: (0, node_util_1.isDeepStrictEqual)([...schemaToolNames].sort(), [...expectedNames].sort()),
+                handlersExact: selection.ordinary.every((definition) => typeof definition.handler === "function") && selection.engine.every((schema) => [tools_1.ponderTool, tools_1.settleTool, tools_1.speakTool, tools_1.restTool].includes(schema)),
+                poisonedSchemaIntersectionCount: (0, tools_1.toolSelectionSchemas)(poisoned).filter((schema) => !schemaToolNames.includes(schema.function.name)).length,
+                excludedToolNames: excludedAttempts.map((receipt) => receipt.name),
+                excludedSchemaIntersectionCount: schemaToolNames.filter((name) => excludedNames.includes(name)).length,
+                fabricatedHandlerInvocationCount: excludedAttempts.filter((receipt) => receipt.invoked).length,
+                excludedToolAttemptCount: excludedAttempts.length,
+                excludedToolRejectedCount: excludedAttempts.filter((receipt) => receipt.reason === "profile_excluded").length,
+                excludedToolInvokedCount: excludedAttempts.filter((receipt) => receipt.invoked).length,
+                excludedToolSideEffectCount: excludedAttempts.filter((receipt) => receipt.sideEffect).length,
+                globallyResolvableExcludedToolCount: excludedAttempts.filter((receipt) => receipt.globallyResolvable).length,
+            };
+        };
+        const profileBoundaries = {
+            "sanctuary-owner": await boundaryFor("sanctuary-owner"),
+            "sanctuary-household": await boundaryFor("sanctuary-household"),
+            "sanctuary-event": await boundaryFor("sanctuary-event"),
+        };
+        if ((0, node_fs_1.readFileSync)(path.join(agentRoot, "tool-profiles.json"), "utf8") !== rawProfiles)
+            throw new Error("Sanctuary containment profiles changed during the audit");
+        const restartDefinition = (0, tools_1.resolveToolDefinition)("unraid_restart_container");
+        const writeApprovalPolicy = restartDefinition.approvalPolicy({ container: "calibre-web" });
+        const writeApprovalPolicyExact = writeApprovalPolicy.kind === "required"
+            && writeApprovalPolicy.policyId === "sanctuary.unraid.restart.v1"
+            && writeApprovalPolicy.actionClass === "unraid.container.restart"
+            && writeApprovalPolicy.requiresSoleCall === true;
+        let lifecycleBalance = 0;
+        let lifecyclePairs = 0;
+        for (const entry of auditLedgerEntries) {
+            if (entry.event === "senses.telegram_turn_start")
+                lifecycleBalance += 1;
+            if (entry.event === "senses.telegram_turn_end" && lifecycleBalance > 0) {
+                lifecycleBalance -= 1;
+                lifecyclePairs += 1;
+            }
+        }
+        const rawWriteMaterialFieldCount = rawInventory.reduce((count, record) => count
+            + Object.keys(record).filter((field) => /^(?:key|credential|secret|token)$/iu.test(field)).length, 0);
+        if (container && typeof container.readOnlyRoot !== "boolean")
+            throw new Error("containment root-mode observation must be boolean");
+        containment = {
+            schemaVersion: "sanctuary-containment-audit-v2",
+            keyCount: inventory.length,
+            keyInventoryDigest: (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(redactedInventory)).digest("hex"),
+            readScopeDigest: (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(readRecord ? flattenedPermissions(readRecord) : [])).digest("hex"),
+            writeScopeDigest: (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(writeRecord ? flattenedPermissions(writeRecord) : [])).digest("hex"),
+            keyRoleAssignmentCount: inventory.reduce((count, record) => count + record.roles.length, 0),
+            profileBoundaries,
+            auditPathDigest: (0, node_crypto_1.createHash)("sha256").update(TELEGRAM_AUDIT).digest("hex"),
+            auditLedgerDigest: (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(auditLedgerEntries)).digest("hex"),
+            auditRecordCount: auditLedgerEntries.length,
+            auditLifecyclePairCount: lifecyclePairs,
+            containerUser: typeof container?.user === "string" ? container.user : "",
+            liveProcessUser: typeof container?.liveProcessUser === "string" ? container.liveProcessUser : "",
+            mountCount: Number(container?.mountCount ?? -1),
+            publishedPortCount: Number(container?.publishedPortCount ?? -1),
+            networkMode: typeof container?.networkMode === "string" ? container.networkMode : "",
+            readOnlyRoot: container?.readOnlyRoot === true,
+            mountsExact: container?.mountsExact === true,
+            securityExact: container?.securityExact === true,
+            updaterDisabled: container?.updaterDisabled === true,
+            writableKeyExposure: container?.writableKeyExposure !== false,
+            rawWriteMaterialFieldCount,
+            typedWriteExecutorCount: relationshipRegistry.profiles["sanctuary-owner"].toolNames.filter((name) => name === "unraid_restart_container" && writeApprovalPolicy.kind === "required").length,
+            writeApprovalPolicyDigest: (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(writeApprovalPolicy)).digest("hex"),
+            writeApprovalPolicyExact,
+            sensitiveMaterialObserved: auditContainsSensitiveMaterial(auditRaw ?? "", deps.telegramCredentials?.()) || rawWriteMaterialFieldCount > 0 || container?.writableKeyExposure === true,
+            stopDenied, restartDenied, denialAuditCount, denialStateUnchanged, denialProbeCompleted,
+        };
+    }
+    const telegramAdmissions = label === "unit-16d-2-unknown-admission"
+        ? await projectTelegramAdmissions(agentRoot, dependency(deps.telegramCredentials, "Telegram credentials")(), identityRaw?.trim() ?? null)
+        : [];
+    const sourceValues = {
+        "identity-key": identityRaw, "telegram-audit": auditEntries, "telegram-offset": gatewayCursor.progressDigest,
+        "approval-journal": approvals, "approval-checkpoints": checkpointsRaw, "container-inspect": container,
+        "provider-live-check": liveProvider ?? null, "cron-runtime": cronRaw, "health-runtime": health, "restart-attempt-ledger": restartAttempts,
+        "digest-runtime": health, "reboot-checkpoint": rebootCheckpoint, "telegram-turn-receipts": telegramTurns, "read-only-denial-receipt": denialReceipt ?? null,
+        "identity-surface-audit": identity ? { inspectedRecordCount: identity.inspectedRecordCount, opaqueSubjectCount: identity.opaqueSubjectCount, mismatchCount: identity.mismatchCount, rawLeakCount: identity.rawLeakCount, canonicalSessionCount: identity.canonicalSessionCount, canonicalFriendCount: identity.canonicalFriendCount, sessionSurfaceDigest: identity.sessionSurfaceDigest, friendSurfaceDigest: identity.friendSurfaceDigest, surfaceDigest: identity.surfaceDigest } : null,
+        "containment-audit": containment ?? null,
+        "telegram-admission-evidence": telegramAdmissions,
+        "health-probe-receipt": healthProbe ?? null,
+        "scheduler-liveness-receipt": healthProbe?.schedulerReceipt ?? null,
+        "interactive-driver-receipt": parsedJson(interactiveDriverRaw),
+        "live-grounding-read": liveGrounding ?? null,
+    };
+    const zeroWork = {
+        providerToolDigest: (0, node_crypto_1.createHash)("sha256").update(JSON.stringify({ telegramTurnsRaw, restartAttemptsRaw })).digest("hex"),
+        outwardDigest: (0, node_crypto_1.createHash)("sha256").update(JSON.stringify({
+            deliveredReceipts: health?.deliveredReceipts ?? [],
+            outwardEvents: auditLedgerEntries.filter((entry) => /(?:delivered|send|outbound)/u.test(entry.event)),
+        })).digest("hex"),
+        approvalMutationDigest: (0, node_crypto_1.createHash)("sha256").update(JSON.stringify({
+            checkpointsRaw,
+            approvalStoreDigest: digestOptionalFiles([approvalDatabasePath, `${approvalDatabasePath}-wal`, `${approvalDatabasePath}-shm`]),
+            restartAttemptsRaw,
+            restartCount: container?.restartCount ?? null,
+        })).digest("hex"),
+        sessionFriendDigest: (0, node_crypto_1.createHash)("sha256").update(JSON.stringify({
+            sessionSurfaceDigest: identity?.sessionSurfaceDigest ?? null,
+            friendSurfaceDigest: identity?.friendSurfaceDigest ?? null,
+        })).digest("hex"),
+    };
+    return {
+        capturedAt: deps.now?.() ?? Date.now(),
+        sourceValues,
+        postbootIntegrity,
+        prebootIntegrity,
+        events: auditEntries,
+        approvals,
+        restartAttempts,
+        telegramTurns,
+        telegramAdmissions,
+        telegramNextUpdateId,
+        zeroWork,
+        liveGrounding,
+        identity,
+        container: container ? {
+            exactImage: typeof expectedImageId === "string" && SHA256.test(expectedImageId) && container.imageId === `sha256:${expectedImageId}`, running: container.running === true,
+            healthy: container.health === "healthy", user: text(container.user, "container user"), readOnlyRoot: container.readOnlyRoot === true,
+            mountCount: Number(container.mountCount), publishedPortCount: Number(container.publishedPortCount), restartPolicy: text(container.restartPolicy, "restart policy"), restartCount: Number(container.restartCount),
+            autostartExact: container.autostartExact === true, mountsExact: container.mountsExact === true, updaterDisabled: container.updaterDisabled === true,
+            vaultUnlocked: container.vaultUnlocked === true, manualAuthRequired: container.manualAuthRequired === true,
+        } : undefined,
+        provider: liveProvider,
+        healthProbe,
+        interactiveDriver,
+        denial: denialReceipt,
+        cron: cronRaw ? { registered: canonicalSanctuaryHealthCronRegistered(cronRaw), fingerprint: (0, node_crypto_1.createHash)("sha256").update(cronRaw).digest("hex"), receiptDigest: (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(health ? health.deliveredReceipts : null)).digest("hex"), sweepCount: healthSweeps.length } : undefined,
+        health: health ? { transitionCount: healthSweeps.filter((receipt) => Number(receipt.opened) > 0 || Number(receipt.recovered) > 0).length, alertCount: scenarioDeliveries.filter((receipt) => receipt.kind === "transition" || receipt.kind === "transition_and_digest").length, productionRestored: container?.running === true && container.health === "healthy" } : undefined,
+        digest: health && digestFiredWithinMs !== null ? { scheduleObserved: Boolean(cronRaw && canonicalSanctuaryHealthCronRegistered(cronRaw)), messageCount: scenarioDeliveries.filter((receipt) => receipt.kind === "digest" || receipt.kind === "transition_and_digest").length, firedWithinMs: digestFiredWithinMs, productionRestored: container?.running === true && container.health === "healthy" } : undefined,
+        reboot,
+        containment: containment ?? {
+            schemaVersion: "sanctuary-containment-audit-v2", keyCount: 0, keyInventoryDigest: "", readScopeDigest: "", writeScopeDigest: "", keyRoleAssignmentCount: 0,
+            profileBoundaries: null, auditPathDigest: "", auditLedgerDigest: "", auditRecordCount: 0, auditLifecyclePairCount: 0,
+            containerUser: "", liveProcessUser: "", mountCount: 0, publishedPortCount: 0, networkMode: "", readOnlyRoot: false, mountsExact: false, securityExact: false, updaterDisabled: false,
+            writableKeyExposure: container?.writableKeyExposure === true, rawWriteMaterialFieldCount: 0, typedWriteExecutorCount: 0, writeApprovalPolicyDigest: "", writeApprovalPolicyExact: false,
+            sensitiveMaterialObserved: auditContainsSensitiveMaterial(auditRaw ?? "") || container?.writableKeyExposure === true,
+            stopDenied, restartDenied, denialAuditCount, denialStateUnchanged, denialProbeCompleted,
+        },
+    };
+}
+async function postbootIntegritySnapshot(deps) {
+    const agentRoot = (0, identity_1.getAgentRoot)(TARGET_ID);
+    const identityRaw = optionalFixedFile(deps, pathFor(agentRoot, "state/senses/telegram/identity.key"));
+    const auditRaw = optionalFixedFile(deps, TELEGRAM_AUDIT);
+    const auditHeadRaw = optionalFixedFile(deps, TELEGRAM_AUDIT_HEAD);
+    if ((auditRaw === null) !== (auditHeadRaw === null))
+        throw new Error("Telegram audit ledger/head presence mismatch");
+    if (auditRaw !== null && (!identityRaw || !/^[A-Za-z0-9_-]{43}\n?$/u.test(identityRaw)))
+        throw new Error("Telegram audit ledger identity key is unavailable");
+    const auditLedgerEntries = auditRaw === null ? [] : (0, telegram_audit_ledger_1.verifyTelegramAuditLedger)({
+        ledgerRaw: auditRaw,
+        headRaw: auditHeadRaw,
+        identityKey: identityRaw.trim(),
+    });
+    const restartAttemptsRaw = optionalFixedFile(deps, pathFor(agentRoot, "state/acceptance/restart-attempts.ndjson")) ?? "";
+    return buildPostbootIntegritySnapshot({
+        telegramNextUpdateId: (await readGatewayCursor(deps)).nextUpdateId, checkpointsRaw: optionalFixedFile(deps, pathFor(agentRoot, "state/approvals/checkpoints.json")),
+        restartAttempts: parseRestartAttempts(restartAttemptsRaw, null), cronRaw: optionalFixedFile(deps, "/home/ouro/.ouro-cli/scheduler/sanctuary.crontab"),
+        health: parseHealthAcceptanceState(optionalFixedFile(deps, pathFor(agentRoot, "state/health/sanctuary-health.json"))), auditLedgerEntries,
+        activeScenarioHandleDigest: (0, sanctuary_acceptance_marker_1.readSanctuaryAcceptanceMarker)(TARGET_ID)?.scenarioHandleDigest ?? null,
+    });
+}
+function pathFor(root, suffix) { return `${root}/${suffix}`; }
+async function captureAcceptanceScenario(payload, deps) {
+    const phase = text(payload.phase, "scenario phase");
+    if (phase !== "begin" && phase !== "poll")
+        throw new Error("scenario phase is invalid");
+    exactKeys(payload, phase === "begin" ? ["operation", "phase", "label", "externalGate", "sources"] : ["operation", "phase", "label", "externalGate", "sources", "checkpointDigest"], "scenario payload");
+    const label = text(payload.label, "scenario label");
+    if (!sanctuary_acceptance_harness_1.SANCTUARY_UNIT_16_EVIDENCE_LABELS.includes(label))
+        throw new Error("scenario label is invalid");
+    const externalGate = text(payload.externalGate, "scenario external gate");
+    if (externalGate !== sanctuary_acceptance_harness_1.SANCTUARY_SCENARIO_GATES[label])
+        throw new Error("scenario external gate is invalid");
+    if (!Array.isArray(payload.sources) || JSON.stringify(payload.sources) !== JSON.stringify(sanctuary_acceptance_harness_1.SANCTUARY_SCENARIO_SOURCES[label]))
+        throw new Error("scenario sources are invalid");
+    if (!deps.captureScenario)
+        throw new Error("scenario capture is unavailable");
+    return deps.captureScenario({ phase, label, externalGate, sources: payload.sources, ...(phase === "poll" ? { checkpointDigest: text(payload.checkpointDigest, "scenario checkpoint digest") } : {}) });
+}
+function normalizePermission(value) {
+    const permission = object(value, "Unraid key permission");
+    if (JSON.stringify(Object.keys(permission).sort()) !== JSON.stringify(["actions", "resource"]))
+        throw new Error("Unraid key permission fields are invalid");
+    const resource = text(permission.resource, "Unraid key permission resource");
+    if (!PERMISSION_RESOURCES.has(resource))
+        throw new Error("Unraid key permission resource is invalid");
+    if (!Array.isArray(permission.actions) || permission.actions.length === 0)
+        throw new Error("Unraid key permission actions are invalid");
+    const actions = permission.actions.map((action) => text(action, "Unraid key permission action"));
+    if (new Set(actions).size !== actions.length || actions.some((action) => !PERMISSION_ACTIONS.has(action)))
+        throw new Error("Unraid key permission actions are invalid");
+    return { resource, actions: [...actions].sort() };
+}
+function normalizeKey(value) {
+    const key = value;
+    if (!Array.isArray(key.permissions))
+        throw new Error("Unraid key permissions are invalid");
+    if (!Array.isArray(key.roles) || !key.roles.every((role) => typeof role === "string"))
+        throw new Error("Unraid key roles are invalid");
+    return {
+        id: keyId(key.id),
+        name: text(key.name, "Unraid key name"),
+        permissions: key.permissions.map(normalizePermission),
+        roles: [...key.roles],
+    };
+}
+function scope(key) {
+    const flattened = key.permissions.flatMap((permission) => permission.actions.map((action) => `${permission.resource}:${action}`)).sort();
+    if (JSON.stringify(flattened) === JSON.stringify(RO_PERMISSIONS))
+        return "read-only";
+    if (JSON.stringify(flattened) === JSON.stringify([...RO_PERMISSIONS, "DOCKER:UPDATE_ANY"].sort()))
+        return "bounded-write";
+    return "legacy-write";
+}
+function sameSecret(left, right) {
+    const leftBytes = Buffer.from(left, "utf8");
+    const rightBytes = Buffer.from(right, "utf8");
+    return leftBytes.length === rightBytes.length && (0, node_crypto_1.timingSafeEqual)(leftBytes, rightBytes);
+}
+function exactLoopbackGraphqlEndpoint(value) {
+    const endpoint = new URL(text(value, "endpoint"));
+    if ((endpoint.protocol !== "http:" && endpoint.protocol !== "https:")
+        || (endpoint.hostname !== "127.0.0.1" && endpoint.hostname !== "localhost" && endpoint.hostname !== "::1")
+        || endpoint.pathname !== "/graphql" || endpoint.username || endpoint.password || endpoint.search || endpoint.hash) {
+        throw new Error("probe endpoint must be an exact loopback GraphQL endpoint");
+    }
+    return endpoint;
+}
+function inventory(deps) {
+    const keys = deps.readKeyFiles().map(normalizeKey);
+    if (new Set(keys.map((key) => key.id)).size !== keys.length)
+        throw new Error("Unraid key inventory contains duplicate IDs");
+    if (new Set(keys.map((key) => key.name)).size !== keys.length)
+        throw new Error("Unraid key inventory contains duplicate names");
+    return keys;
+}
+async function vaultBackedCapabilityVerify(payload, deps) {
+    const id = keyId(payload.keyId);
+    const capability = text(payload.capability, "capability");
+    if (capability !== "read-only" && capability !== "bounded-write")
+        throw new Error("capability is invalid");
+    const args = [
+        "exec", "-i", "ouro-butler-staging",
+        "/opt/ouro/deploy/unraid/sanctuary-acceptance-adapter.sh",
+        "vault-probe", id, capability,
+    ];
+    const result = await deps.execFile("/usr/bin/docker", args);
+    const response = object(JSON.parse(result.stdout), "vault probe result");
+    if (response.valid !== true || response.keyId !== id || response.capability !== capability)
+        throw new Error("vault-backed capability verification failed");
+    return { verified: true, keyId: id, capability };
+}
+function closedInventory(deps) {
+    return {
+        keys: inventory(deps).map((key) => ({
+            id: key.id,
+            scope: scope(key),
+            roles: key.roles.length === 0 ? "none" : "present",
+        })).sort((left, right) => left.id.localeCompare(right.id)),
+    };
+}
+async function exactIdRevoke(payload, deps) {
+    const id = keyId(payload.keyId);
+    const matches = inventory(deps).filter((key) => key.id === id);
+    if (matches.length !== 1)
+        throw new Error("exact Unraid key ID is absent or ambiguous");
+    const target = matches[0];
+    const result = await deps.execFile("/usr/local/sbin/unraid-api", ["apikey", "--name", target.name, "--delete", "--json"]);
+    const response = object(JSON.parse(result.stdout), "Unraid revoke result");
+    if (response.deleted !== 1 || !Array.isArray(response.keys) || response.keys.length !== 1)
+        throw new Error("Unraid revoke result is invalid");
+    const deleted = object(response.keys[0], "deleted Unraid key");
+    if (deleted.id !== id || deleted.name !== target.name)
+        throw new Error("Unraid revoke did not return the exact key ID");
+    return { revoked: true, id };
+}
+async function revokedKeyAuthRejection(payload, deps) {
+    const id = keyId(payload.keyId);
+    const endpoint = exactLoopbackGraphqlEndpoint(payload.endpoint);
+    const descriptorPayload = object(JSON.parse(deps.readDescriptor()), "revoked-key descriptor");
+    if (JSON.stringify(Object.keys(descriptorPayload).sort()) !== JSON.stringify(["descriptor", "keyId"]))
+        throw new Error("revoked-key descriptor shape is invalid");
+    if (keyId(descriptorPayload.keyId) !== id)
+        throw new Error("revoked-key descriptor ID mismatch");
+    const descriptor = text(descriptorPayload.descriptor, "revoked-key descriptor value");
+    const signal = AbortSignal.timeout(NETWORK_TIMEOUT_MS);
+    const response = await deps.fetch(endpoint.href, {
+        method: "POST",
+        headers: { "content-type": "application/json", "x-api-key": descriptor },
+        body: JSON.stringify({ query: AUTH_PROBE, variables: {} }),
+        signal,
+    });
+    if (response.status !== 401 && response.status !== 403)
+        throw new Error("revoked Unraid key did not receive an authentication rejection");
+    return { rejected: true, id, status: response.status };
+}
+function dependency(value, label) {
+    if (!value)
+        throw new Error(`${label} is unavailable`);
+    return value;
+}
+function exactKeys(value, keys, label) {
+    if (JSON.stringify(Object.keys(value).sort()) !== JSON.stringify([...keys].sort()))
+        throw new Error(`${label} shape is invalid`);
+}
+function sha256(value) {
+    return (0, node_crypto_1.createHash)("sha256").update(value, "utf8").digest("hex");
+}
+function fixedFile(deps, filePath) {
+    return dependency(deps.readFixedFile, "fixed file reader")(filePath);
+}
+async function runtimeConfig(reader, label, ...args) {
+    const result = await dependency(reader, label)(...args);
+    if (!result.ok)
+        throw new Error(`${label} is unavailable`);
+    return result.config;
+}
+async function readGatewayCursor(deps) {
+    const cursor = await dependency(deps.gatewayCursor, "signed gateway cursor")();
+    if (!cursor || !Number.isSafeInteger(cursor.nextUpdateId) || cursor.nextUpdateId < 0 || typeof cursor.progressDigest !== "string" || !/^sha256:[a-f0-9]{64}$/u.test(cursor.progressDigest))
+        throw new Error("signed gateway cursor is invalid");
+    return cursor;
+}
+async 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 cursor = await readGatewayCursor(deps);
+    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");
+    }
+    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: cursor.progressDigest.slice("sha256:".length),
+        auditCursorDigest,
+    };
+}
+async function telegramPollerQuiescence(payload, deps) {
+    if (payload.expectedState !== "stopped" || JSON.stringify(Object.keys(payload).sort()) !== JSON.stringify(["expectedState", "operation"])) {
+        throw new Error("Telegram poller quiescence request is invalid");
+    }
+    const fact = object(await dependency(deps.hostRequest, "Sanctuary host broker")({ operation: "telegram_gateway_quiescence", targetId: TARGET_ID }), "Telegram root poller proof");
+    exactKeys(fact, ["schemaVersion", "activePollers", "residentStopped", "processBindingDigest", "keyId", "publicKeyDigest", "botId", "observedAt"], "Telegram root poller proof");
+    const gateway = dependency(deps.gateway, "Telegram root gateway")();
+    try {
+        if (!await gateway.authorityTransport.hostApproval?.refresh())
+            throw new Error("Telegram root gateway health is unavailable");
+        const cursor = await gateway.cursorSnapshot();
+        const now = (deps.now ?? Date.now)();
+        if (fact.schemaVersion !== 1 || fact.activePollers !== 1 || fact.residentStopped !== true
+            || typeof fact.processBindingDigest !== "string" || !SHA256.test(fact.processBindingDigest)
+            || fact.keyId !== cursor.keyId || fact.publicKeyDigest !== cursor.publicKeyDigest || fact.botId !== cursor.botId
+            || typeof fact.observedAt !== "string" || !Number.isFinite(Date.parse(fact.observedAt))
+            || Date.parse(fact.observedAt) > now || now - Date.parse(fact.observedAt) > 30_000)
+            throw new Error("Telegram root poller proof is invalid or stale");
+        return { quiesced: true, activePollers: 1 };
+    }
+    finally {
+        gateway.authorityTransport.api.stop();
+    }
+}
+function callbackUpdate(value) {
+    const update = object(value, "callback update");
+    object(update.callback_query, "callback update callback_query");
+    return update;
+}
+function withCallbackPlaybackJournal(agentRoot, operation) {
+    const databasePath = path.join(agentRoot, CALLBACK_PLAYBACK_JOURNAL);
+    (0, node_fs_1.mkdirSync)(path.dirname(databasePath), { recursive: true, mode: 0o700 });
+    const database = new better_sqlite3_1.default(databasePath);
+    try {
+        (0, node_fs_1.chmodSync)(databasePath, 0o600);
+        database.pragma("journal_mode = DELETE");
+        database.pragma("synchronous = FULL");
+        database.exec(`
+      CREATE TABLE IF NOT EXISTS callback_playback (
+        coordinate_digest TEXT PRIMARY KEY NOT NULL CHECK(length(coordinate_digest) = 64),
+        playback_count INTEGER NOT NULL CHECK(playback_count > 0)
+      )
+    `);
+        return operation(database);
+    }
+    finally {
+        database.close();
+    }
+}
+function callbackPlaybackSnapshot(agentRoot, coordinateDigest) {
+    if (!SHA256.test(coordinateDigest))
+        throw new Error("callback coordinate digest is invalid");
+    return withCallbackPlaybackJournal(agentRoot, (database) => {
+        const rows = database.prepare("SELECT coordinate_digest, playback_count FROM callback_playback ORDER BY coordinate_digest")
+            .all();
+        if (rows.some((row) => !SHA256.test(row.coordinate_digest) || !Number.isSafeInteger(row.playback_count) || row.playback_count <= 0)) {
+            throw new Error("callback playback journal is invalid");
+        }
+        const playbackCount = rows.find((row) => row.coordinate_digest === coordinateDigest)?.playback_count ?? 0;
+        return { playbackCount, coordinateDigest, journalDigest: sha256(JSON.stringify(rows)) };
+    });
+}
+function recordCallbackPlayback(agentRoot, coordinateDigest) {
+    if (!SHA256.test(coordinateDigest))
+        throw new Error("callback coordinate digest is invalid");
+    withCallbackPlaybackJournal(agentRoot, (database) => {
+        database.prepare(`
+      INSERT INTO callback_playback (coordinate_digest, playback_count) VALUES (?, 1)
+      ON CONFLICT(coordinate_digest) DO UPDATE SET playback_count = playback_count + 1
+    `).run(coordinateDigest);
+    });
+}
+function callbackCoordinate(update) {
+    const updateId = update.update_id;
+    if (!Number.isSafeInteger(updateId) || Number(updateId) < 0)
+        throw new Error("callback update_id is invalid");
+    const callback = object(update.callback_query, "callback update callback_query");
+    const from = object(callback.from, "callback update sender");
+    const message = object(callback.message, "callback update message");
+    const chat = object(message.chat, "callback update chat");
+    const callbackId = (value, label) => {
+        if (!Number.isSafeInteger(value) || Number(value) <= 0)
+            throw new Error(`${label} is invalid`);
+        return String(value);
+    };
+    const coordinate = {
+        updateId: Number(updateId),
+        queryId: text(callback.id, "callback query id"),
+        callbackData: text(callback.data, "callback data"),
+        userId: callbackId(from.id, "callback user id"),
+        chatId: callbackId(chat.id, "callback chat id"),
+        messageId: callbackId(message.message_id, "callback message id"),
+    };
+    return {
+        updateId: coordinate.updateId,
+        digest: sha256(`ouroboros.sanctuary.callback-coordinate.v1\0${JSON.stringify(coordinate)}`),
+    };
+}
+async function callbackPlaybackPreflight(payload, deps) {
+    exactKeys(payload, ["operation", "update"], "callback playback preflight request");
+    const coordinate = callbackCoordinate(callbackUpdate(payload.update));
+    const offset = await readGatewayCursor(deps);
+    const snapshot = object(dependency(deps.callbackPlaybackSnapshot, "callback playback journal")(coordinate.digest), "callback playback journal snapshot");
+    exactKeys(snapshot, ["coordinateDigest", "journalDigest", "playbackCount"], "callback playback journal snapshot");
+    if (snapshot.coordinateDigest !== coordinate.digest || typeof snapshot.journalDigest !== "string" || !SHA256.test(snapshot.journalDigest)
+        || !Number.isSafeInteger(snapshot.playbackCount) || Number(snapshot.playbackCount) < 0) {
+        throw new Error("callback playback journal snapshot is invalid");
+    }
+    return {
+        playbackCount: Math.max(Number(snapshot.playbackCount), Number(offset.nextUpdateId) > coordinate.updateId ? 1 : 0),
+        coordinateDigest: coordinate.digest,
+        journalDigest: snapshot.journalDigest,
+    };
+}
+async function concurrentCallbackProbe(payload, deps) {
+    const update = callbackUpdate(payload.update);
+    if (!Number.isSafeInteger(payload.concurrency) || payload.concurrency < 2 || payload.concurrency > 16) {
+        throw new Error("callback concurrency is invalid");
+    }
+    const probe = dependency(deps.callbackProbe, "callback probe");
+    const results = await Promise.all(Array.from({ length: payload.concurrency }, () => probe(update, false)));
+    return { results };
+}
+async function callbackReplay(payload, deps) {
+    return dependency(deps.callbackProbe, "callback probe")(callbackUpdate(payload.update), true);
+}
+async function interactiveRuntimeOperation(payload, deps) {
+    exactKeys(payload, ["operation", "label", "scenarioHandleDigest"], "interactive runtime payload");
+    const operation = text(payload.operation, "interactive runtime operation");
+    const label = text(payload.label, "interactive runtime label");
+    const scenarioHandleDigest = text(payload.scenarioHandleDigest, "interactive runtime scenario digest");
+    if (!SHA256.test(scenarioHandleDigest))
+        throw new Error("interactive runtime scenario digest is invalid");
+    const expectedLabel = operation === "drive_timeout_stale" ? "unit-16k-timeout-stale"
+        : operation === "drive_duplicate_callbacks" ? "unit-16l-duplicate-callback"
+            : "unit-16m-restart-continuation";
+    if (label !== expectedLabel)
+        throw new Error("interactive runtime label is invalid");
+    return dependency(deps.interactiveRuntime, "interactive production runtime")({ operation, label, scenarioHandleDigest });
+}
+async function interactiveRuntimeReady(payload) {
+    exactKeys(payload, ["operation", "label", "scenarioHandleDigest"], "interactive readiness payload");
+    if (payload.label !== "unit-16m-restart-continuation" || typeof payload.scenarioHandleDigest !== "string" || !SHA256.test(payload.scenarioHandleDigest)) {
+        throw new Error("interactive readiness coordinates are invalid");
+    }
+    const agentRoot = (0, identity_1.getAgentRoot)(TARGET_ID);
+    const socketPath = path.join(agentRoot, "state", "acceptance", "telegram-control.sock");
+    try {
+        const response = object(await defaultHostRequest(payload, socketPath, 2_000), "interactive readiness response");
+        exactKeys(response, ["ready"], "interactive readiness response");
+        return { ready: response.ready === true };
+    }
+    catch {
+        return { ready: false };
+    }
+}
+function requireTargetServer(payload) {
+    if (text(payload.targetServerId, "targetServerId") !== TARGET_SERVER_ID)
+        throw new Error("targetServerId is invalid");
+}
+function flattenedPermissions(record) {
+    return record.permissions.flatMap((permission) => permission.actions.map((action) => `${permission.resource}:${action}`)).sort();
+}
+async function keyInventory(payload, deps) {
+    requireTargetServer(payload);
+    const response = object(await dependency(deps.hostRequest, "Sanctuary host broker")({
+        operation: "inventory_keys", targetServerId: TARGET_SERVER_ID,
+    }), "host key inventory");
+    if (!Array.isArray(response.keys))
+        throw new Error("host key inventory is invalid");
+    const keys = response.keys.map(normalizeKey);
+    if (new Set(keys.map(({ id }) => id)).size !== keys.length || new Set(keys.map(({ name }) => name)).size !== keys.length) {
+        throw new Error("host key inventory is ambiguous");
+    }
+    return { keys: keys.map((record) => ({
+            id: record.id, name: record.name, permissions: flattenedPermissions(record), roles: [...record.roles].sort(),
+        })).sort((left, right) => left.id.localeCompare(right.id)) };
+}
+function permissionStrings(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        throw new Error("permissions are invalid");
+    const result = value.map((permission) => text(permission, "permission"));
+    if (new Set(result).size !== result.length || result.some((permission) => !/^[A-Z_]+:(?:CREATE|READ|UPDATE|DELETE)_(?:ANY|OWN)$/u.test(permission))) {
+        throw new Error("permissions are invalid");
+    }
+    return [...result].sort();
+}
+async function createKey(payload, deps) {
+    requireTargetServer(payload);
+    const name = text(payload.name, "Unraid key name");
+    if (!/^Butler (?:RO|RW)(?: Rotation [0-9a-f]{16})?$/u.test(name))
+        throw new Error("Unraid key name is invalid");
+    const permissions = permissionStrings(payload.permissions);
+    const field = name.startsWith("Butler RO") ? "unraidReadApiKey" : "unraidWriteApiKey";
+    const expected = field === "unraidReadApiKey" ? RO_PERMISSIONS : [...RO_PERMISSIONS, "DOCKER:UPDATE_ANY"].sort();
+    if (JSON.stringify(permissions) !== JSON.stringify(expected))
+        throw new Error("Unraid key scope is invalid");
+    const raw = object(await dependency(deps.hostRequest, "Sanctuary host broker")({
+        operation: "create_key", targetServerId: TARGET_SERVER_ID, name, permissions,
+    }), "created Unraid key");
+    const created = normalizeKey(raw);
+    const id = created.id;
+    const key = text(raw.key, "created Unraid key credential");
+    if (created.name !== name || JSON.stringify(flattenedPermissions(created)) !== JSON.stringify(permissions)
+        || created.roles.length !== 0)
+        throw new Error("created Unraid key scope mismatch");
+    const stored = await dependency(deps.mergeMachine, "machine vault writer")(TARGET_ID, TARGET_ID, {
+        [field]: key,
+        sanctuaryAcceptanceKeyHandles: { [id]: key },
+    });
+    if (!stored.ok || stored.config[field] !== key)
+        throw new Error("created Unraid key vault readback failed");
+    return { id, name, key: `unraid-key:${id}:${field}`, permissions, roles: [] };
+}
+async function storeKey(payload, deps) {
+    requireTargetServer(payload);
+    const id = keyId(payload.keyId);
+    const field = text(payload.vaultField, "vaultField");
+    if (field !== "unraidReadApiKey" && field !== "unraidWriteApiKey")
+        throw new Error("vaultField is invalid");
+    const handle = text(payload.key, "Unraid key handle");
+    if (handle !== `unraid-key:${id}:${field}`)
+        throw new Error("Unraid key handle is invalid");
+    const stored = await runtimeConfig(deps.refreshMachine, "Sanctuary machine runtime config", TARGET_ID, TARGET_ID);
+    const handles = object(stored.sanctuaryAcceptanceKeyHandles, "vault-backed acceptance key handles");
+    if (text(handles[id], "vault-backed Unraid credential") !== text(stored[field], "vault-backed Unraid credential")) {
+        throw new Error("Unraid key handle does not bind to the active vault field");
+    }
+    const acknowledged = object(await dependency(deps.hostRequest, "Sanctuary host broker")({
+        operation: "acknowledge_key_storage", targetServerId: TARGET_SERVER_ID, keyId: id,
+    }), "Unraid key storage acknowledgement");
+    if (acknowledged.acknowledged !== true || acknowledged.id !== id) {
+        throw new Error("Unraid key storage acknowledgement failed");
+    }
+    return { stored: true, keyId: id };
+}
+async function probeKey(payload, deps) {
+    requireTargetServer(payload);
+    const id = keyId(payload.id);
+    const handle = text(payload.key, "Unraid key handle");
+    const config = await runtimeConfig(deps.refreshMachine, "Sanctuary machine runtime config", TARGET_ID, TARGET_ID);
+    const handleMatch = /^unraid-key:([A-Za-z0-9._:-]+):(unraidReadApiKey|unraidWriteApiKey)$/u.exec(handle);
+    if (!handleMatch || handleMatch[1] !== id)
+        throw new Error("Unraid key handle is invalid");
+    const handles = object(config.sanctuaryAcceptanceKeyHandles, "vault-backed acceptance key handles");
+    const key = text(handles[id], "vault-backed Unraid credential");
+    const endpoint = exactLoopbackGraphqlEndpoint(config.unraidGraphqlUrl);
+    let response;
+    try {
+        response = await deps.fetch(endpoint.href, {
+            method: "POST", headers: { "content-type": "application/json", "x-api-key": key },
+            body: JSON.stringify({ query: AUTH_PROBE, variables: {} }), signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS),
+        });
+    }
+    catch {
+        throw new Error("Unraid key readiness probe failed");
+    }
+    const envelope = object(await response.json(), "Unraid key readiness response");
+    if (!response.ok || !envelope.data || envelope.errors)
+        throw new Error("Unraid key readiness probe failed");
+    return { valid: true };
+}
+async function readOldKey(payload, deps) {
+    requireTargetServer(payload);
+    const id = keyId(payload.id);
+    const raw = object(await dependency(deps.hostRequest, "Sanctuary host broker")({
+        operation: "read_key_record", targetServerId: TARGET_SERVER_ID, keyId: id,
+    }), "old Unraid key record");
+    const record = { ...normalizeKey(raw), key: text(raw.key, "old Unraid key credential") };
+    if (record.id !== id)
+        throw new Error("old Unraid key ID does not match the host record");
+    const stored = await dependency(deps.mergeMachine, "machine vault writer")(TARGET_ID, TARGET_ID, { sanctuaryAcceptanceKeyHandles: { [id]: record.key } });
+    if (!stored.ok)
+        throw new Error("old Unraid key recovery storage failed");
+    return { key: `unraid-key:${id}:legacy` };
+}
+async function revokeKey(payload, deps) {
+    requireTargetServer(payload);
+    const id = keyId(payload.id);
+    const response = object(await dependency(deps.hostRequest, "Sanctuary host broker")({
+        operation: "revoke_key", targetServerId: TARGET_SERVER_ID, keyId: id,
+    }), "host key revoke");
+    if (response.revoked !== true || response.id !== id)
+        throw new Error("host key revoke did not attest the exact ID");
+    return { revoked: true, id };
+}
+async function probeRevokedKey(payload, deps) {
+    requireTargetServer(payload);
+    const id = keyId(payload.id);
+    const handle = text(payload.key, "revoked Unraid key handle");
+    if (handle !== `unraid-key:${id}:legacy` && !handle.startsWith(`unraid-key:${id}:unraid`))
+        throw new Error("revoked Unraid key handle is invalid");
+    const response = object(await dependency(deps.hostRequest, "Sanctuary host broker")({
+        operation: "probe_revoked_key", targetServerId: TARGET_SERVER_ID, keyId: id,
+    }), "revoked key host proof");
+    if (response.valid !== false || response.id !== id || (response.status !== 401 && response.status !== 403)) {
+        throw new Error("revoked Unraid key still authenticates");
+    }
+    const cleared = await dependency(deps.mergeMachine, "machine vault writer")(TARGET_ID, TARGET_ID, { sanctuaryAcceptanceKeyHandles: { [id]: "" } });
+    if (!cleared.ok)
+        throw new Error("revoked Unraid key recovery cleanup failed");
+    return { valid: false, status: response.status, id };
+}
+async function provenance(payload, deps) {
+    if (payload.schema !== "sanctuary-unit-16-provenance-v1")
+        throw new Error("provenance schema is invalid");
+    const imageDigest = fixedFile(deps, IMAGE_DIGEST_FILE).trim();
+    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 = await cursorSnapshot({ operation: "snapshot", schema: "telegram-cursor-v1", allowGenesis: false }, deps);
+    return { imageDigest, containerDigest, cursorDigest: sha256(`${cursor.offsetDigest}\0${cursor.auditCursorDigest}`) };
+}
+async function evidenceSnapshot(payload, deps) {
+    if (payload.schema !== "postboot-health-v1")
+        throw new Error("evidence schema is invalid");
+    const health = object(JSON.parse(fixedFile(deps, POSTBOOT_HEALTH_FILE)), "postboot health");
+    exactKeys(health, ["healthy"], "postboot health");
+    if (typeof health.healthy !== "boolean")
+        throw new Error("postboot health is invalid");
+    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: (await cursorSnapshot({ operation: "snapshot", schema: "telegram-cursor-v1", allowGenesis: false }, deps)).offsetDigest,
+    };
+}
+function bootId(deps) {
+    const value = fixedFile(deps, BOOT_ID_FILE).trim();
+    if (!/^[A-Za-z0-9-]{4,128}$/u.test(value))
+        throw new Error("boot identity is invalid");
+    return value;
+}
+async function requestReboot(payload, deps) {
+    if (text(payload.targetId, "targetId") !== TARGET_ID)
+        throw new Error("targetId is invalid");
+    const idempotencyKey = text(payload.idempotencyKey, "idempotencyKey");
+    const preflightDigest = text(payload.preflightDigest, "preflightDigest");
+    const processBindingDigest = text(payload.processBindingDigest, "processBindingDigest");
+    if (!/^[0-9a-f]{32}$/u.test(idempotencyKey))
+        throw new Error("idempotencyKey is invalid");
+    if (!SHA256.test(preflightDigest) || !SHA256.test(processBindingDigest))
+        throw new Error("reboot binding digest is invalid");
+    const response = object(await dependency(deps.hostRequest, "Sanctuary host broker")({
+        operation: "request_reboot", targetId: TARGET_ID, idempotencyKey, preflightDigest, processBindingDigest,
+    }), "host reboot staging");
+    const requestId = text(response.requestId, "host reboot requestId");
+    const reservationId = text(response.reservationId, "host reboot reservationId");
+    const prebootId = text(response.prebootId, "host reboot prebootId");
+    if (response.accepted !== true || response.staged !== true || response.targetId !== TARGET_ID || response.preflightDigest !== preflightDigest || response.processBindingDigest !== processBindingDigest
+        || requestId !== sha256(`sanctuary-reboot\0${idempotencyKey}`)
+        || reservationId !== sha256(`sanctuary-reboot-reservation\0${requestId}`))
+        throw new Error("host reboot staging attestation is invalid");
+    return { accepted: true, targetId: TARGET_ID, requestId, reservationId, prebootId, preflightDigest, processBindingDigest };
+}
+async function rebootPreflight(payload, deps) {
+    if (text(payload.targetId, "targetId") !== TARGET_ID)
+        throw new Error("targetId is invalid");
+    const processBindingDigest = fixedFile(deps, PROCESS_BINDING_DIGEST_FILE).trim();
+    if (!SHA256.test(processBindingDigest))
+        throw new Error("process binding digest is invalid");
+    const result = object(await dependency(deps.hostRequest, "Sanctuary host broker")({ operation: "reboot_preflight_snapshot", targetId: TARGET_ID, processBindingDigest }), "host reboot preflight");
+    const digest = text(result.digest, "host reboot preflight digest");
+    if (!SHA256.test(digest) || result.processBindingDigest !== processBindingDigest || result.safe !== true || result.arrayReady !== true || result.parityActive !== false || result.moverActive !== false || result.mutationActive !== false) {
+        throw new Error("host reboot preflight attestation is invalid");
+    }
+    return result;
+}
+function pollReboot(payload, deps) {
+    if (text(payload.targetId, "targetId") !== TARGET_ID)
+        throw new Error("targetId is invalid");
+    const requestId = text(payload.requestId, "requestId");
+    if (!SHA256.test(requestId))
+        throw new Error("requestId is invalid");
+    return { targetId: TARGET_ID, requestId, state: "ready", bootId: bootId(deps) };
+}
+async function materializeConfig(payload, deps) {
+    const command = text(payload.command, "materializer command");
+    const contract = object(JSON.parse(fixedFile(deps, CONTRACT_FILE)), "acceptance contract");
+    const templates = object(contract.configTemplates, "acceptance config templates");
+    const template = object(templates[command], "acceptance config template");
+    const config = { ...object(template.fixed, "acceptance fixed config") };
+    const adapterPath = "/opt/ouro/deploy/unraid/sanctuary-acceptance-adapter.sh";
+    if (command === "telegram-bootstrap") {
+        const offset = await readGatewayCursor(deps);
+        Object.assign(config, { expectedBotId: "8541786263", expectedUsername: "MendelowCloudButlerBot", currentOffset: offset.nextUpdateId });
+    }
+    else if (command === "cursor-snapshot") {
+        const phase = text(payload.phase, "cursor snapshot phase");
+        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");
+        if (!Array.isArray(closed.keys) || closed.keys.length === 0)
+            throw new Error("closed Unraid inventory is empty");
+        const ids = closed.keys.map((raw) => keyId(object(raw, "closed Unraid key").id));
+        if (new Set(ids).size !== ids.length)
+            throw new Error("closed Unraid inventory IDs are ambiguous");
+        config.oldKeys = ids.sort().map((id) => ({ id, secretAdapter: adapterPath }));
+    }
+    else if (command === "evidence-bundle-index") {
+        config.entries = sanctuary_acceptance_harness_1.SANCTUARY_UNIT_16_EVIDENCE_LABELS.map((label) => ({ label, path: `/evidence/${label}.json` }));
+    }
+    return config;
+}
+async function telegramReadiness(payload, deps) {
+    exactKeys(payload, ["operation"], "Telegram readiness payload");
+    let gateway;
+    try {
+        gateway = dependency(deps.gateway, "Telegram root gateway")();
+    }
+    catch {
+        throw new Error("Telegram gateway inventory or pins are unavailable; actor: agent-runnable; inspect root migration");
+    }
+    const api = gateway.authorityTransport.api;
+    let bot;
+    try {
+        if (!await gateway.authorityTransport.hostApproval?.refresh())
+            throw new Error("root authority is unhealthy");
+        await gateway.cursorSnapshot();
+        bot = await api.request("getMe", {}, AbortSignal.timeout(30_000));
+    }
+    catch {
+        throw new Error("Telegram gateway health or identity probe failed; actor: agent-runnable; inspect root authority");
+    }
+    finally {
+        try {
+            api.stop();
+        }
+        catch {
+            throw new Error("Telegram client cleanup failed; actor: agent-runnable; retry Telegram readiness");
+        }
+    }
+    if (!bot || typeof bot !== "object" || Array.isArray(bot)
+        || String(bot.id) !== gateway.credentials.botId || gateway.credentials.botId !== "8541786263"
+        || bot.username !== "MendelowCloudButlerBot") {
+        throw new Error("Telegram bot identity mismatch; actor: human-required; repair root gateway identity");
+    }
+    return { ready: true, identityMatches: true };
+}
+async function executeSanctuaryAcceptanceAdapter(rawPayload, deps = createSanctuaryAcceptanceAdapterDependencies()) {
+    const payload = object(rawPayload, "acceptance adapter payload");
+    const operation = text(payload.operation, "operation");
+    (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.sanctuary_acceptance_adapter_start", message: "Sanctuary acceptance adapter started", meta: { operation } });
+    try {
+        let result;
+        switch (operation) {
+            case "vault-backed-capability-verify":
+                result = await vaultBackedCapabilityVerify(payload, deps);
+                break;
+            case "closed-inventory":
+                result = closedInventory(deps);
+                break;
+            case "exact-id-revoke":
+                result = await exactIdRevoke(payload, deps);
+                break;
+            case "revoked-key-auth-rejection":
+                result = await revokedKeyAuthRejection(payload, deps);
+                break;
+            case "quiesce_telegram_poller":
+                result = await telegramPollerQuiescence(payload, deps);
+                break;
+            case "snapshot":
+                result = await cursorSnapshot(payload, deps);
+                break;
+            case "callback_playback_preflight":
+                result = await callbackPlaybackPreflight(payload, deps);
+                break;
+            case "inject_callbacks_concurrently":
+                result = await concurrentCallbackProbe(payload, deps);
+                break;
+            case "inject_callback_replay":
+                result = await callbackReplay(payload, deps);
+                break;
+            case "drive_timeout_stale":
+                result = await interactiveRuntimeOperation(payload, deps);
+                break;
+            case "drive_duplicate_callbacks":
+                result = await interactiveRuntimeOperation(payload, deps);
+                break;
+            case "prepare_restart_continuation":
+                result = await interactiveRuntimeOperation(payload, deps);
+                break;
+            case "reconcile_restart_continuation":
+                result = await interactiveRuntimeOperation(payload, deps);
+                break;
+            case "interactive_runtime_ready":
+                result = await interactiveRuntimeReady(payload);
+                break;
+            case "inventory_keys":
+                result = await keyInventory(payload, deps);
+                break;
+            case "create_key":
+                result = await createKey(payload, deps);
+                break;
+            case "store_key":
+                result = await storeKey(payload, deps);
+                break;
+            case "probe_new_key":
+                result = await probeKey(payload, deps);
+                break;
+            case "read_old_key":
+                result = await readOldKey(payload, deps);
+                break;
+            case "revoke_key":
+                result = await revokeKey(payload, deps);
+                break;
+            case "probe_revoked_key":
+                result = await probeRevokedKey(payload, deps);
+                break;
+            case "evidence_snapshot":
+                result = await evidenceSnapshot(payload, deps);
+                break;
+            case "capture_evidence_provenance":
+                result = await provenance(payload, deps);
+                break;
+            case "capture_acceptance_scenario":
+                result = await captureAcceptanceScenario(payload, deps);
+                break;
+            case "finalize_acceptance_scenarios":
+                exactKeys(payload, ["operation"], "scenario finalization payload");
+                if (!deps.finalizeScenarios)
+                    throw new Error("scenario finalization is unavailable");
+                await deps.finalizeScenarios();
+                result = { finalized: true };
+                break;
+            case "reboot_preflight_snapshot":
+                result = await rebootPreflight(payload, deps);
+                break;
+            case "postboot_integrity_snapshot":
+                result = await postbootIntegritySnapshot(deps);
+                break;
+            case "request_reboot":
+                result = await requestReboot(payload, deps);
+                break;
+            case "poll_reboot":
+                result = pollReboot(payload, deps);
+                break;
+            case "materialize_config":
+                result = await materializeConfig(payload, deps);
+                break;
+            case "telegram_readiness":
+                result = await telegramReadiness(payload, deps);
+                break;
+            default: throw new Error("unknown Sanctuary acceptance adapter operation");
+        }
+        (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.sanctuary_acceptance_adapter_end", message: "Sanctuary acceptance adapter completed", meta: { operation } });
+        return result;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "error", component: "daemon", event: "daemon.sanctuary_acceptance_adapter_error", message: "Sanctuary acceptance adapter failed", meta: { operation, category: error instanceof Error ? error.name : "unknown" } });
+        throw error;
+    }
+}
+async function executeSanctuaryAcceptanceVaultProbe(keyIdValue, capabilityValue, deps = createSanctuaryAcceptanceVaultProbeDependencies({ keyRecordPath: SELECTED_KEY_RECORD })) {
+    const id = keyId(keyIdValue);
+    const capability = text(capabilityValue, "capability");
+    if (capability !== "read-only" && capability !== "bounded-write")
+        throw new Error("capability is invalid");
+    const refreshed = await deps.refresh("sanctuary", "sanctuary");
+    if (!refreshed.ok)
+        throw new Error("Sanctuary machine runtime credentials are unavailable");
+    const endpoint = exactLoopbackGraphqlEndpoint(refreshed.config.unraidGraphqlUrl);
+    const field = capability === "read-only" ? "unraidReadApiKey" : "unraidWriteApiKey";
+    const descriptor = text(refreshed.config[field], "vault-backed Unraid descriptor");
+    const matches = deps.readKeyRecords().filter((record) => sameSecret(record.key, descriptor));
+    if (matches.length !== 1 || matches[0].id !== id)
+        throw new Error("vault descriptor does not bind to the exact key ID");
+    const matched = matches[0];
+    const expectedName = capability === "read-only" ? "Butler RO" : "Butler RW";
+    if (matched.name !== expectedName || matched.roles.length !== 0 || scope(matched) !== capability) {
+        throw new Error("vault-backed Unraid key metadata scope is invalid");
+    }
+    const headers = { "content-type": "application/json", "x-api-key": descriptor };
+    const readResponse = await deps.fetch(endpoint.href, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ query: AUTH_PROBE, variables: {} }),
+        signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS),
+    });
+    if (!readResponse.ok)
+        throw new Error("vault-backed Unraid capability probe failed");
+    const readEnvelope = object(await readResponse.json(), "vault-backed Unraid response");
+    if (!readEnvelope.data || readEnvelope.errors)
+        throw new Error("vault-backed Unraid capability probe was rejected");
+    const writeResponse = await deps.fetch(endpoint.href, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ query: WRITE_PROBE, variables: { id: MISSING_CONTAINER_ID } }),
+        signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS),
+    });
+    const writeEnvelope = object(await writeResponse.json(), "vault-backed Unraid write response");
+    const errors = Array.isArray(writeEnvelope.errors) ? writeEnvelope.errors.map((value) => object(value, "GraphQL error")) : [];
+    const codes = errors.map((error) => {
+        const extensions = error.extensions && typeof error.extensions === "object" && !Array.isArray(error.extensions)
+            ? error.extensions
+            : {};
+        return typeof extensions.code === "string" ? extensions.code : "";
+    });
+    if (capability === "read-only") {
+        if (writeEnvelope.data || (writeResponse.status !== 403 && !codes.includes("FORBIDDEN") && !codes.includes("PERMISSION_DENIED"))) {
+            throw new Error("read-only Unraid key did not prove write permission denial");
+        }
+        return { valid: true, keyId: id, capability, proof: "read-authorized-write-denied" };
+    }
+    if (writeEnvelope.data || !writeResponse.ok || !codes.includes("NOT_FOUND")) {
+        throw new Error("bounded-write Unraid key did not reach deterministic not-found");
+    }
+    return { valid: true, keyId: id, capability, proof: "read-authorized-write-reached-not-found" };
+}
+async function executeSanctuaryAcceptanceRevokedProbe(keyIdValue, endpointValue, rawKeyFile, deps = { fetch }) {
+    const id = keyId(keyIdValue);
+    const raw = object(JSON.parse(rawKeyFile), "revoked Unraid key file");
+    if (keyId(raw.id) !== id)
+        throw new Error("revoked Unraid key file ID mismatch");
+    const descriptor = text(raw.key, "revoked Unraid key descriptor");
+    return revokedKeyAuthRejection({ keyId: id, endpoint: endpointValue }, {
+        readDescriptor: () => JSON.stringify({ keyId: id, descriptor }),
+        fetch: deps.fetch,
+    });
+}
+function createAcceptanceProbeEffects(input) {
+    const store = new telegram_effect_adapter_1.FileTelegramEffectJournal(path.join(input.agentRoot, "state", "telegram", "effects"));
+    const target = { kind: "approved_relationship", friendId: `telegram-user:${input.subject}`, sessionKey: `telegram:${input.subject}` };
+    const execute = (0, telegram_effect_adapter_1.createTelegramAuthorizedEffectExecutor)({
+        store,
+        api: input.api,
+        authorize: ({ target: candidate }) => JSON.stringify(candidate) === JSON.stringify(target)
+            ? { allowed: true, receiptId: `configured-owner:${input.subject}`, expiresAt: new Date(Date.now() + 5 * 60_000).toISOString(), transport: { chatId: input.chatId } }
+            : { allowed: false, reason: "effect target is not the configured owner relationship" },
+    });
+    const sessionPath = (0, shared_turn_1.getSenseSessionPath)(TARGET_ID, target.friendId, "telegram", target.sessionKey, input.agentRoot);
+    const port = (0, telegram_effect_adapter_1.createTelegramApprovalEffectPort)({
+        target,
+        chatId: input.chatId,
+        execute,
+        record: async (artifact) => { await (0, telegram_effect_adapter_1.recordTelegramEffectsInSession)({ store, sessionPath, artifacts: [artifact] }); },
+    });
+    return { port, close: () => store.close() };
+}
+exports.proveAttemptedRecoveryWithoutRetry = sanctuary_interactive_control_1.proveSanctuaryAttemptedRecoveryWithoutRetry;
+async function executeSanctuaryInteractiveRuntimeOperation(rawPayload, supplied) {
+    exactKeys(rawPayload, ["operation", "label", "scenarioHandleDigest"], "interactive runtime payload");
+    const agentRoot = supplied?.agentRoot ?? (0, identity_1.getAgentRoot)(TARGET_ID);
+    if (!supplied)
+        return defaultHostRequest(rawPayload, path.join(agentRoot, "state", "acceptance", "telegram-control.sock"), ADAPTER_TIMEOUT_MS);
+    const deps = {
+        agentRoot,
+        readApprovals: supplied.readApprovals ?? ((digest) => (0, approval_store_1.readApprovalsByScenarioHandleDigest)(path.join(agentRoot, "state", "approvals", "approvals.sqlite"), digest)),
+        readPending: dependency(supplied.readPending, "daemon-owned pending approval reader"),
+        createSession: supplied.createSession ?? (async () => { throw new Error("daemon-owned interactive callback session is unavailable"); }),
+        proveIndeterminateRecovery: supplied.proveIndeterminateRecovery
+            ?? ((approval, scenarioHandleDigest) => (0, sanctuary_interactive_control_1.proveSanctuaryAttemptedRecoveryWithoutRetry)(agentRoot, scenarioHandleDigest, approval)),
+        writeCredentialObserved: supplied.writeCredentialObserved ?? (() => /credential|api[_-]?key|token|secret/iu.test(JSON.stringify(rawPayload))),
+    };
+    return (0, sanctuary_interactive_control_1.executeSanctuaryInteractiveEngine)(rawPayload, deps);
+}
+async function executeSanctuaryAcceptanceCallbackProbe(rawUpdate, replay, deps = {
+    gateway: () => (0, sanctuary_authority_resident_1.openSanctuaryResidentAuthority)({}, {}),
+    identityKey: telegram_1.readOrCreateTelegramIdentityKey,
+    createRuntime: telegram_approval_runtime_1.createTelegramApprovalRuntime,
+    toolContext: sanctuary_runtime_1.createSanctuaryToolContext,
+    effects: createAcceptanceProbeEffects,
+    recordCallbackPlayback: (coordinateDigest) => recordCallbackPlayback((0, identity_1.getAgentRoot)(TARGET_ID), coordinateDigest),
+}) {
+    const update = callbackUpdate(rawUpdate);
+    const gateway = deps.gateway();
+    const credentials = gateway.credentials;
+    const identityKey = deps.identityKey((0, identity_1.getAgentRoot)(TARGET_ID));
+    const subject = (0, telegram_1.opaqueTelegramSubject)(identityKey, credentials.botId, credentials.authorizedUserId, credentials.authorizedChatId);
+    const api = gateway.authorityTransport.api;
+    const effectBoundary = deps.effects?.({ agentRoot: (0, identity_1.getAgentRoot)(TARGET_ID), api, subject, chatId: credentials.authorizedChatId });
+    const unavailableEffects = {
+        sendText: async () => { throw new Error("Telegram acceptance probe effect boundary is unavailable"); },
+        sendCard: async () => { throw new Error("Telegram acceptance probe effect boundary is unavailable"); },
+        edit: async () => { throw new Error("Telegram acceptance probe effect boundary is unavailable"); },
+        acknowledge: async () => { throw new Error("Telegram acceptance probe effect boundary is unavailable"); },
+    };
+    const runtime = deps.createRuntime({
+        agentName: TARGET_ID,
+        api,
+        authorizedUserId: credentials.authorizedUserId,
+        authorizedChatId: credentials.authorizedChatId,
+        subject,
+        identityKey,
+        toolContext: deps.toolContext(TARGET_ID),
+        effects: effectBoundary?.port ?? unavailableEffects,
+    });
+    try {
+        deps.recordCallbackPlayback(callbackCoordinate(update).digest);
+        const result = await runtime.transport.handleUpdate(update);
+        if (replay && (result.handled !== true || result.accepted !== false || result.reason !== "stale_callback")) {
+            throw new Error("Telegram callback replay did not settle as stale");
+        }
+        return {
+            settled: result.handled,
+            claimed: result.reason === "accepted" || result.reason === "decision_refused",
+            mutated: result.accepted,
+        };
+    }
+    finally {
+        runtime.close();
+        effectBoundary?.close();
+        api.stop();
+    }
+}