@ouro.bot/cli 0.1.0-alpha.76 → 0.1.0-alpha.761

package/dist/senses/proactive-content-guard.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProactiveInternalContentBlockReason = getProactiveInternalContentBlockReason;
+exports.emitProactiveInternalContentBlocked = emitProactiveInternalContentBlocked;
+const runtime_1 = require("../nerves/runtime");
+// ── Patterns ────────────────────────────────────────────────────
+const PROACTIVE_INTERNAL_CONTENT_PATTERNS = [
+    // PR 447 patterns: raw meta markers
+    { reason: "raw_meta_marker", pattern: /<\s*\/?\s*(think|analysis|commentary)\b[^>]*>/i },
+    { reason: "raw_meta_marker", pattern: /\[\s*surfaced from inner dialog\s*\]/i },
+    // Stale private-runtime vocabulary / attention / obligation references
+    { reason: "legacy_private_runtime_reference", pattern: /\binner (dialog|dialogue)\b/i },
+    { reason: "attention_queue_reference", pattern: /\battention queues?\b/i },
+    { reason: "return_obligation_reference", pattern: /\b(return|held|heart|inner)\s+obligations?\b/i },
+    // Surfacing mechanics
+    { reason: "surfacing_mechanics_reference", pattern: /\b(surface tool|surfacing (mechanics|itself)|surfaced? outward|call `?surface`?|delegationId|delegation id)\b/i },
+    // Prompt references
+    { reason: "prompt_reference", pattern: /\b(system|developer|inner|tool|orientation)\s+prompts?\b|\bprompt\/orientation\b|\bprompt wording\b/i },
+    // Routing references
+    { reason: "routing_reference", pattern: /\b(routing target|reply target|route through surface|routed through surface|proactive bluebubbles delivery)\b/i },
+    // Heartbeat / status patterns
+    { reason: "heartbeat_status", pattern: /\bheartbeat\b/i },
+    { reason: "heartbeat_status", pattern: /\bcheck-in\b/i },
+    { reason: "heartbeat_status", pattern: /\btask board\b/i },
+    { reason: "heartbeat_status", pattern: /\ball else settled\b/i },
+    { reason: "heartbeat_status", pattern: /\bobligations?\s+showing\b/i },
+    { reason: "heartbeat_status", pattern: /\bsame state\b/i },
+];
+// ── Public API ──────────────────────────────────────────────────
+function getProactiveInternalContentBlockReason(text) {
+    for (const { reason, pattern } of PROACTIVE_INTERNAL_CONTENT_PATTERNS) {
+        if (pattern.test(text))
+            return reason;
+    }
+    return null;
+}
+function emitProactiveInternalContentBlocked(params) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "senses",
+        event: "senses.proactive_internal_content_blocked",
+        message: "proactive send blocked: internal content",
+        meta: {
+            friendId: params.friendId,
+            source: params.source,
+            reason: params.reason,
+            ...(params.sessionKey ? { sessionKey: params.sessionKey } : {}),
+            ...(params.intent ? { intent: params.intent } : {}),
+        },
+    });
+}

package/dist/senses/sanctuary-download-credit-presentation.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.presentSanctuaryDownloadCreditReply = presentSanctuaryDownloadCreditReply;
+const runtime_1 = require("../nerves/runtime");
+const TOP_UP_LINK = "https://www.astraweb.com/login";
+const SAFE_FALLBACK = `Downloads are paused to protect your prepaid credit. Top it up here: ${TOP_UP_LINK}. Tell me when you’re done, and I’ll resume downloads and verify one finishes. Or tell me a reminder time, like “tomorrow at 9.”`;
+const FORBIDDEN_INTERNALS = /\b(?:SABnzbd|Sonarr|Radarr|Deluge|auth[ -]?check|credential|dead[ -]?letter|indexer has been disabled|keep watching)\b/iu;
+const EXHAUSTED_CREDIT = /(?:\b(?:prepaid )?credit (?:is |appear(?:s|ed)? |seems? )?(?:exhausted|depleted)\b|\bout of (?:prepaid )?credit\b|\bzero (?:prepaid )?credit\b|\bno (?:prepaid )?credit (?:left|remaining|available)\b)/iu;
+const REQUIRED_HOUSEHOLD_CONTRACT = [
+    /\bdownloads?\b/iu,
+    /\bpaused?\b/iu,
+    /\bprotect\b/iu,
+    /\bprepaid credit\b/iu,
+    /\btell me\b/iu,
+    /\bdone\b/iu,
+    /\bresume\b/iu,
+    /\bverify\b/iu,
+    /\b(?:finish(?:es|ed)?|completed?)\b/iu,
+    /\bremind(?:er)?\b/iu,
+    /\btime\b|\btomorrow at 9\b/iu,
+];
+function presentSanctuaryDownloadCreditReply(agentName, exactQuestion, text) {
+    if (agentName !== "sanctuary" || !exactQuestion || !text.includes(TOP_UP_LINK) || !/\bcredit\b/iu.test(text))
+        return text;
+    if (!FORBIDDEN_INTERNALS.test(text) && REQUIRED_HOUSEHOLD_CONTRACT.every((pattern) => pattern.test(text)))
+        return text;
+    if (!EXHAUSTED_CREDIT.test(text))
+        return text;
+    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.telegram_download_credit_reply_repaired", message: "repaired Sanctuary download-credit reply at the Telegram boundary", meta: { agentName } });
+    return SAFE_FALLBACK;
+}

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanctuaryFullVisibilityRequiredToolCalls = sanctuaryFullVisibilityRequiredToolCalls;
+const runtime_1 = require("../nerves/runtime");
+const REQUIRED_TOOL_NAMES = ["query_active_work", "query_cares", "unraid_get_system", "unraid_list_containers"];
+const WHOLE_STATUS_REQUESTS = new Set(["what are you working on", "what's going on with sanctuary"]);
+function sanctuaryFullVisibilityRequiredToolCalls(request, advertisedToolNames) {
+    const normalized = request.normalize("NFKC").trim().toLocaleLowerCase("en-US").replaceAll("’", "'").replace(/[?!.\s]+$/gu, "");
+    if (!WHOLE_STATUS_REQUESTS.has(normalized) || !REQUIRED_TOOL_NAMES.every((name) => advertisedToolNames.includes(name)))
+        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 } });
+    return {
+        names: REQUIRED_TOOL_NAMES,
+        retryMessage: "Before answering, read current active work, cares, system health, and service state. Then give Ari one compact household summary; do not ask him to choose a status slice.",
+    };
+}

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)());