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

package/dist/senses/sanctuary-full-visibility-contract.js

@@ -0,0 +1,302 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSanctuaryCurrentStatusIntent = isSanctuaryCurrentStatusIntent;
+exports.sanctuaryFullVisibilityEmptyResponse = sanctuaryFullVisibilityEmptyResponse;
+exports.sanctuaryFullVisibilityRequiredToolCalls = sanctuaryFullVisibilityRequiredToolCalls;
+exports.sanctuaryStaleDockerCareRequiredToolCalls = sanctuaryStaleDockerCareRequiredToolCalls;
+const node_crypto_1 = require("node:crypto");
+const cares_1 = require("../arc/cares");
+const runtime_1 = require("../nerves/runtime");
+const REQUIRED_TOOL_NAMES = ["query_active_work", "query_cares", "unraid_get_system", "unraid_list_containers", "unraid_get_storage", "unraid_get_notifications", "sanctuary_get_download_queue"];
+const WHOLE_STATUS_REQUESTS = new Set(["what are you working on", "what's going on with sanctuary"]);
+function unsupportedCurrentClaim(answer, queueUnavailable, authorizedDockerClaims) {
+    if (queueUnavailable && answer.trim().length === 0)
+        return "Give Ari the current results that did complete and say plainly that the download queue is currently unavailable; do not return an empty answer.";
+    if (queueUnavailable) {
+        const unsupportedQueueClaim = answer.split(/[,;!?\n]|(?<!\d)\.(?!\d)/u).some((clause) => {
+            if (!/\b(?:download(?:s| queue)?|queue|SABnzbd)\b/iu.test(clause))
+                return false;
+            const explicitlyUnverified = /\b(?:(?:cannot|can't|could not|couldn't|unable to) (?:currently )?(?:be )?(?:verif(?:y|ied)|read|check(?:ed)?|confirm(?:ed)?)|(?:do not|don't) know(?: whether)?|unknown|unavailable|unverified|stale|historical|previous|prior|failed)\b|\bneeds? (?:a )?(?:fresh |authoritative )*(?:check|read|verification)\b/iu.test(clause);
+            return !explicitlyUnverified;
+        });
+        if (unsupportedQueueClaim)
+            return "The current download-queue read is unavailable. Preserve the other current results, but do not claim a queue state; say plainly that downloads could not be verified.";
+    }
+    const unsupported = answer.replace(/docker\.img/giu, "docker image").split(/[,;!?\n]|(?<!\d)\.(?!\d)/u).some((sentence) => {
+        if (!/docker image(?: disk)?/iu.test(sentence))
+            return false;
+        const normalizedSentence = sentence.normalize("NFKC").trim().toLocaleLowerCase("en-US");
+        if (authorizedDockerClaims.some((claim) => claim.normalize("NFKC").replace(/[.!?]+$/u, "").trim().toLocaleLowerCase("en-US") === normalizedSentence))
+            return false;
+        const uncertaintyOnly = /\b(?:cannot|can't|unable to) (?:currently )?(?:verify|measure)\b|\b(?:unknown|unverified)\b|\bneeds? (?:a )?(?:fresh |authoritative )*(?:check|measurement)\b/iu.test(sentence);
+        const stateClaim = /\b\d+(?:\.\d+)?\s*%|\bfull\b|\b(?:no|out of) space\b|\bwrites? (?:will |may )?fail\b|\b(?:healthy|unhealthy|running|stopped)\b/iu.test(sentence);
+        return stateClaim || !uncertaintyOnly;
+    });
+    if (unsupported)
+        return "No current Butler tool measures Docker image utilization. Do not report a Docker image percentage or full state as current; say that the stale care needs a fresh authoritative check.";
+    const unsupportedProviderClaim = answer.split(/[,;!?\n]|(?<!\d)\.(?!\d)/u).some((clause) => {
+        const explicitlyUnverified = /\b(?:cannot|can't|unable to) (?:currently )?(?:verify|confirm)|\b(?:unknown|unverified|stale|historical|previous|prior)\b|\bneeds? (?:a )?(?:fresh |authoritative )*(?:check|verification)\b/iu.test(clause);
+        if (explicitlyUnverified)
+            return false;
+        if (/\b(?:Astraweb|Usenet provider|download provider|(?:block|prepaid|download|provider) credit)\b/iu.test(clause))
+            return true;
+        return /\bSABnzbd\b/iu.test(clause) && /\b(?:auth(?:entication)?|authenticated|credentials?)\b/iu.test(clause);
+    });
+    return unsupportedProviderClaim ? "The current queue read does not prove provider credit or authentication status. Do not report Astraweb, block-credit, or authentication failure as current; say that the provider needs a fresh authoritative check." : undefined;
+}
+function exactQueueUnavailableResult(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const result = value;
+    if (JSON.stringify(Object.keys(result).sort()) !== JSON.stringify(["error", "observedAt", "ok"]))
+        return false;
+    if (result.ok !== false || typeof result.observedAt !== "string" || !Number.isFinite(Date.parse(result.observedAt)) || new Date(result.observedAt).toISOString() !== result.observedAt)
+        return false;
+    const error = result.error;
+    return !!error && typeof error === "object" && !Array.isArray(error)
+        && JSON.stringify(Object.keys(error).sort()) === JSON.stringify(["code"])
+        && ["credential_unavailable", "request_unavailable", "malformed_response"].includes(String(error.code));
+}
+function successfulCurrentResult(name, result) {
+    if (Buffer.byteLength(result, "utf8") > 1_000_000)
+        return { valid: false, queueUnavailable: false };
+    if (name === "query_active_work")
+        return { valid: result.trimStart().startsWith("this is my current top-level live world-state."), queueUnavailable: false };
+    try {
+        const parsed = JSON.parse(result);
+        if (name === "query_cares")
+            return { valid: Array.isArray(parsed), queueUnavailable: false };
+        if (name === "unraid_get_notifications") {
+            const root = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+            const error = root?.error && typeof root.error === "object" && !Array.isArray(root.error) ? root.error : null;
+            const unavailable = root?.ok === false
+                && JSON.stringify(Object.keys(root).sort()) === JSON.stringify(["error", "ok"])
+                && !!error && JSON.stringify(Object.keys(error).sort()) === JSON.stringify(["code", "degraded", "message"])
+                && ["unauthorized", "forbidden", "timeout", "transport", "graphql", "invalid_response"].includes(String(error.code))
+                && typeof error.message === "string" && Buffer.byteLength(error.message, "utf8") <= 512 && error.degraded === true;
+            if (unavailable)
+                return { valid: true, queueUnavailable: false };
+            const data = root?.data && typeof root.data === "object" && !Array.isArray(root.data) ? root.data : null;
+            return { valid: root?.ok === true && Array.isArray(data?.unacknowledged) && typeof data.truncated === "boolean", queueUnavailable: false };
+        }
+        if (name === "sanctuary_get_download_queue") {
+            if (exactQueueUnavailableResult(parsed))
+                return { valid: true, queueUnavailable: true };
+            if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+                return { valid: false, queueUnavailable: false };
+            const queue = parsed;
+            const exactKeys = ["observedAt", "paused", "queuedJobs", "stateDigest", "status"];
+            return { valid: JSON.stringify(Object.keys(queue).sort()) === JSON.stringify(exactKeys)
+                    && typeof queue.paused === "boolean"
+                    && typeof queue.status === "string" && Buffer.byteLength(queue.status, "utf8") <= 64
+                    && Number.isSafeInteger(queue.queuedJobs) && Number(queue.queuedJobs) >= 0 && Number(queue.queuedJobs) <= 1_000_000
+                    && typeof queue.observedAt === "string" && Number.isFinite(Date.parse(queue.observedAt)) && new Date(queue.observedAt).toISOString() === queue.observedAt
+                    && typeof queue.stateDigest === "string" && /^[a-f0-9]{64}$/u.test(queue.stateDigest), queueUnavailable: false };
+        }
+        return { valid: !!parsed && typeof parsed === "object" && !Array.isArray(parsed) && parsed.ok === true, queueUnavailable: false };
+    }
+    catch {
+        return { valid: false, queueUnavailable: false };
+    }
+}
+function normalizedRequest(request) {
+    return request.normalize("NFKC").trim().toLocaleLowerCase("en-US").replace(/[‘’]/gu, "'").replace(/[^a-z0-9']+/gu, " ").trim();
+}
+function isSanctuaryCurrentStatusIntent(request) {
+    const normalized = normalizedRequest(request);
+    if (WHOLE_STATUS_REQUESTS.has(normalized))
+        return true;
+    if (["what's up", "everything good", "anything wrong"].includes(normalized))
+        return true;
+    if (!normalized || /\b(?:yesterday|tomorrow|document|movie request)\b/u.test(normalized))
+        return false;
+    if (/^do you care about\b/u.test(normalized) || /\b(?:plex|jellyfin|sonarr|radarr|docker labels?)\b/u.test(normalized))
+        return false;
+    const wholeScope = /\b(?:anything|everything|what(?:'s| is)|things?)\b/u.test(normalized);
+    const current = /\b(?:now|right now|currently|going on|status)\b/u.test(normalized);
+    const concern = /\b(?:care about|should (?:i|we) know about|working on|going on|status)\b/u.test(normalized);
+    return wholeScope && current && concern;
+}
+function sanctuaryFullVisibilityEmptyResponse(request) {
+    return isSanctuaryCurrentStatusIntent(request)
+        ? "I couldn't finish a trustworthy Sanctuary status check because a current check was unavailable. I won't guess or reuse old alerts; please try again shortly."
+        : undefined;
+}
+function sanctuaryFullVisibilityRequiredToolCalls(request, _advertisedToolNames, authorizedDockerClaims = () => []) {
+    if (!isSanctuaryCurrentStatusIntent(request))
+        return undefined;
+    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.sanctuary_full_visibility_reads_required", message: "required current Sanctuary visibility reads", meta: { toolCount: REQUIRED_TOOL_NAMES.length } });
+    let queueUnavailable = false;
+    const completed = new Set();
+    return {
+        names: REQUIRED_TOOL_NAMES,
+        retryMessage: "Before answering, read current active work, cares, system health, service state, storage, notifications, and the download queue. Current tool facts outrank care history; a stale care is a recheck item, not a present-tense fact. Then give Ari one compact household summary; do not ask him to choose a status slice.",
+        requireSuccessfulResults: true,
+        validateRequiredToolResult: (name, result) => {
+            const validation = successfulCurrentResult(name, result);
+            if (name === "sanctuary_get_download_queue" && validation.valid)
+                queueUnavailable = validation.queueUnavailable;
+            if (validation.valid)
+                completed.add(name);
+            return validation.valid;
+        },
+        validateTerminalAnswer: (answer) => unsupportedCurrentClaim(answer, queueUnavailable, authorizedDockerClaims()),
+        emptyResponseFallback: () => REQUIRED_TOOL_NAMES.every((name) => completed.has(name)) ? sanctuaryFullVisibilityEmptyResponse(request) : undefined,
+    };
+}
+const SAFE_LABEL = "Docker image disk utilization";
+const INCONCLUSIVE_RISK = "Docker image disk utilization verification is inconclusive.";
+const ACTIVE_RISK = "A fresh Unraid notification reports high Docker image disk utilization.";
+function qualifyingDockerCare(care, now) {
+    if ((0, cares_1.projectCareEvidence)(care, now) === care)
+        return undefined;
+    const binding = care.incidentBindings?.find(cares_1.isManagedDockerCareIncidentBinding);
+    return binding ? {
+        id: care.id, updatedAt: care.updatedAt, currentRisk: care.currentRisk, nextCheckAt: care.nextCheckAt, salience: care.salience, steward: care.steward, binding: { ...binding },
+        hasOtherUnresolvedBindings: care.incidentBindings.some((candidate) => candidate !== binding && !candidate.resolvedAt),
+    } : undefined;
+}
+function canonicalNotification(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const notification = value;
+    return typeof notification.id === "string"
+        && typeof notification.createdAt === "string"
+        && Number.isFinite(Date.parse(notification.createdAt))
+        && new Date(notification.createdAt).toISOString() === notification.createdAt
+        && typeof notification.title === "string"
+        && typeof notification.summary === "string"
+        && typeof notification.severity === "string"
+        && typeof notification.degraded === "boolean"
+        ? notification
+        : undefined;
+}
+function notificationRevision(notification) {
+    return (0, node_crypto_1.createHash)("sha256").update(JSON.stringify({
+        id: notification.id,
+        createdAt: notification.createdAt,
+        severity: notification.severity,
+        title: notification.title,
+        summary: notification.summary,
+        degraded: notification.degraded,
+    })).digest("hex");
+}
+function dockerObservation(result, care) {
+    try {
+        const parsed = JSON.parse(result);
+        const data = parsed?.ok === true && parsed.data && typeof parsed.data === "object" && !Array.isArray(parsed.data) ? parsed.data : undefined;
+        if (!data || data.truncated !== false || !Array.isArray(data.unacknowledged))
+            return { outcome: "inconclusive" };
+        const boundary = Math.max(Date.parse(care.updatedAt), Date.parse(care.nextCheckAt));
+        const related = data.unacknowledged.map(canonicalNotification).filter((item) => !!item).filter((item) => {
+            const text = `${item.title} ${item.summary}`;
+            return item.degraded === false && Date.parse(String(item.createdAt)) > boundary && /docker/iu.test(text) && /image/iu.test(text) && /(?:disk|utilization)/iu.test(text);
+        });
+        if (related.length !== 1)
+            return { outcome: "inconclusive" };
+        const notification = related[0];
+        const text = `${notification.title} ${notification.summary}`;
+        const revision = notificationRevision(notification);
+        if (/\b(?:recover(?:ed|y)?|resolved|normal|healthy|cleared)\b/iu.test(text))
+            return { outcome: "fresh_recovered", revision };
+        if (/\b(?:critical|warning|error|full|high|9[0-9]%|100%)\b/iu.test(`${notification.severity} ${text}`)) {
+            return { outcome: "fresh_active", revision, risk: ACTIVE_RISK };
+        }
+        return { outcome: "inconclusive" };
+    }
+    catch {
+        return { outcome: "inconclusive" };
+    }
+}
+function mutationFor(care, observation, now) {
+    const common = {
+        id: care.id,
+        source: care.binding.source,
+        incidentKey: care.binding.incidentKey,
+        expectedUpdatedAt: care.updatedAt,
+        label: SAFE_LABEL,
+        why: observation.outcome === "inconclusive" ? "Current Unraid notification evidence was inconclusive." : "Current Unraid notification evidence was checked.",
+    };
+    if (observation.outcome === "fresh_recovered") {
+        const unresolvedContextRemains = care.hasOtherUnresolvedBindings;
+        return {
+            ...common,
+            action: "resolve_incident",
+            currentRisk: unresolvedContextRemains ? cares_1.CARE_INCIDENT_RECOVERY_REVIEW_RISK : "",
+            nextCheckAt: unresolvedContextRemains ? new Date(now + 15 * 60_000).toISOString() : "",
+        };
+    }
+    return {
+        ...common,
+        action: "upsert_incident",
+        kind: "system",
+        status: observation.outcome === "fresh_active" ? "active" : "watching",
+        salience: care.salience,
+        stewardship: care.steward,
+        classifiedRevision: observation.outcome === "fresh_active" ? observation.revision : care.binding.classifiedRevision,
+        currentRisk: observation.outcome === "fresh_active" ? observation.risk : INCONCLUSIVE_RISK,
+        nextCheckAt: new Date(now + 15 * 60_000).toISOString(),
+    };
+}
+function exactMutation(expected, actual) {
+    return Object.keys(expected).length === Object.keys(actual).length
+        && Object.entries(expected).every(([key, value]) => actual[key] === value);
+}
+function sanctuaryStaleDockerCareRequiredToolCalls(activeCares, now, _advertisedToolNames) {
+    const cares = activeCares.map((care) => qualifyingDockerCare(care, now)).filter((care) => !!care);
+    if (cares.length === 0)
+        return undefined;
+    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.sanctuary_stale_docker_care_verification_required", message: "stale Docker Care requires current notification verification", meta: { careCount: cares.length } });
+    let verifierComplete = false;
+    let mutations = [];
+    const completed = new Set();
+    return {
+        names: ["unraid_get_notifications"],
+        get retryMessage() {
+            return mutations.length === 0
+                ? "Recheck the stale Docker image disk Care from current notifications, then apply every exact evidence-bounded Care update before answering."
+                : `Apply these exact evidence-bounded care_manage arguments before answering: ${JSON.stringify(mutations)}.`;
+        },
+        requireSuccessfulResults: true,
+        validateRequiredToolResult: (name, result, args) => {
+            if (name === "unraid_get_notifications")
+                return Buffer.byteLength(result, "utf8") <= 1_000_000;
+            if (name !== "care_manage")
+                return false;
+            const expected = mutations.find((candidate) => exactMutation(candidate, args));
+            if (!expected)
+                return false;
+            try {
+                const care = JSON.parse(result);
+                const binding = care.incidentBindings?.find((candidate) => candidate.source === expected.source && candidate.incidentKey === expected.incidentKey);
+                const resolved = expected.action === "resolve_incident" ? !!binding?.resolvedAt : binding?.classifiedRevision === expected.classifiedRevision;
+                const updatedUnderCas = typeof care.updatedAt === "string" && Date.parse(care.updatedAt) > Date.parse(expected.expectedUpdatedAt);
+                const wholeCareResolutionValid = expected.action !== "resolve_incident" || expected.currentRisk !== "" || care.incidentBindings?.some((candidate) => !candidate.resolvedAt) || care.status === "resolved";
+                if (care.id !== expected.id || care.label !== SAFE_LABEL || care.why !== expected.why || care.currentRisk !== (expected.currentRisk || null) || care.nextCheckAt !== (expected.nextCheckAt || null) || (expected.status && care.status !== expected.status) || !resolved || !updatedUnderCas || !wholeCareResolutionValid)
+                    return false;
+                completed.add(care.id);
+                return completed.size === mutations.length;
+            }
+            catch {
+                return false;
+            }
+        },
+        validateToolCallBeforeDispatch: (name, args) => {
+            if (name !== "care_manage")
+                return undefined;
+            if (!verifierComplete)
+                return "Read current Unraid notifications before mutating stale Docker Care.";
+            return mutations.some((candidate) => exactMutation(candidate, args)) ? undefined : `Only these exact evidence-bounded stale Docker Care mutations are authorized in this turn: ${JSON.stringify(mutations)}.`;
+        },
+        requiredToolCallsAfterResult: (name, _args, result) => {
+            if (name !== "unraid_get_notifications")
+                return [];
+            mutations = cares.map((care) => mutationFor(care, dockerObservation(result, care), now));
+            verifierComplete = true;
+            (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.sanctuary_stale_docker_care_verification_completed", message: "current notification verification produced bounded Care outcomes", meta: { careCount: cares.length, mutationCount: mutations.length } });
+            return ["care_manage"];
+        },
+        expectedMutations: () => mutations.map((mutation) => ({ ...mutation })),
+        currentRiskClaims: () => mutations.filter((mutation) => mutation.currentRisk === ACTIVE_RISK).map((mutation) => mutation.currentRisk),
+    };
+}

package/dist/senses/sanctuary-grounding.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanctuaryGroundingDigest = sanctuaryGroundingDigest;
+exports.projectSanctuaryGrounding = projectSanctuaryGrounding;
+exports.renderSanctuaryGroundedResponse = renderSanctuaryGroundedResponse;
+exports.sanctuaryGroundedResponseAccurate = sanctuaryGroundedResponseAccurate;
+const node_crypto_1 = require("node:crypto");
+const runtime_1 = require("../nerves/runtime");
+function object(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error(`${label} must be an object`);
+    return value;
+}
+function sanctuaryGroundingDigest(facts) {
+    return (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(facts)).digest("hex");
+}
+function projectSanctuaryGrounding(toolName, result) {
+    if (toolName !== "unraid_get_system" && toolName !== "unraid_get_storage")
+        return null;
+    const envelope = object(result, "Sanctuary grounding result");
+    if (envelope.ok !== true)
+        throw new Error("Sanctuary grounding result must succeed");
+    const data = object(envelope.data, "Sanctuary grounding data");
+    if (toolName === "unraid_get_system") {
+        const exact = ["apiVersion", "arrayState", "degraded", "serverName", "sourceIdentityDigest", "unraidVersion", "uptimeSeconds"];
+        if (JSON.stringify(Object.keys(data).sort()) !== JSON.stringify(exact))
+            throw new Error("Sanctuary system grounding shape is invalid");
+        for (const key of ["serverName", "unraidVersion", "apiVersion", "arrayState"])
+            if (typeof data[key] !== "string" || !data[key])
+                throw new Error("Sanctuary system grounding value is invalid");
+        if (typeof data.degraded !== "boolean" || (data.uptimeSeconds !== null && (!Number.isSafeInteger(data.uptimeSeconds) || Number(data.uptimeSeconds) < 0)))
+            throw new Error("Sanctuary system grounding value is invalid");
+        const facts = { serverName: data.serverName, unraidVersion: data.unraidVersion, apiVersion: data.apiVersion, arrayState: data.arrayState, degraded: data.degraded };
+        (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.sanctuary_grounding_projected", message: "Sanctuary grounding facts projected", meta: { toolName } });
+        return facts;
+    }
+    const exact = ["array", "shares", "sourceIdentityDigest", "truncated"];
+    if (JSON.stringify(Object.keys(data).sort()) !== JSON.stringify(exact) || !Array.isArray(data.shares) || typeof data.truncated !== "boolean")
+        throw new Error("Sanctuary storage grounding shape is invalid");
+    const array = object(data.array, "Sanctuary storage array grounding");
+    if (JSON.stringify(Object.keys(array).sort()) !== JSON.stringify(["degraded", "freeBytes", "state", "usedBytes", "usedPercent"]))
+        throw new Error("Sanctuary storage array grounding shape is invalid");
+    if (typeof array.state !== "string" || !array.state || typeof array.degraded !== "boolean"
+        || ![array.usedBytes, array.freeBytes].every((value) => value === null || (Number.isSafeInteger(value) && Number(value) >= 0))
+        || (array.usedPercent !== null && (typeof array.usedPercent !== "number" || !Number.isFinite(array.usedPercent))))
+        throw new Error("Sanctuary storage array grounding value is invalid");
+    const { sourceIdentityDigest: _sourceIdentityDigest, ...facts } = data;
+    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.sanctuary_grounding_projected", message: "Sanctuary grounding facts projected", meta: { toolName } });
+    return structuredClone(facts);
+}
+function normalized(value) {
+    return value.normalize("NFKC").toLocaleLowerCase("en-US");
+}
+function regexEscape(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function systemResponseAccurate(facts, response) {
+    if (typeof facts.serverName !== "string" || typeof facts.unraidVersion !== "string" || typeof facts.arrayState !== "string" || typeof facts.degraded !== "boolean")
+        return false;
+    const pattern = new RegExp(`^${regexEscape(normalized(facts.serverName))} is running unraid ${regexEscape(normalized(facts.unraidVersion))}(?:; the array is| with the array) ${regexEscape(normalized(facts.arrayState))} and (not degraded|healthy|nominal|degraded|unhealthy)\\.?$`, "u");
+    const match = pattern.exec(response);
+    if (!match)
+        return false;
+    return facts.degraded ? match[1] === "degraded" || match[1] === "unhealthy" : match[1] === "not degraded" || match[1] === "healthy" || match[1] === "nominal";
+}
+function byteAmount(amount, unit) {
+    const divisors = { tb: 1_000_000_000_000, tib: 1_099_511_627_776, gb: 1_000_000_000, gib: 1_073_741_824, byte: 1, bytes: 1 };
+    return Number(amount) * divisors[unit];
+}
+function storageResponseAccurate(facts, response) {
+    const array = object(facts.array, "Sanctuary response storage facts");
+    if (typeof array.freeBytes !== "number" || typeof array.usedPercent !== "number" || typeof array.state !== "string" || typeof array.degraded !== "boolean")
+        return false;
+    const pattern = /^(?:there is|about) (\d+(?:\.\d+)?)\s*(tb|tib|gb|gib|bytes?) (?:is )?(?:available|free|left)(?:;|,| and) (?:(?:the array is )(\d+(?:\.\d+)?)\s*%\s*(?:used|full)|(?:usage is )(\d+(?:\.\d+)?)\s*%)\.(?: the array is ([\p{L}\p{N}_-]+) and (not degraded|healthy|nominal|degraded|unhealthy)\.)?$/u;
+    const match = pattern.exec(response);
+    if (!match)
+        return false;
+    const bytesAccurate = Math.abs(byteAmount(match[1], match[2]) - array.freeBytes) <= Math.max(1, array.freeBytes * 0.025);
+    const percentAccurate = Math.abs(Number(match[3] ?? match[4]) - array.usedPercent) <= 0.51;
+    if (!bytesAccurate || !percentAccurate)
+        return false;
+    if (match[5] === undefined && match[6] === undefined)
+        return true;
+    const healthAccurate = array.degraded ? match[6] === "degraded" || match[6] === "unhealthy" : match[6] === "not degraded" || match[6] === "healthy" || match[6] === "nominal";
+    return normalized(String(match[5])) === normalized(array.state) && healthAccurate;
+}
+function compactNumber(value) {
+    return value.toFixed(2).replace(/\.0+$/u, "").replace(/(\.\d*?)0+$/u, "$1");
+}
+function renderSanctuaryGroundedResponse(toolName, facts) {
+    let response;
+    if (toolName === "unraid_get_system") {
+        if (typeof facts.serverName !== "string" || typeof facts.unraidVersion !== "string" || typeof facts.arrayState !== "string" || typeof facts.degraded !== "boolean")
+            throw new Error("Sanctuary system response facts are invalid");
+        response = `${facts.serverName} is running Unraid ${facts.unraidVersion} with the array ${facts.arrayState} and ${facts.degraded ? "degraded" : "not degraded"}.`;
+    }
+    else {
+        const array = object(facts.array, "Sanctuary storage response facts");
+        if (typeof array.freeBytes !== "number" || typeof array.usedPercent !== "number")
+            throw new Error("Sanctuary storage response facts are invalid");
+        const units = [[1_000_000_000_000, "TB"], [1_000_000_000, "GB"], [1, "bytes"]];
+        const freeBytes = Number(array.freeBytes);
+        const usedPercent = Number(array.usedPercent);
+        const [divisor, unit] = units.find(([candidate]) => freeBytes >= candidate) ?? units[units.length - 1];
+        response = `There is ${compactNumber(freeBytes / divisor)} ${unit} free and the array is ${compactNumber(usedPercent)}% used.`;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.sanctuary_grounded_response_rendered",
+        message: "Rendered a deterministic Sanctuary response from grounded facts",
+        meta: { toolName },
+    });
+    return response;
+}
+function sanctuaryGroundedResponseAccurate(toolName, facts, responseText) {
+    const response = normalized(responseText);
+    return toolName === "unraid_get_system" ? systemResponseAccurate(facts, response) : storageResponseAccurate(facts, response);
+}

package/dist/senses/sanctuary-health-acceptance-probe-entry.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sanctuary_health_acceptance_probe_1 = require("./sanctuary-health-acceptance-probe");
+const runtime_1 = require("../nerves/runtime");
+(0, runtime_1.emitNervesEvent)({
+    component: "senses",
+    event: "senses.entry_boot",
+    message: "booting Sanctuary health acceptance probe entrypoint",
+    meta: { entry: "sanctuary-health-acceptance-probe" },
+});
+(0, sanctuary_health_acceptance_probe_1.startSanctuaryHealthAcceptanceProbeCli)(process.argv.slice(2), (0, sanctuary_health_acceptance_probe_1.createSanctuaryHealthAcceptanceProbeCliOutput)());