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

package/dist/senses/sanctuary-health-runner.js

@@ -33,114 +33,69 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runSanctuaryHealthPrivateTurn = runSanctuaryHealthPrivateTurn;
 exports.runSanctuaryHealthHabit = runSanctuaryHealthHabit;
 const path = __importStar(require("node:path"));
+const router_1 = require("../heart/external-events/router");
 const identity_1 = require("../heart/identity");
-const core_1 = require("../heart/core");
-const autonomy_budget_1 = require("../heart/autonomy-budget");
+const machine_identity_1 = require("../heart/machine-identity");
+const runtime_credentials_1 = require("../heart/runtime-credentials");
 const runtime_1 = require("../nerves/runtime");
-const tools_1 = require("../repertoire/tools");
-const telegram_client_1 = require("./telegram-client");
 const sanctuary_health_1 = require("./sanctuary-health");
 const sanctuary_runtime_1 = require("./sanctuary-runtime");
-const telegram_1 = require("./telegram");
-function privateTurnCallbacks(onProviderInvocation) {
-    return {
-        onModelStart() { onProviderInvocation?.(); }, onModelStreamStart() { }, onTextChunk() { }, onReasoningChunk() { },
-        onToolStart() { }, onToolEnd() { }, onError() { }, onClearText() { },
-    };
-}
-async function runSanctuaryHealthPrivateTurn(input) {
-    const definition = (0, tools_1.resolveToolDefinition)("send_message");
-    if (!definition)
-        throw new Error("canonical send_message definition is unavailable");
-    const agentRoot = (0, identity_1.getAgentRoot)(input.agentName);
-    const budgetTarget = { eventId: input.eventId, payloadStored: false };
-    const budget = (0, autonomy_budget_1.reserveAutonomyBudget)(agentRoot, {
-        agent: input.agentName,
-        triggerType: "habit",
-        sourceKind: "private-runtime",
-        senseOrHabit: "sanctuary-health",
-        target: budgetTarget,
-        idempotencyKey: `sanctuary-health:${input.eventId}`,
-    }, (0, autonomy_budget_1.resolveAutonomyBudgetPolicy)(agentRoot, input.agentName));
-    if (!budget.allowed && budget.status !== "duplicate")
-        throw new Error(`Sanctuary health private turn blocked: ${budget.reason}`);
-    let delivered = false;
-    const result = await (0, core_1.runAgent)([
-        {
-            role: "user",
-            content: [
-                "A durable Sanctuary health event is pending.",
-                `Event id: ${input.eventId}`,
-                `Deterministic payload: ${input.payload}`,
-                "Summarize it briefly for Ari. Call send_message exactly once with friendId=operator, channel=telegram, and the summary as content, then rest.",
-            ].join("\n"),
-        },
-    ], privateTurnCallbacks(input.onProviderInvocation), "inner", undefined, {
-        toolProfile: "sanctuary-health-private",
-        tools: [definition.tool],
-        toolContext: { signin: async () => undefined },
-        execTool: async (name, args) => {
-            if (name !== "send_message")
-                throw new Error(`Sanctuary health profile cannot execute ${name}`);
-            if (delivered)
-                throw new Error("Sanctuary health Telegram delivery was already attempted");
-            if (args.friendId !== "operator" || args.channel !== "telegram" || typeof args.content !== "string" || args.content.trim().length === 0) {
-                throw new Error("Sanctuary health send_message target or content is invalid");
-            }
-            await input.deliver(args.content);
-            delivered = true;
-            return "delivered";
-        },
-    });
-    if (result.outcome === "errored") {
-        throw result.error ?? new Error("Sanctuary health private turn failed");
-    }
-    return { delivered };
+function evidenceInputs(agentName, result) {
+    const revision = result.observationRevision;
+    const current = result.incidents.map((incident) => ({
+        agent: agentName,
+        source: "sanctuary-health",
+        eventType: "health.observed",
+        eventId: incident.id,
+        observationRevision: incident.observationRevision ?? revision,
+        transition: incident.transition ?? result.transition ?? "changed",
+        summary: incident.summary,
+        evidence: [incident.summary],
+        priority: "high",
+    }));
+    const recovered = (result.recovered ?? []).map((incident) => ({
+        agent: agentName,
+        source: "sanctuary-health",
+        eventType: "health.observed",
+        eventId: incident.id,
+        observationRevision: incident.observationRevision ?? revision,
+        transition: "recovered",
+        summary: `recovered: ${incident.summary}`,
+        evidence: [`recovered: ${incident.summary}`],
+        priority: "high",
+    }));
+    return [...current, ...recovered];
 }
 async function runSanctuaryHealthHabit(agentName, options = {}) {
+    if (!options.createSweep && !(0, runtime_credentials_1.readMachineRuntimeCredentialConfig)(agentName).ok) {
+        const machine = (0, machine_identity_1.loadOrCreateMachineIdentity)();
+        await (0, runtime_credentials_1.refreshMachineRuntimeCredentialConfig)(agentName, machine.machineId, { preserveCachedOnFailure: true });
+    }
     const sweep = options.createSweep?.(agentName) ?? (0, sanctuary_health_1.createSanctuaryHealthSweep)({
         toolContext: (0, sanctuary_runtime_1.createSanctuaryToolContext)(agentName),
         statePath: path.join((0, identity_1.getAgentRoot)(agentName), "state", "health", "sanctuary-health.json"),
     });
     const result = await sweep();
-    if (!result.message || !result.deliveryId) {
-        (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.sanctuary_health_habit", message: "Sanctuary native health habit completed without paid work", meta: { agentName, incidentCount: result.incidents.length, delivered: false } });
-        return { ok: true, message: "health sweep completed with no alert", data: { incidentCount: result.incidents.length, delivered: false } };
-    }
-    const credentials = (options.credentials ?? telegram_1.loadTelegramSenseCredentials)(agentName);
-    const api = (options.createApi ?? ((token) => (0, telegram_client_1.createTelegramBotApi)({ token })))(credentials.botToken);
-    const eventId = result.deliveryId;
-    const payload = result.message;
-    let attempted = false;
-    try {
-        const deliver = async (content) => {
-            if (attempted)
-                throw new Error("Sanctuary health Telegram delivery was already attempted");
-            attempted = true;
-            await sweep.cacheDeliveryPayload?.(result.deliveryId, content);
-            await sweep.markDeliveryAttempting?.(result.deliveryId);
-            const messageIds = await (0, telegram_client_1.sendTelegramText)(api, credentials.authorizedChatId, content);
-            await sweep.markDelivered?.(result.deliveryId, messageIds);
-        };
-        const privateResult = result.cachedMessage
-            ? (await deliver(result.cachedMessage), { delivered: true })
-            : await (async () => {
-                options.acceptanceMetrics?.onPrivateTurnStart();
-                return (options.runPrivateTurn ?? runSanctuaryHealthPrivateTurn)({
-                    agentName,
-                    eventId,
-                    payload,
-                    deliver,
-                    onProviderInvocation: options.acceptanceMetrics?.onProviderInvocation,
-                });
-            })();
-        (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.sanctuary_health_habit", message: "Sanctuary native health habit completed", meta: { agentName, incidentCount: result.incidents.length, delivered: privateResult.delivered } });
-        return { ok: true, message: privateResult.delivered ? "health sweep completed and delivered" : "health event remains pending", data: { incidentCount: result.incidents.length, delivered: privateResult.delivered } };
-    }
-    finally {
-        api.stop();
+    const inputs = evidenceInputs(agentName, result);
+    if (inputs.length === 0) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.sanctuary_health_habit",
+            message: "Sanctuary health evidence submitted",
+            meta: { agentName, incidentCount: 0, submitted: 0, wakesRequested: 0 },
+        });
+        return { ok: true, message: "health evidence submitted", data: { incidentCount: 0, submitted: 0, wakesRequested: 0 } };
     }
+    const submit = options.submitEvidence ?? ((input) => (0, router_1.recordExternalEvent)(input));
+    const receipts = await Promise.all(inputs.map((input) => submit(input)));
+    const wakesRequested = receipts.some((receipt) => receipt.shouldWake) ? 1 : 0;
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.sanctuary_health_habit",
+        message: "Sanctuary health evidence submitted",
+        meta: { agentName, incidentCount: result.incidents.length, submitted: inputs.length, wakesRequested },
+    });
+    return { ok: true, message: "health evidence submitted", data: { incidentCount: result.incidents.length, submitted: inputs.length, wakesRequested } };
 }

