@ouro.bot/cli 0.1.0-alpha.81 → 0.1.0-alpha.810

package/dist/senses/sanctuary-interactive-control.js

@@ -0,0 +1,306 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proveSanctuaryAttemptedRecoveryWithoutRetry = proveSanctuaryAttemptedRecoveryWithoutRetry;
+exports.executeSanctuaryInteractiveEngine = executeSanctuaryInteractiveEngine;
+exports.createSanctuaryInteractiveControl = createSanctuaryInteractiveControl;
+exports.sanctuaryInteractiveControlReady = sanctuaryInteractiveControlReady;
+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 approval_store_1 = require("../heart/approval-store");
+const tool_approval_1 = require("../heart/tool-approval");
+const runtime_1 = require("../nerves/runtime");
+const telegram_client_1 = require("./telegram-client");
+const SHA256 = /^[0-9a-f]{64}$/u;
+const MAX_CONTROL_REQUEST = 16 * 1024;
+function object(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error(`${label} must be an object`);
+    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 exactApproval(projections) {
+    const matches = projections.filter(({ approval }) => approval.toolName === "unraid_restart_container" && approval.arguments.container === "calibre-web");
+    if (matches.length !== 1)
+        throw new Error("interactive production approval is absent or ambiguous");
+    return matches[0];
+}
+function exactPending(records, approvalId) {
+    const validCallback = (value) => typeof value === "string" && Buffer.byteLength(value) >= 1 && Buffer.byteLength(value) <= 64;
+    const matches = records.filter((record) => record.approvalId === approvalId && record.deliveryState === "bound" && record.messageId !== null
+        && validCallback(record.approveCallbackData) && validCallback(record.denyCallbackData));
+    if (matches.length !== 1)
+        throw new Error("interactive production pending approval is absent or ambiguous");
+    return matches[0];
+}
+function exactTerminalTombstone(records, approvalId) {
+    const validCallback = (value) => typeof value === "string" && Buffer.byteLength(value) >= 1 && Buffer.byteLength(value) <= 64;
+    const matches = records.filter((record) => record.approvalId === approvalId && record.deliveryState === "terminal_tombstone" && record.messageId !== null
+        && validCallback(record.approveCallbackData) && validCallback(record.denyCallbackData)
+        && record.expiryObservation?.schemaVersion === "telegram-approval-expiry-observation-v1"
+        && record.expiryObservation.deadlineAt === record.expiresAt && Number.isSafeInteger(record.expiryObservation.observedAt)
+        && record.expiryObservation.observedAt >= record.expiresAt && typeof record.expiryObservation.evidenceMac === "string" && SHA256.test(record.expiryObservation.evidenceMac)
+        && Number.isSafeInteger(record.terminalizedAt) && Number(record.terminalizedAt) >= record.expiryObservation.observedAt);
+    if (matches.length !== 1)
+        throw new Error("interactive production terminal tombstone is absent or ambiguous");
+    return matches[0];
+}
+function pendingDigest(record) {
+    return sha256(JSON.stringify({ approvalId: record.approvalId, messageId: record.messageId, deliveryState: record.deliveryState, approveCallbackData: record.approveCallbackData, denyCallbackData: record.denyCallbackData, expiresAt: record.expiresAt }));
+}
+function proveSanctuaryAttemptedRecoveryWithoutRetry(agentRoot, scenarioHandleDigest, approval) {
+    if (!SHA256.test(scenarioHandleDigest))
+        throw new Error("attempted recovery scenario is invalid");
+    const databaseRoot = path.join(agentRoot, "state", "acceptance", "attempted-recovery-probes");
+    (0, node_fs_1.mkdirSync)(databaseRoot, { recursive: true, mode: 0o700 });
+    const databasePath = path.join(databaseRoot, `${scenarioHandleDigest}.sqlite`);
+    if ((0, node_fs_1.existsSync)(databasePath))
+        throw new Error("attempted recovery proof requires inspect-before-retry");
+    const instant = new Date("2026-08-21T00:00:00.000Z");
+    const first = (0, approval_store_1.openApprovalStore)({ databasePath, now: () => instant });
+    const ownerId = "acceptance-attempted-recovery";
+    const toolCallId = `acceptance-${approval.toolCallId}`;
+    const frozenAssistantMessage = structuredClone(approval.frozenAssistantMessage);
+    const toolCalls = frozenAssistantMessage.tool_calls;
+    if (!Array.isArray(toolCalls) || toolCalls.length !== 1 || !toolCalls[0] || typeof toolCalls[0] !== "object" || Array.isArray(toolCalls[0])) {
+        first.close();
+        throw new Error("attempted recovery frozen tool call is invalid");
+    }
+    toolCalls[0].id = toolCallId;
+    const prepared = first.prepare({
+        toolCallId, toolName: approval.toolName, arguments: approval.arguments,
+        schemaDigest: approval.schemaDigest, toolDigest: approval.toolDigest, policyDigest: approval.policyDigest, policyId: approval.policyId,
+        sessionKey: "acceptance:attempted-recovery", sessionPath: path.join(databaseRoot, `${scenarioHandleDigest}.session.json`),
+        baseSessionRevision: approval.baseSessionRevision, checkpointDigest: approval.checkpointDigest,
+        requesterId: "acceptance-probe", transport: "telegram", transportUserId: "acceptance-probe", transportChatId: "acceptance-probe",
+        expiresAt: "2099-01-01T00:00:00.000Z", frozenAssistantMessage,
+    });
+    first.activate({ approvalId: prepared.record.approvalId, checkpointDigest: prepared.record.checkpointDigest, suspendedSessionRevision: approval.suspendedSessionRevision });
+    first.bindPrompt({ approvalId: prepared.record.approvalId, transport: "telegram", transportChatId: "acceptance-probe", transportMessageId: "acceptance-message" });
+    const claimed = first.decide({
+        approvalId: prepared.record.approvalId, decisionToken: prepared.decisionToken, decision: "approve", requesterId: "acceptance-probe",
+        transport: "telegram", transportUserId: "acceptance-probe", transportChatId: "acceptance-probe", transportMessageId: "acceptance-message",
+        sessionKey: "acceptance:attempted-recovery", ownerId,
+    });
+    const attempted = first.markAttempted({ approvalId: claimed.approvalId, ownerId, epoch: claimed.epoch });
+    first.close();
+    const attemptedRecordDigest = sha256(JSON.stringify(attempted));
+    const reopened = (0, approval_store_1.openApprovalStore)({ databasePath, now: () => instant });
+    const durableAttempted = reopened.read(attempted.approvalId);
+    if (!durableAttempted || durableAttempted.state !== "attempted") {
+        reopened.close();
+        throw new Error("attempted recovery record was not durable across reopen");
+    }
+    const recovered = (0, tool_approval_1.recoverAttemptedApproval)({ approvalStore: reopened, approvalId: durableAttempted.approvalId });
+    let retryCount = 0;
+    try {
+        (0, tool_approval_1.recoverAttemptedApproval)({ approvalStore: reopened, approvalId: durableAttempted.approvalId });
+        retryCount += 1;
+    }
+    catch { /* expected */ }
+    reopened.close();
+    return { observed: recovered.state === "attempted_indeterminate", retryCount, reopened: true, attemptedRecordDigest, recoveredRecordDigest: sha256(JSON.stringify(recovered)) };
+}
+async function executeSanctuaryInteractiveEngine(raw, deps) {
+    const payload = object(raw, "interactive runtime payload");
+    exactKeys(payload, ["operation", "label", "scenarioHandleDigest"], "interactive runtime payload");
+    const operation = payload.operation;
+    const label = payload.label;
+    const scenarioHandleDigest = payload.scenarioHandleDigest;
+    if (typeof scenarioHandleDigest !== "string" || !SHA256.test(scenarioHandleDigest)
+        || !["unit-16k-timeout-stale", "unit-16l-duplicate-callback", "unit-16m-restart-continuation"].includes(label)
+        || !["drive_timeout_stale", "drive_duplicate_callbacks", "prepare_restart_continuation", "reconcile_restart_continuation"].includes(String(operation))
+        || (operation === "drive_timeout_stale") !== (label === "unit-16k-timeout-stale")
+        || (operation === "drive_duplicate_callbacks") !== (label === "unit-16l-duplicate-callback"))
+        throw new Error("interactive runtime operation binding is invalid");
+    const before = exactApproval(deps.readApprovals(scenarioHandleDigest));
+    if (!before.approval.suspendedSessionRevision)
+        throw new Error("interactive production approval checkpoint is unavailable");
+    if (operation === "drive_timeout_stale") {
+        if (before.approval.state === "proposed") {
+            exactPending(deps.readPending(), before.approval.approvalId);
+            return { state: "waiting" };
+        }
+        if (before.approval.state !== "expired" || before.approval.epoch !== 0)
+            throw new Error("timeout stale approval is not expired without a claim");
+        const captured = exactTerminalTombstone(deps.readPending(), before.approval.approvalId);
+        const session = await deps.createSession();
+        try {
+            const queryId = (0, node_crypto_1.randomBytes)(18).toString("base64url");
+            const result = await session.handle({ callbackData: captured.approveCallbackData, queryId, messageId: captured.messageId });
+            const after = exactApproval(deps.readApprovals(scenarioHandleDigest));
+            const promptTerminal = !session.pendingApprovalIds().includes(before.approval.approvalId);
+            if (!result.handled || result.accepted || result.reason !== "stale_callback" || after.approval.state !== "expired" || after.approval.epoch !== 0 || !promptTerminal) {
+                throw new Error("timeout stale callback proof failed");
+            }
+            return {
+                schemaVersion: "sanctuary-timeout-stale-driver-receipt-v1", phase: "complete", label, scenarioHandleDigest,
+                approvalIdDigest: sha256(before.approval.approvalId), checkpointDigest: before.approval.checkpointDigest,
+                suspendedSessionRevisionDigest: sha256(before.approval.suspendedSessionRevision), approvalEpochBefore: before.approval.epoch,
+                callbackAttempts: 1, distinctQueryCount: 1, callbackDataDigest: sha256(captured.approveCallbackData),
+                settledCount: 1, claimCount: 0, mutationCount: 0, staleAcknowledged: true, promptTerminal,
+            };
+        }
+        finally {
+            session.close();
+        }
+    }
+    if (before.approval.state !== "proposed")
+        throw new Error("interactive production approval is not currently proposed");
+    const pending = exactPending(deps.readPending(), before.approval.approvalId);
+    const common = { approvalIdDigest: sha256(before.approval.approvalId), checkpointDigest: before.approval.checkpointDigest, suspendedSessionRevisionDigest: sha256(before.approval.suspendedSessionRevision), approvalEpochBefore: before.approval.epoch };
+    if (operation === "prepare_restart_continuation") {
+        const recovery = deps.proveIndeterminateRecovery(before.approval, scenarioHandleDigest);
+        if (!recovery.observed || recovery.retryCount !== 0 || !recovery.reopened
+            || !SHA256.test(recovery.attemptedRecordDigest) || !SHA256.test(recovery.recoveredRecordDigest)
+            || recovery.attemptedRecordDigest === recovery.recoveredRecordDigest)
+            throw new Error("isolated attempted recovery proof failed");
+        return {
+            schemaVersion: "sanctuary-interactive-driver-receipt-v2", phase: "prepared", label, scenarioHandleDigest, ...common,
+            pendingDigestBefore: pendingDigest(pending), indeterminateRecoveryObserved: true,
+            attemptedRecoveryReopened: true, attemptedRecordDigest: recovery.attemptedRecordDigest, recoveredRecordDigest: recovery.recoveredRecordDigest,
+        };
+    }
+    const session = await deps.createSession();
+    try {
+        if (operation === "drive_duplicate_callbacks") {
+            const queryIds = [(0, node_crypto_1.randomBytes)(18).toString("base64url"), (0, node_crypto_1.randomBytes)(18).toString("base64url")];
+            let arrivals = 0;
+            let release;
+            const barrier = new Promise((resolve) => { release = resolve; });
+            const invoke = async (queryId) => { arrivals += 1; if (arrivals === 2)
+                release(); await barrier; return session.handle({ callbackData: pending.approveCallbackData, queryId, messageId: pending.messageId }); };
+            const results = await Promise.all(queryIds.map(invoke));
+            const after = exactApproval(deps.readApprovals(scenarioHandleDigest));
+            const stale = await session.handle({ callbackData: pending.approveCallbackData, queryId: (0, node_crypto_1.randomBytes)(18).toString("base64url"), messageId: pending.messageId });
+            return { schemaVersion: "sanctuary-interactive-driver-receipt-v2", phase: "complete", label, scenarioHandleDigest, ...common, callbackAttempts: 2, distinctQueryCount: new Set(queryIds).size, callbackDataDigest: sha256(pending.approveCallbackData), barrierObserved: arrivals === 2, settledCount: results.filter(({ handled }) => handled).length, claimCount: after.approval.epoch === before.approval.epoch + 1 ? 1 : 0, mutationCount: after.approval.state === "succeeded" ? 1 : 0, staleReplayAttempts: 1, staleReplaySettled: stale.handled, staleReplayMutationCount: 0, promptTerminal: !session.pendingApprovalIds().includes(before.approval.approvalId), writeCredentialObserved: deps.writeCredentialObserved() };
+        }
+        const result = await session.handle({ callbackData: pending.approveCallbackData, queryId: (0, node_crypto_1.randomBytes)(18).toString("base64url"), messageId: pending.messageId });
+        const after = exactApproval(deps.readApprovals(scenarioHandleDigest));
+        if (!after.continuation || after.approval.state !== "succeeded")
+            throw new Error("restart continuation did not complete");
+        return { approvalEpochAfterRestart: before.approval.epoch, continuationEpochAfter: after.continuation.continuationEpoch, pendingDigestAfter: pendingDigest(pending), pendingRestored: true, callbackAttempts: 1, mutationCount: result.accepted ? 1 : 0, indeterminateRetryCount: 0 };
+    }
+    finally {
+        session.close();
+    }
+}
+function createSanctuaryInteractiveControl(options) {
+    const socketPath = path.join(options.agentRoot, "state", "acceptance", "telegram-control.sock");
+    const runRequest = options.runRequest ?? (async (operation) => operation());
+    let server;
+    let updateId = 2_100_000_000;
+    return {
+        socketPath,
+        async start() {
+            if (server)
+                return;
+            (0, node_fs_1.mkdirSync)(path.dirname(socketPath), { recursive: true, mode: 0o700 });
+            if ((0, node_fs_1.existsSync)(socketPath))
+                (0, node_fs_1.unlinkSync)(socketPath);
+            server = (0, node_net_1.createServer)({ allowHalfOpen: true }, (connection) => {
+                let raw = "";
+                connection.setEncoding("utf8");
+                connection.on("error", () => undefined);
+                connection.on("data", (chunk) => { raw += chunk; if (Buffer.byteLength(raw) > MAX_CONTROL_REQUEST)
+                    connection.destroy(); });
+                connection.on("end", () => {
+                    void runRequest(async () => {
+                        try {
+                            (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.sanctuary_interactive_control_request", message: "Sanctuary interactive control request received", meta: { bytes: Buffer.byteLength(raw) } });
+                            const parsed = object(JSON.parse(raw), "interactive control request");
+                            if (parsed.operation === "interactive_runtime_ready") {
+                                exactKeys(parsed, ["operation", "label", "scenarioHandleDigest"], "interactive readiness request");
+                                if (parsed.label !== "unit-16m-restart-continuation" || typeof parsed.scenarioHandleDigest !== "string" || !SHA256.test(parsed.scenarioHandleDigest))
+                                    throw new Error("interactive readiness binding is invalid");
+                                connection.end(`${JSON.stringify({ ok: true, result: { ready: true } })}\n`);
+                                return;
+                            }
+                            const result = await executeSanctuaryInteractiveEngine(parsed, {
+                                agentRoot: options.agentRoot,
+                                readApprovals: (digest) => (0, approval_store_1.readApprovalsByScenarioHandleDigest)(path.join(options.agentRoot, "state", "approvals", "approvals.sqlite"), digest),
+                                readPending: () => new telegram_client_1.FileTelegramPendingApprovalStore(path.join(options.agentRoot, "state", "approvals", "telegram-pending.json")).load(),
+                                createSession: async () => ({
+                                    handle: ({ callbackData, queryId, messageId }) => runRequest(() => options.transport.handleUpdate({
+                                        update_id: updateId++,
+                                        callback_query: {
+                                            id: queryId,
+                                            from: { id: Number(options.authorizedUserId) },
+                                            data: callbackData,
+                                            message: {
+                                                message_id: Number(messageId),
+                                                chat: { id: Number(options.authorizedChatId) },
+                                            },
+                                        },
+                                    })),
+                                    pendingApprovalIds: () => options.transport.listPendingDeliveries().map(({ approvalId }) => approvalId),
+                                    close: () => undefined,
+                                }),
+                                proveIndeterminateRecovery: (approval, digest) => proveSanctuaryAttemptedRecoveryWithoutRetry(options.agentRoot, digest, approval),
+                                writeCredentialObserved: () => /credential|api[_-]?key|token|secret/iu.test(raw),
+                            });
+                            connection.end(`${JSON.stringify({ ok: true, result })}\n`);
+                        }
+                        catch {
+                            connection.end(`${JSON.stringify({ ok: false, error: "interactive runtime operation failed" })}\n`);
+                        }
+                    }).catch(() => { if (!connection.destroyed)
+                        connection.end(`${JSON.stringify({ ok: false, error: "interactive runtime operation failed" })}\n`); });
+                });
+            });
+            await new Promise((resolve, reject) => { server.once("error", reject); server.listen(socketPath, () => { server.off("error", reject); (0, node_fs_1.chmodSync)(socketPath, 0o600); resolve(); }); });
+        },
+        async stop() { const active = server; server = undefined; if (active)
+            await new Promise((resolve) => active.close(() => resolve())); if ((0, node_fs_1.existsSync)(socketPath))
+            (0, node_fs_1.unlinkSync)(socketPath); },
+    };
+}
+async function sanctuaryInteractiveControlReady(socketPath, timeoutMs = 1_000) {
+    return new Promise((resolve) => {
+        const socket = (0, node_net_1.createConnection)(socketPath);
+        const finish = (ready) => { socket.destroy(); resolve(ready); };
+        socket.setTimeout(timeoutMs, () => finish(false));
+        socket.once("connect", () => finish(true));
+        socket.once("error", () => finish(false));
+    });
+}

package/dist/senses/sanctuary-media-catalog-contract.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanctuaryMediaCatalogRequiredToolCalls = sanctuaryMediaCatalogRequiredToolCalls;
+const runtime_1 = require("../nerves/runtime");
+const sanctuary_media_optimization_1 = require("./sanctuary-media-optimization");
+const REQUIRED_TOOL_NAMES = ["sanctuary_search_media_catalog"];
+const HOUSEHOLD_JARGON = /\b(?:bounded|catalog|inventory|endpoint|backend|data shape|pars(?:e|ed|ing)|json|jellyfin|unmanic|sanctuary_search_media_catalog)\b/iu;
+const NEGATED_MEDIA_ACCESS = /\b(?:not|never|none|nothing|zero|inaccessible|invisible|unavailable|broken|failed|failing)\b|\b(?:isn[’']t|won[’']t)\b|\bno\s+access\b|\b(?:lost|lacks?|lacking|without)\s+access\b|\bonly\s+\d|\bfewer\s+than\b|\bsome\s+of\b|\b(?:part|portion|subset)\s+of\b|\bi\s+(?:can(?:not|[’']t)|do\s+not|don[’']t|have\s+no)\b|\bi[’']m\s+not\b/iu;
+const UNSOLICITED_PIVOT = /\b(?:what would you like|what are you in the mood for|would you like me to|do you want me to|want me to|recommend we add)\b/iu;
+const REPORT_LABEL = /(?:^|\n)\s*(?:version|house|the house|render check|status|result)\s*:/iu;
+const TITLE_LIST_GLUE = new Set(["and", "are", "catalog", "film", "films", "from", "have", "here", "in", "is", "library", "movie", "movies", "on", "shelf", "show", "shows", "the", "these", "titles", "we"]);
+const COUNT_ANSWER_GLUE = new Set(["and", "are", "currently", "episodes", "film", "films", "have", "in", "items", "library", "movie", "movies", "on", "shelf", "show", "shows", "the", "there", "tv", "we"]);
+function requestKind(request, titleQuery) {
+    if (/\b(?:favorite|favourite|recommend|suggest|pick|what (?:movie|film|show) should|should (?:we|i) (?:watch|add)|what to watch|missing from|must (?:watch|add|get))\b/u.test(request))
+        return "taste_recommendation";
+    if (/\b(?:see|visible|visibility|access|accessible|browse|browseable|browsable)\b.*\b(?:jellyfin|library|lib|catalog|shelf)\b|\b(?:jellyfin|library|lib|catalog|shelf)\b.*\b(?:see|visible|visibility|access|accessible|browse|browseable|browsable)\b/u.test(request))
+        return "visibility";
+    if (titleQuery)
+        return "title_lookup";
+    return "other";
+}
+function requestedListCount(request) {
+    const match = request.match(/\b(?:show|list)\s+(?:me\s+)?(one|two|three|four|five|six|seven|eight|nine|ten|[1-9]|1[0-9]|20)\b/u);
+    if (!match)
+        return null;
+    const words = { one: 1, two: 2, three: 3, four: 4, five: 5, six: 6, seven: 7, eight: 8, nine: 9, ten: 10 };
+    return words[match[1]] ?? Number(match[1]);
+}
+function requestedTitle(request) {
+    const conversationalSuffixRemoved = request.replace(/\s+(?:please|(?:right\s+)?now|currently)$/u, "");
+    const haveMatch = conversationalSuffixRemoved.match(/\b(?:do|did|can|could)\s+(?:we|you)\s+(?:have|got|stock)\s+(.+)$/u);
+    if (haveMatch)
+        return haveMatch[1].replace(/^(?:the\s+)?(?:movie|film|show)\s+/u, "").trim();
+    const locationMatch = conversationalSuffixRemoved.match(/\b(?:is|are)\s+(.+?)\s+(?:in|on)\s+(?:(?:the|our)\s+)?(?:jellyfin|library|lib|catalog|shelf)$/u);
+    return locationMatch?.[1]?.replace(/^(?:the\s+)?(?:movie|film|show)\s+/u, "").trim() ?? "";
+}
+function includesNormalizedPhrase(text, phrase) {
+    return ` ${(0, sanctuary_media_optimization_1.normalizeSanctuaryMediaText)(text)} `.includes(` ${(0, sanctuary_media_optimization_1.normalizeSanctuaryMediaText)(phrase)} `);
+}
+function catalogTitleGroundingRejection(answer, current, expectedCount) {
+    let remainder = ` ${(0, sanctuary_media_optimization_1.normalizeSanctuaryMediaText)(answer)} `;
+    const titles = [...new Set(current.titles.map(sanctuary_media_optimization_1.normalizeSanctuaryMediaText).filter(Boolean))].sort((left, right) => right.length - left.length);
+    const mentioned = [];
+    for (const title of titles) {
+        const phrase = ` ${title} `;
+        if (!remainder.includes(phrase))
+            continue;
+        mentioned.push(title);
+        remainder = remainder.replaceAll(phrase, " ");
+    }
+    const hasUnverifiedWords = remainder.split(/\s+/u).some((word) => word && !TITLE_LIST_GLUE.has(word));
+    const hasExactCount = expectedCount === null || (titles.length === expectedCount && mentioned.length === expectedCount);
+    if (mentioned.length === 0 || !hasExactCount || hasUnverifiedWords)
+        return "Name exactly the returned catalog titles; do not add or substitute unverified titles.";
+    return undefined;
+}
+function catalogCountGroundingRejection(answer, current) {
+    const formattedCount = new Intl.NumberFormat("en-US").format(current.totalItems);
+    let remainder = ` ${(0, sanctuary_media_optimization_1.normalizeSanctuaryMediaText)(answer)} `;
+    const countPhrase = ` ${(0, sanctuary_media_optimization_1.normalizeSanctuaryMediaText)(formattedCount)} `;
+    const countOccurrences = remainder.split(countPhrase).length - 1;
+    if (countOccurrences === 0)
+        return `Report the current verified shelf count of ${formattedCount}.`;
+    if (countOccurrences !== 1)
+        return "Report the verified shelf count once.";
+    remainder = remainder.replaceAll(countPhrase, " ");
+    if (remainder.split(/\s+/u).some((word) => word && !COUNT_ANSWER_GLUE.has(word)))
+        return "Report only the verified count in ordinary household language.";
+    return undefined;
+}
+function parseCatalogEvidence(result, args) {
+    try {
+        const parsed = JSON.parse(result);
+        if (parsed.ok !== true || !parsed.data || !Number.isSafeInteger(parsed.data.totalItems) || !Number.isSafeInteger(parsed.data.matchedItems) || !Array.isArray(parsed.data.items))
+            return null;
+        const titles = parsed.data.items.flatMap((item) => {
+            if (!item || typeof item !== "object" || Array.isArray(item))
+                return [];
+            const title = item.untrustedTitle;
+            return typeof title === "string" && title.trim() ? [title.trim()] : [];
+        });
+        return {
+            query: (0, sanctuary_media_optimization_1.normalizeSanctuaryMediaText)(args.query ?? ""),
+            totalItems: parsed.data.totalItems,
+            matchedItems: parsed.data.matchedItems,
+            titles,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function sentenceCount(answer) {
+    return answer.split(/[.!?]+(?:\s+|$)/u).filter((part) => part.trim()).length;
+}
+function hasGroundedFirstPersonVisibility(answer, formattedCount) {
+    if (NEGATED_MEDIA_ACCESS.test(answer) || answer.split(formattedCount).length - 1 !== 1)
+        return false;
+    const escapedCount = formattedCount.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+    const mediaNoun = "(?:titles?|movies?|films?|shows?|episodes?|items?)";
+    const countedObject = `(?:all\\s+|about\\s+|around\\s+|exactly\\s+|roughly\\s+)?${escapedCount}\\s+${mediaNoun}\\b`;
+    const contextObject = `(?:it|(?:(?:the|our)\\s+)?(?:full\\s+)?(?:library|shelf))(?:\\s+(?:now|again))?(?=\\s*(?:[.!?;,:—-]|$))`;
+    const accessObject = `(?:${contextObject}|${countedObject})`;
+    const firstPersonAccess = [
+        new RegExp(`\\bi\\s+(?:(?:can\\s+(?:(?:absolutely|clearly|currently|definitely|now|plainly|readily)\\s+)?|(?:currently|now)\\s+)?(?:see|browse|access|view))\\s+${accessObject}`, "iu"),
+        new RegExp(`\\bi(?:\\s+have|[’']ve\\s+got)\\s+(?:(?:full\\s+)?access\\s+to\\s+${accessObject}|${countedObject})`, "iu"),
+        new RegExp(`\\bi(?:\\s+am|[’']m)\\s+(?:(?:currently|now)\\s+)?(?:looking\\s+at|able\\s+to\\s+(?:see|browse|access|view))\\s+${accessObject}`, "iu"),
+        /\b(?:(?:the|our)\s+)?(?:full\s+)?(?:library|shelf)\s+is\s+(?:fully\s+)?(?:visible|accessible)\s+to\s+me\b/iu,
+    ];
+    const groundedCount = new RegExp(`\\b${escapedCount}\\s+${mediaNoun}\\b`, "iu");
+    return firstPersonAccess.some((pattern) => pattern.test(answer)) && groundedCount.test(answer);
+}
+function commonAnswerRejection(answer, technicalDetailRequested) {
+    if (/\b(?:just|only|actually|merely)\s+(?:a\s+)?(?:bot|ai|assistant)\b|\bi\s+(?:can[’']?t|cannot|don[’']?t|do not)\s+(?:actually\s+)?watch\b|\bif i had to pick\b/iu.test(answer)) {
+        return "Answer from the catalog evidence with a confident, personable choice; do not retreat into an AI or 'I cannot watch' disclaimer.";
+    }
+    if (/\b(?:you'?d|you\s+would|you\s+need\s+to|please)\b.*\b(?:check|look at|poke|nudge)\b.*\b(?:log|logs|dashboard|jellyfin|unmanic)\b/iu.test(answer)) {
+        return "Do not send Ari to check Jellyfin, Unmanic, dashboards, or logs for ordinary library visibility while safe catalog tools are available. Use the catalog evidence, or if the catalog read itself fails, say exactly what I could and could not verify.";
+    }
+    if (UNSOLICITED_PIVOT.test(answer))
+        return "Answer the media question that was asked, then stop; do not append an unsolicited question or recommendation pivot.";
+    if (REPORT_LABEL.test(answer))
+        return "Answer conversationally; do not use status-report labels such as version:, house:, render check:, status:, or result:.";
+    if (!technicalDetailRequested && HOUSEHOLD_JARGON.test(answer))
+        return "Use household language such as shelf or library; omit implementation jargon unless technical detail was requested.";
+    return undefined;
+}
+function sanctuaryMediaCatalogRequiredToolCalls(request, advertisedToolNames) {
+    if (!advertisedToolNames.includes("sanctuary_search_media_catalog"))
+        return undefined;
+    const normalized = (0, sanctuary_media_optimization_1.normalizeSanctuaryMediaText)(request);
+    const mentionsMedia = /\b(?:film|films|movie|movies|shows|tv|jellyfin|watch|shelf|stock|catalog|library|lib)\b/u.test(normalized);
+    const asksCatalog = /\b(?:have|got|stock|catalog|library|lib|shelf|jellyfin|favorite|favourite|recommend|suggest|pick|watch|add|see|show|list|browse|access)\b/u.test(normalized);
+    const requestedTitleQuery = requestedTitle(normalized);
+    if ((!mentionsMedia && !requestedTitleQuery) || !asksCatalog)
+        return undefined;
+    const kind = requestKind(normalized, requestedTitleQuery);
+    const asksForAddition = /\b(?:add|missing from|must get)\b/u.test(normalized);
+    const asksForCount = /\b(?:how many|count)\b/u.test(normalized);
+    const listCount = requestedListCount(normalized);
+    const technicalDetailRequested = /\b(?:technical|technically|implementation|endpoint|backend|debug|detail|internals?)\b/u.test(normalized);
+    let latestEvidence;
+    const names = [...REQUIRED_TOOL_NAMES];
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.sanctuary_media_catalog_obligation",
+        message: "media catalog intent requires safe restricted catalog evidence",
+        meta: { requiredToolNames: names },
+    });
+    return {
+        names,
+        requireSuccessfulResults: true,
+        retryMessage: asksForCount
+            ? "Use sanctuary_search_media_catalog before answering, then report only the current shelf count in ordinary household language."
+            : kind === "visibility"
+                ? "Use sanctuary_search_media_catalog before answering. Lead with the direct answer from current catalog evidence, report the shelf count in ordinary household language, and stop without sampled titles or a follow-up question."
+                : kind === "title_lookup"
+                    ? "Use sanctuary_search_media_catalog with the requested title before answering. Confirm its presence or absence directly from current catalog evidence."
+                    : kind === "taste_recommendation"
+                        ? "Use sanctuary_search_media_catalog before answering. Make one concise, decisive choice grounded in returned catalog evidence; do not volunteer an AI or 'I cannot watch' disclaimer."
+                        : listCount
+                            ? `Use sanctuary_search_media_catalog with limit ${listCount} before answering, then name exactly the returned catalog titles.`
+                            : "Use sanctuary_search_media_catalog before answering and base any named titles on the returned catalog evidence.",
+        validateRequiredToolResult(name, result, args) {
+            if (name !== "sanctuary_search_media_catalog")
+                return false;
+            const current = parseCatalogEvidence(result, args);
+            if (!current)
+                return false;
+            latestEvidence = current;
+            return true;
+        },
+        validateToolCallBeforeDispatch(name, args) {
+            if (name !== "sanctuary_search_media_catalog")
+                return undefined;
+            const query = (0, sanctuary_media_optimization_1.normalizeSanctuaryMediaText)(args.query ?? "");
+            if (kind === "title_lookup" && !query)
+                return "Search for the requested title by name before answering whether it is on the shelf.";
+            if (kind === "title_lookup" && query !== requestedTitleQuery)
+                return `Search for the requested title ${requestedTitleQuery} before answering whether it is on the shelf.`;
+            if (asksForAddition && !query)
+                return "Search for one candidate title by name before recommending it as an addition.";
+            if (listCount && Number(args.limit) !== listCount)
+                return `Set the catalog limit to ${listCount} so the answer is grounded in exactly the requested number of titles.`;
+            return undefined;
+        },
+        validateTerminalAnswer(answer) {
+            const commonRejection = commonAnswerRejection(answer, technicalDetailRequested);
+            if (commonRejection)
+                return commonRejection;
+            const latest = latestEvidence;
+            if (asksForCount && latest)
+                return catalogCountGroundingRejection(answer, latest);
+            if (kind === "visibility") {
+                if (answer.length > 240 || answer.includes("\n") || sentenceCount(answer) > 2)
+                    return "Answer library visibility in no more than two short sentences and 240 characters.";
+                if (!/^yes\b/iu.test(answer.trim()))
+                    return "Lead with a direct yes when the current catalog read succeeds.";
+                if (latest) {
+                    const formattedCount = new Intl.NumberFormat("en-US").format(latest.totalItems);
+                    if (!hasGroundedFirstPersonVisibility(answer, formattedCount))
+                        return `Reply in one or two sentences. A valid shape is: Yes—I can see the library now. It contains ${formattedCount} titles.`;
+                }
+                if (/\b(?:titles? like|such as|including)\b/iu.test(answer))
+                    return "Do not sample titles for a visibility question; answer whether the shelf is visible and give the current count.";
+                if ([...answer.matchAll(/\byes\b/giu)].length > 1)
+                    return "Give one answer once; do not repeat the yes or restate the response.";
+                if (answer.includes("?"))
+                    return "Answer the visibility question and stop without asking a new question.";
+            }
+            if (kind === "title_lookup" && latest?.query) {
+                const exactMatch = latest.titles.some((title) => (0, sanctuary_media_optimization_1.normalizeSanctuaryMediaText)(title) === requestedTitleQuery);
+                const expectedLead = exactMatch ? /^yes\b/iu : /^no\b/iu;
+                if (!expectedLead.test(answer.trim()))
+                    return `Lead with ${exactMatch ? "yes" : "no"} based on the current title search.`;
+                if (!includesNormalizedPhrase(answer, requestedTitleQuery))
+                    return "Name the requested title in the direct answer.";
+            }
+            if (kind === "taste_recommendation" && latest) {
+                if (asksForAddition) {
+                    if (!latest.query || latest.matchedItems !== 0 || !includesNormalizedPhrase(answer, latest.query))
+                        return "Recommend an addition only after an exact current catalog search shows that candidate is absent.";
+                    if (/\b(?:i|we)\s+(?:added|requested|submitted|queued)\b/iu.test(answer))
+                        return "Do not claim the title was added or requested when no media-request action was available.";
+                }
+                else if (!latest.titles.some((title) => includesNormalizedPhrase(answer, title))) {
+                    return "Make the choice from a title returned by the current catalog evidence.";
+                }
+            }
+            if (kind === "other" && latest)
+                return catalogTitleGroundingRejection(answer, latest, listCount);
+            return undefined;
+        },
+    };
+}