package/dist/senses/sanctuary-health.js

@@ -33,7 +33,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SANCTUARY_PUBLIC_ENDPOINTS = void 0;
 exports.withSanctuaryHealthStateLease = withSanctuaryHealthStateLease;
+exports.readSanctuaryHealthState = readSanctuaryHealthState;
 exports.probeSanctuaryEndpoint = probeSanctuaryEndpoint;
 exports.createSanctuaryHealthSweep = createSanctuaryHealthSweep;
 const fs = __importStar(require("node:fs"));
@@ -41,7 +43,7 @@ const path = __importStar(require("node:path"));
 const node_crypto_1 = require("node:crypto");
 const runtime_1 = require("../nerves/runtime");
 const sanctuary_acceptance_marker_1 = require("../heart/daemon/sanctuary-acceptance-marker");
-const ENDPOINTS = [
+exports.SANCTUARY_PUBLIC_ENDPOINTS = [
     "https://media.mendelow.cloud/",
     "https://books.mendelow.cloud/",
     "https://requests.mendelow.cloud/",
@@ -51,24 +53,23 @@ const REQUIRED_CONTAINERS = new Set(["calibre", "calibre-web", "Cloudflare-DDNS"
 const UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
 const MAX_HEALTH_STATE_BYTES = 4 * 1024 * 1024;
 const MAX_HEALTH_TEXT_BYTES = 50_000;
-function canonicalIsoTimestamp(value) {
-    if (typeof value !== "string" || value.length > 30)
-        return false;
-    const parsed = Date.parse(value);
-    return Number.isFinite(parsed) && new Date(parsed).toISOString() === value;
-}
-function boundedHealthText(value) {
-    if (Buffer.byteLength(value) <= MAX_HEALTH_TEXT_BYTES)
+const MAX_HEALTH_INCIDENT_BYTES = 4_096;
+function boundedIncidentText(value) {
+    if (Buffer.byteLength(value) <= MAX_HEALTH_INCIDENT_BYTES)
         return value;
-    const ellipsis = "…";
-    const contentByteLimit = MAX_HEALTH_TEXT_BYTES - Buffer.byteLength(ellipsis);
     let output = "";
     for (const character of value) {
-        if (Buffer.byteLength(output) + Buffer.byteLength(character) > contentByteLimit)
+        if (Buffer.byteLength(output) + Buffer.byteLength(character) > MAX_HEALTH_INCIDENT_BYTES - 3)
             break;
         output += character;
     }
-    return `${output}${ellipsis}`;
+    return `${output}…`;
+}
+function canonicalIsoTimestamp(value) {
+    if (typeof value !== "string" || value.length > 30)
+        return false;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) && new Date(parsed).toISOString() === value;
 }
 const healthLockTails = new Map();
 const healthLeaseBrand = Symbol("sanctuary-health-state-lease");
@@ -106,6 +107,7 @@ async function acquireHealthFileLease(statePath, timeoutMs) {
     const ownerPath = path.join(leasePath, "owner.json");
     const deadline = Date.now() + timeoutMs;
     const nonce = (0, node_crypto_1.createHash)("sha256").update((0, node_crypto_1.randomUUID)()).digest("hex");
+    fs.mkdirSync(path.dirname(statePath), { recursive: true });
     for (;;) {
         try {
             fs.mkdirSync(leasePath, { recursive: false, mode: 0o700 });
@@ -233,6 +235,10 @@ function load(filePath) {
         throw new Error("Sanctuary health state is corrupt", { cause: error });
     }
 }
+/** Read-only projection for status/orientation surfaces; mutation remains lease-owned by the sweep. */
+function readSanctuaryHealthState(filePath) {
+    return load(filePath);
+}
 function save(filePath, state) {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     const temporary = `${filePath}.tmp-${process.pid}-${(0, node_crypto_1.randomUUID)()}`;
@@ -293,18 +299,9 @@ function createSanctuaryHealthSweep(options) {
         const startedAt = now().toISOString();
         (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.sanctuary_health_start", message: "Sanctuary deterministic health sweep started", meta: { statePath: options.statePath, ...acceptanceEventMeta() } });
         const pendingState = load(options.statePath);
-        if (pendingState.outbox?.status === "pending") {
-            (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.sanctuary_health_end", message: "Sanctuary health delivery recovered from durable outbox", meta: { incidentCount: Object.keys(pendingState.incidents).length, deliveryId: pendingState.outbox.id, deliveryStatus: pendingState.outbox.status, ...acceptanceEventMeta() } });
-            return {
-                message: pendingState.outbox.message,
-                incidents: Object.values(pendingState.incidents),
-                deliveryId: pendingState.outbox.id,
-                ...(pendingState.outbox.summarizedMessage ? { cachedMessage: pendingState.outbox.summarizedMessage } : {}),
-            };
-        }
-        if (pendingState.outbox?.status === "attempting") {
-            pendingState.indeterminateDeliveries.push(pendingState.outbox);
+        if (pendingState.outbox) {
             pendingState.outbox = null;
+            pendingState.indeterminateDeliveries = [];
             pendingState.updatedAt = now().toISOString();
             save(options.statePath, pendingState);
         }
@@ -313,42 +310,49 @@ function createSanctuaryHealthSweep(options) {
             throw new Error("Sanctuary health runtime is unavailable");
         const [containersResult, storageResult, disksResult, notificationsResult, endpoints] = await Promise.all([
             runtime.listContainers(), runtime.getStorage(), runtime.getDisks(), runtime.getNotifications(),
-            Promise.all(ENDPOINTS.map((url) => probeSanctuaryEndpoint(url, fetchImpl))),
+            Promise.all(exports.SANCTUARY_PUBLIC_ENDPOINTS.map((url) => probeSanctuaryEndpoint(url, fetchImpl))),
         ]);
         const incidents = new Map();
-        const add = (id, summary) => incidents.set(id, { id, summary });
+        const add = (id, rawSummary) => {
+            const summary = boundedIncidentText(rawSummary);
+            incidents.set(id, {
+                id,
+                summary,
+                observationRevision: (0, node_crypto_1.createHash)("sha256").update(`${id}\0${summary}`).digest("hex"),
+            });
+        };
         const containers = record(containersResult)?.ok ? record(record(containersResult)?.data)?.containers : null;
         if (!Array.isArray(containers))
             add("containers:unavailable", "container status is unavailable");
         else
             for (const container of containers) {
                 if ((container.autostart === true || REQUIRED_CONTAINERS.has(container.name)) && container.state !== "running")
-                    add(`container:${container.id}:${container.state}:${container.exitCode ?? "none"}`, `${container.name} is ${container.state}`);
+                    add(`container:${container.id}:availability`, `${container.name} is ${container.state}`);
                 if (container.state === "unknown" || container.degraded === true)
-                    add(`container:${container.id}:degraded`, `${container.name} status is degraded`);
+                    add(`container:${container.id}:health`, `${container.name} status is degraded`);
             }
         const storage = record(storageResult)?.ok ? record(record(storageResult)?.data) : null;
         const array = record(storage?.array);
         if (!array || array.degraded || typeof array.usedPercent !== "number")
-            add("storage:array:degraded", "array capacity is unavailable");
+            add("storage:array:capacity", "array capacity is unavailable");
         else if (array.usedPercent >= 90)
-            add("storage:array:90", `array usage is ${array.usedPercent}%`);
+            add("storage:array:capacity", `array usage is ${array.usedPercent}%`);
         for (const share of Array.isArray(storage?.shares) ? storage.shares : [])
             if (share.degraded || typeof share.usedPercent !== "number")
-                add(`storage:share:${share.name}:degraded`, `${share.name} capacity is unavailable`);
+                add(`storage:share:${share.name}:capacity`, `${share.name} capacity is unavailable`);
             else if (share.usedPercent >= 90)
-                add(`storage:share:${share.name}:90`, `${share.name} usage is ${share.usedPercent}%`);
+                add(`storage:share:${share.name}:capacity`, `${share.name} usage is ${share.usedPercent}%`);
         const disks = record(disksResult)?.ok ? record(record(disksResult)?.data) : null;
         if (!disks)
             add("disks:unavailable", "disk health is unavailable");
         else {
             for (const disk of Array.isArray(disks.disks) ? disks.disks : []) {
                 if (disk.smart !== "passed")
-                    add(`disk:${disk.id}:smart:${disk.smart}`, `${disk.name} SMART is ${disk.smart}`);
+                    add(`disk:${disk.id}:smart`, `${disk.name} SMART is ${disk.smart}`);
                 if (typeof disk.temperatureC !== "number")
-                    add(`disk:${disk.id}:temperature:unknown`, `${disk.name} temperature is unavailable`);
+                    add(`disk:${disk.id}:temperature`, `${disk.name} temperature is unavailable`);
                 else if (disk.temperatureC >= 50)
-                    add(`disk:${disk.id}:temperature:50`, `${disk.name} is ${disk.temperatureC}°C`);
+                    add(`disk:${disk.id}:temperature`, `${disk.name} is ${disk.temperatureC}°C`);
             }
             const parity = record(disks.parity);
             if (!parity || parity.result !== "success" || typeof parity.ageHours !== "number" || parity.ageHours >= 45 * 24)
@@ -364,84 +368,41 @@ function createSanctuaryHealthSweep(options) {
             if (!endpoint.ok)
                 add(`endpoint:${endpoint.url}`, `${endpoint.url} returned ${endpoint.status || "no response"}`);
         const previous = load(options.statePath);
-        const current = Object.fromEntries([...incidents.entries()].sort(([a], [b]) => a.localeCompare(b)));
+        const current = Object.fromEntries([...incidents.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([id, incident]) => {
+            const prior = previous.incidents[id];
+            const transition = !prior ? "opened" : prior.observationRevision === incident.observationRevision ? "unchanged" : "changed";
+            return [id, { ...incident, transition }];
+        }));
         const opened = Object.values(current).filter((incident) => !previous.incidents[incident.id]);
+        const changed = Object.values(current).filter((incident) => incident.transition === "changed");
         const recovered = Object.values(previous.incidents).filter((incident) => !current[incident.id]);
-        const localParts = new Intl.DateTimeFormat("en-CA", { timeZone: "America/Los_Angeles", year: "numeric", month: "2-digit", day: "2-digit", hour: "2-digit", hourCycle: "h23" }).formatToParts(now());
-        const part = (type) => localParts.find((item) => item.type === type)?.value ?? "";
-        const day = `${part("year")}-${part("month")}-${part("day")}`;
-        const digestDue = Number(part("hour")) >= 9
-            && (Object.keys(current).length > 0 || previous.indeterminateDeliveries.length > 0)
-            && previous.lastDigestDay !== day;
-        const lines = [
-            ...opened.map((incident) => `🚨 ${incident.summary}`),
-            ...recovered.map((incident) => `✅ recovered: ${incident.summary}`),
-            ...(digestDue && Object.keys(current).length > 0 ? [`📋 still broken: ${Object.values(current).map((incident) => incident.summary).join("; ")}`] : []),
-            ...(digestDue && previous.indeterminateDeliveries.length > 0
-                ? previous.indeterminateDeliveries.map((delivery) => `⚠️ prior Telegram delivery was indeterminate: ${delivery.message}`)
-                : []),
-        ];
-        const message = lines.length ? boundedHealthText(lines.join("\n")) : null;
-        const deliveryKind = digestDue && (opened.length > 0 || recovered.length > 0)
-            ? "transition_and_digest"
-            : digestDue ? "digest" : "transition";
-        const delivery = message ? { id: (0, node_crypto_1.randomUUID)(), message, status: "pending", createdAt: now().toISOString(), kind: deliveryKind } : null;
         const acceptanceMeta = acceptanceEventMeta();
         const completedAt = now().toISOString();
+        const incidentDigest = (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(current)).digest("hex");
         const sweepReceipt = {
             sweepId,
             startedAt,
             completedAt,
-            incidentDigest: (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(current)).digest("hex"),
+            incidentDigest,
             opened: opened.length,
             recovered: recovered.length,
-            digestDue,
-            ...(delivery ? { deliveryId: delivery.id } : {}),
+            digestDue: false,
             ...(acceptanceMeta.scenarioHandleDigest ? { scenarioHandleDigest: acceptanceMeta.scenarioHandleDigest } : {}),
         };
         const next = {
             incidents: current,
-            lastDigestDay: digestDue ? day : previous.lastDigestDay,
+            lastDigestDay: null,
             updatedAt: now().toISOString(),
-            outbox: delivery,
-            indeterminateDeliveries: digestDue ? [] : previous.indeterminateDeliveries,
+            outbox: null,
+            indeterminateDeliveries: [],
             deliveredReceipts: previous.deliveredReceipts,
             sweepReceipts: [...previous.sweepReceipts, sweepReceipt].slice(-500),
         };
         save(options.statePath, next);
-        (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.sanctuary_health_end", message: "Sanctuary deterministic health sweep completed", meta: { incidentCount: incidents.size, opened: opened.length, recovered: recovered.length, digestDue, ...acceptanceEventMeta() } });
-        return { message, incidents: Object.values(current), ...(delivery ? { deliveryId: delivery.id } : {}) };
+        (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.sanctuary_health_end", message: "Sanctuary deterministic health sweep completed", meta: { incidentCount: incidents.size, opened: opened.length, recovered: recovered.length, digestDue: false, ...acceptanceEventMeta() } });
+        const transition = changed.length > 0 || (opened.length > 0 && recovered.length > 0) ? "changed" : opened.length > 0 ? "opened" : recovered.length > 0 ? "recovered" : "unchanged";
+        return { message: null, incidents: Object.values(current), recovered, observationRevision: incidentDigest, transition };
     };
     const sweep = (() => withHealthLock(options.statePath, runSweep, options.lease));
-    sweep.markDeliveryAttempting = (deliveryId) => withHealthLock(options.statePath, () => {
-        const state = load(options.statePath);
-        if (!state.outbox || state.outbox.id !== deliveryId || state.outbox.status !== "pending")
-            throw new Error(`Sanctuary health delivery ${deliveryId} is not pending`);
-        state.outbox.status = "attempting";
-        state.updatedAt = now().toISOString();
-        save(options.statePath, state);
-    }, options.lease);
-    sweep.cacheDeliveryPayload = (deliveryId, message) => withHealthLock(options.statePath, () => {
-        if (typeof message !== "string" || message.trim().length === 0 || Buffer.byteLength(message) > MAX_HEALTH_TEXT_BYTES)
-            throw new Error("Sanctuary health cached delivery payload must be nonempty and bounded");
-        const state = load(options.statePath);
-        if (!state.outbox || state.outbox.id !== deliveryId || state.outbox.status !== "pending")
-            throw new Error(`Sanctuary health delivery ${deliveryId} is not pending`);
-        state.outbox.summarizedMessage = message;
-        state.updatedAt = now().toISOString();
-        save(options.statePath, state);
-    }, options.lease);
-    sweep.markDelivered = (deliveryId, messageIds) => withHealthLock(options.statePath, () => {
-        if (!Array.isArray(messageIds) || messageIds.length < 1 || messageIds.length > 100 || !messageIds.every((id) => Number.isSafeInteger(id) && id > 0)) {
-            throw new Error("Sanctuary health delivery receipt requires canonical Telegram message ids");
-        }
-        const state = load(options.statePath);
-        if (!state.outbox || state.outbox.id !== deliveryId || state.outbox.status !== "attempting")
-            throw new Error(`Sanctuary health delivery ${deliveryId} is not attempting`);
-        state.deliveredReceipts = [...state.deliveredReceipts, { deliveryId, kind: state.outbox.kind, messageIds: [...messageIds], deliveredAt: now().toISOString() }].slice(-100);
-        state.outbox = null;
-        state.updatedAt = now().toISOString();
-        save(options.statePath, state);
-    }, options.lease);
     return sweep;
 }

package/dist/senses/sanctuary-runtime.js

@@ -42,11 +42,14 @@ const node_async_hooks_1 = require("node:async_hooks");
 const identity_1 = require("../heart/identity");
 const runtime_credentials_1 = require("../heart/runtime-credentials");
 const unraid_restart_1 = require("../repertoire/unraid-restart");
+const steward_policy_1 = require("../heart/steward-policy");
 const unraid_client_1 = require("../repertoire/unraid-client");
 const tools_unraid_1 = require("../repertoire/tools-unraid");
 const runtime_1 = require("../nerves/runtime");
 const sanctuary_acceptance_marker_1 = require("../heart/daemon/sanctuary-acceptance-marker");
 const sanctuary_grounding_1 = require("./sanctuary-grounding");
+const sanctuary_health_1 = require("./sanctuary-health");
+const sanctuary_sab_1 = require("./sanctuary-sab");
 const sanctuaryToolReceipts = new node_async_hooks_1.AsyncLocalStorage();
 const sanctuaryToolGroundings = new node_async_hooks_1.AsyncLocalStorage();
 const acceptanceLedgerTails = new Map();
@@ -165,6 +168,7 @@ function createSanctuaryToolContext(agentName) {
     const endpoint = required(initial, "unraidGraphqlUrl");
     const readClient = new unraid_client_1.UnraidClient({ endpoint, apiKey: required(initial, "unraidReadApiKey") });
     const reads = (0, tools_unraid_1.createUnraidReadTools)(readClient);
+    const sab = (0, sanctuary_sab_1.createSanctuarySabClient)();
     const acceptanceRead = (toolName, read) => async (...args) => {
         try {
             const result = await read(...args);
@@ -187,6 +191,8 @@ function createSanctuaryToolContext(agentName) {
         },
         acceptanceScenarioHandleDigest: () => (0, sanctuary_acceptance_marker_1.readSanctuaryAcceptanceMarker)(agentName)?.scenarioHandleDigest,
         acceptanceApproval: sanctuary_acceptance_marker_1.readSanctuaryAcceptanceApproval,
+        reserveRoutineAction: (input) => (0, steward_policy_1.consumeRoutineActionGrant)((0, identity_1.getAgentRoot)(agentName), input),
+        transitionRoutineAction: (input) => (0, steward_policy_1.transitionRoutineActionReceipt)((0, identity_1.getAgentRoot)(agentName), input),
     });
     return {
         sanctuary: {
@@ -196,11 +202,39 @@ function createSanctuaryToolContext(agentName) {
             getDisks: acceptanceRead("unraid_get_disks", reads.getDisks),
             getNotifications: acceptanceRead("unraid_get_notifications", reads.getNotifications),
             getSystem: acceptanceRead("unraid_get_system", reads.getSystem),
-            restartContainer: async (args) => {
-                const result = await restart(args);
+            checkServices: acceptanceRead("unraid_check_services", async () => {
+                const services = await Promise.all(sanctuary_health_1.SANCTUARY_PUBLIC_ENDPOINTS.map(async (url) => ({ name: new URL(url).hostname.split(".")[0], ...await (0, sanctuary_health_1.probeSanctuaryEndpoint)(url) })));
+                return { ok: true, data: { observedAt: new Date().toISOString(), services, degraded: services.some((service) => !service.ok) } };
+            }),
+            getDownloadQueue: acceptanceRead("sanctuary_get_download_queue", sab.readQueue),
+            resumeDownloadQueue: async () => {
+                try {
+                    const result = await sab.resumeQueue();
+                    collectToolResult(result);
+                    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.sanctuary_download_resume_receipt", message: "Sanctuary download queue resume completed", meta: { changed: result.changed, verified: result.verified, receiptDigest: result.receiptDigest } });
+                    return { ok: true, data: result };
+                }
+                catch (error) {
+                    (0, runtime_1.emitNervesEvent)({ level: "error", component: "senses", event: "senses.sanctuary_download_resume_error", message: "Sanctuary download queue resume failed", meta: { category: error instanceof Error ? error.name : "unknown" } });
+                    throw error;
+                }
+            },
+            restartContainer: async (args, execution) => {
+                const result = execution ? await restart(args, execution) : await restart(args);
                 collectToolResult(result);
                 return result;
             },
+            recoverRoutineActions: () => (0, steward_policy_1.recoverRoutineActionReceipts)((0, identity_1.getAgentRoot)(agentName), {
+                observeTarget: async (target) => {
+                    const observed = await reads.listContainers();
+                    if (!observed.ok)
+                        throw new Error(observed.error.message);
+                    const matches = observed.data.containers.filter((container) => container.id === target.id && container.name === target.name);
+                    if (matches.length !== 1)
+                        return { ...target, state: "unknown" };
+                    return { id: matches[0].id, name: matches[0].name, state: matches[0].state };
+                },
+            }),
         },
     };
 }

package/dist/senses/sanctuary-sab.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSanctuarySabClient = createSanctuarySabClient;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const runtime_1 = require("../nerves/runtime");
+const DEFAULT_INI_PATH = "/run/sanctuary/sabnzbd.ini";
+const BASE_URL = "http://127.0.0.1:8090/api";
+function apiKey(iniPath) {
+    let contents = "";
+    try {
+        contents = (0, node_fs_1.readFileSync)(iniPath, "utf8");
+    }
+    catch {
+        throw new Error("SAB queue verification credential is unavailable");
+    }
+    const value = contents.match(/^\s*api_key\s*=\s*(\S+)\s*$/mu)?.[1];
+    if (!value)
+        throw new Error("SAB queue verification credential is unavailable");
+    return value;
+}
+function queuedJobs(value) {
+    const parsed = typeof value === "string" && /^\d{1,7}$/u.test(value) ? Number(value) : value;
+    if (!Number.isSafeInteger(parsed) || Number(parsed) < 0 || Number(parsed) > 1_000_000)
+        throw new Error("SAB queue response is malformed");
+    return Number(parsed);
+}
+function createSanctuarySabClient(options = {}) {
+    const iniPath = options.iniPath ?? DEFAULT_INI_PATH;
+    const fetchImpl = options.fetch ?? fetch;
+    let cachedApiKey = null;
+    const request = async (mode) => {
+        cachedApiKey ??= apiKey(iniPath);
+        let response;
+        try {
+            response = await fetchImpl(`${BASE_URL}?mode=${mode}${mode === "queue" ? "&output=json" : ""}&apikey=${encodeURIComponent(cachedApiKey)}`, { signal: AbortSignal.timeout(15_000) });
+        }
+        catch {
+            throw new Error("SAB queue request failed");
+        }
+        if (!response.ok)
+            throw new Error("SAB queue request failed");
+        return response;
+    };
+    const readQueue = async () => {
+        const response = await request("queue");
+        const body = await response.json();
+        if (!body || typeof body !== "object" || Array.isArray(body))
+            throw new Error("SAB queue response is malformed");
+        const queue = body.queue;
+        if (!queue || typeof queue !== "object" || Array.isArray(queue))
+            throw new Error("SAB queue response is malformed");
+        const fields = queue;
+        if (typeof fields.paused !== "boolean" || (fields.status !== undefined && (typeof fields.status !== "string" || Buffer.byteLength(fields.status) > 64)))
+            throw new Error("SAB queue response is malformed");
+        const status = typeof fields.status === "string" ? fields.status : "unknown";
+        const jobs = fields.noofslots === undefined ? 0 : queuedJobs(fields.noofslots);
+        const observedAt = options.now?.() ?? new Date().toISOString();
+        const stateDigest = (0, node_crypto_1.createHash)("sha256").update(JSON.stringify({ paused: fields.paused, status, queuedJobs: jobs })).digest("hex");
+        return { paused: fields.paused, status, queuedJobs: jobs, observedAt, stateDigest };
+    };
+    return {
+        readQueue,
+        async resumeQueue() {
+            const before = await readQueue();
+            if (!before.paused) {
+                const receiptDigest = (0, node_crypto_1.createHash)("sha256").update(`sabnzbd.resume\0${before.stateDigest}\0${before.stateDigest}`).digest("hex");
+                return { changed: false, before, after: before, verified: true, receiptDigest };
+            }
+            const response = await request("resume");
+            await response.body?.cancel().catch(() => undefined);
+            const after = await readQueue();
+            if (after.paused)
+                throw new Error("SAB queue resume could not be verified");
+            const receiptDigest = (0, node_crypto_1.createHash)("sha256").update(`sabnzbd.resume\0${before.stateDigest}\0${after.stateDigest}`).digest("hex");
+            return { changed: true, before, after, verified: true, receiptDigest };
+        },
+    };
+}
+(0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.sanctuary_sab_loaded", message: "typed Sanctuary SAB queue client loaded", meta: { operations: 2 } });