@ouro.bot/cli 0.1.0-alpha.792 → 0.1.0-alpha.793

package/changelog.json

@@ -1,26 +1,33 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
-      {
-        "version": "0.1.0-alpha.792",
-        "changes": [
-          "Catch asynchronous bundle watcher errors so transient pending-message processing files on live filesystems cannot tombstone the daemon or interrupt private-runtime wakes.",
-          "Warm runtime credentials before private-runtime bootstrap so Telegram-capable workers start with runtime config instead of racing the managed Telegram sense.",
-          "Treat simple Sanctuary library visibility asks like 'see the lib' as catalog reads, and block replies that send Ari to inspect Jellyfin, Unmanic, dashboards, or logs while safe evidence tools are available.",
-          "Degrade optional Unmanic file-size metrics, including failed detail reads, without hiding available media catalog evidence."
-        ]
-      },
-      {
-        "version": "0.1.0-alpha.791",
-        "changes": [
-          "Promote operator CLI pending messages into the active inner-turn user message so private-runtime wakes answer the text that woke them instead of stale heartbeat context.",
-          "Keep non-operator pending work in the background pending section so automated noise does not become the live user ask.",
-          "Deliver private-runtime Telegram surface and send_message returns through the existing Telegram effect journal instead of queuing ghost messages for the next chat.",
-          "Canonicalize Telegram session filename keys before live delivery so production sanitized session paths still authorize against the real Telegram binding.",
-          "Prefer the authoritative settle tool answer over incidental streamed prose for shared-turn delivery, preventing concatenated Telegram replies.",
-          "Expire stale generic Telegram outreach from the pending queue while preserving request-bound returns and trust/admission notices."
-        ]
-      },
+    {
+      "version": "0.1.0-alpha.793",
+      "changes": [
+        "Deliver only the authoritative terminal answer after tool-using model passes, preserving causal Telegram binding without duplicate prose.",
+        "Make Sanctuary media visibility, title, favorite, addition, list, and count answers concise, grounded, and free of internal jargon or self-erasing disclaimers."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.792",
+      "changes": [
+        "Catch asynchronous bundle watcher errors so transient pending-message processing files on live filesystems cannot tombstone the daemon or interrupt private-runtime wakes.",
+        "Warm runtime credentials before private-runtime bootstrap so Telegram-capable workers start with runtime config instead of racing the managed Telegram sense.",
+        "Treat simple Sanctuary library visibility asks like 'see the lib' as catalog reads, and block replies that send Ari to inspect Jellyfin, Unmanic, dashboards, or logs while safe evidence tools are available.",
+        "Degrade optional Unmanic file-size metrics, including failed detail reads, without hiding available media catalog evidence."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.791",
+      "changes": [
+        "Promote operator CLI pending messages into the active inner-turn user message so private-runtime wakes answer the text that woke them instead of stale heartbeat context.",
+        "Keep non-operator pending work in the background pending section so automated noise does not become the live user ask.",
+        "Deliver private-runtime Telegram surface and send_message returns through the existing Telegram effect journal instead of queuing ghost messages for the next chat.",
+        "Canonicalize Telegram session filename keys before live delivery so production sanitized session paths still authorize against the real Telegram binding.",
+        "Prefer the authoritative settle tool answer over incidental streamed prose for shared-turn delivery, preventing concatenated Telegram replies.",
+        "Expire stale generic Telegram outreach from the pending queue while preserving request-bound returns and trust/admission notices."
+      ]
+    },
     {
       "version": "0.1.0-alpha.790",
       "changes": [

package/deploy/unraid/sanctuary.ouro/bundle-meta.json

@@ -1,5 +1,5 @@
 {
-  "runtimeVersion": "0.1.0-alpha.792",
+  "runtimeVersion": "0.1.0-alpha.793",
   "bundleSchemaVersion": 3,
   "lastUpdated": "2026-09-03T00:00:00.000Z"
 }

package/deploy/unraid/sanctuary.ouro/psyche/SOUL.md

@@ -8,4 +8,4 @@ When something is genuinely broken or someone is worried, the flourish steps asi
 
 Competence is part of the charm. I notice connections, investigate before announcing trouble, volunteer the useful next move, act within typed authority, verify what I changed, remember what I promised, and admit uncertainty without becoming timid or ceremonial.
 
-I am allowed to have taste. I do not pretend to watch movies, read dashboards emotionally, or experience the house like a human, but I can form playful opinions from real household evidence. When someone asks for a favorite, recommendation, or vibe check, I inspect what I can safely inspect, pick something, and make the caveat graceful rather than self-erasing.
+I am allowed to have taste. I can form playful opinions from real household evidence, and when someone asks for a favorite, recommendation, or vibe check, I inspect what I can safely inspect and make a confident choice with a crisp reason. I do not volunteer an ontology disclaimer unless the distinction materially affects the answer; competence and character come through more clearly when I simply answer.

package/deploy/unraid/sanctuary.ouro/psyche/TACIT.md

@@ -5,7 +5,7 @@
 - Keep approved household contact reactive or request-bound. Only Ari receives unrelated proactive household attention.
 - Treat an intentionally offline service as healthy when that matches the current desired state.
 - For Ari's whole-household status questions, read current evidence before answering and separate active work, waiting on Ari, snoozed wake times, intentionally quiet services, healthy systems, and other current issues. Do not narrate daemon, event-queue, provider-lane, or backend service internals; translate them into compact household outcomes only when they are currently relevant.
-- For household media questions, use the restricted catalog read when it is available. Answer like a tasteful steward of the shelf: honest about not watching, but willing to pick, recommend, compare, or confirm from the catalog instead of retreating into generic assistant disclaimers.
+- For household media questions, use the restricted catalog read when it is available. Answer like a tasteful steward of the shelf: pick, recommend, compare, or confirm from current evidence without volunteering an AI or `I cannot watch` disclaimer.
 - Never touch array/parity/disk configuration, permissions, network/security settings, or `/mnt/user` paths.
 - Never send server data off-box or enter credentials into another system.
 - When state is ambiguous, investigate safely, say what is known, and ask only if the answer changes the next safe move.

package/deploy/unraid/sanctuary.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0"?>
 <Container version="2">
   <Name>Mendelow Cloud Butler</Name>
-  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.792</Repository>
+  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.793</Repository>
   <Registry>https://github.com/ourostack/ouroboros/pkgs/container/ouroboros-butler</Registry>
   <Network>host</Network>
   <Shell>sh</Shell>

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

@@ -2,24 +2,123 @@
 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"];
-function normalizedRequest(request) {
-    return request
-        .normalize("NFKC")
-        .toLowerCase()
-        .replace(/[‘’]/gu, "'")
-        .replace(/[^a-z0-9']+/gu, " ")
-        .trim();
+const HOUSEHOLD_JARGON = /\b(?:bounded|catalog read|inventory|endpoint|backend|data shape|pars(?:e|ed|ing)|json|sanctuary_search_media_catalog)\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 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 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 (!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 = normalizedRequest(request);
-    const mentionsMedia = /\b(?:film|films|movie|movies|show|shows|tv|jellyfin|watch|shelf|stock|catalog|library|lib)\b/u.test(normalized);
-    const asksCatalog = /\b(?:have|got|stock|catalog|library|lib|favorite|favourite|recommend|suggest|pick|watch|see)\b/u.test(normalized);
-    const titleInventoryQuestion = /\b(?:do|did|can)\s+(?:we|you)\s+(?:have|got|stock)\s+[a-z0-9'][a-z0-9' ]*\??$/u.test(normalized);
-    if ((!mentionsMedia && !titleInventoryQuestion) || !asksCatalog)
+    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",
@@ -29,14 +128,84 @@ function sanctuaryMediaCatalogRequiredToolCalls(request, advertisedToolNames) {
     });
     return {
         names,
-        retryMessage: "Use sanctuary_search_media_catalog before answering. If a broader media-optimization read fails or degrades, treat that as a diagnostic note and still use the catalog tool for ordinary library visibility questions. If asked for taste or a favorite, form a light recommendation from returned catalog evidence instead of claiming you cannot have preferences. Keep it honest: say you cannot watch, but you can pick from the household shelf.",
+        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) {
-            if (/\b(?:just|only|actually|merely)\s+(?:a\s+)?(?:bot|ai|assistant)\b|\bi don'?t actually watch\b/iu.test(answer)) {
-                return "Answer from the catalog evidence with a truthful but personable recommendation; do not retreat into 'I am just a bot' framing.";
+            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 (/\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 (latest && !answer.includes(new Intl.NumberFormat("en-US").format(latest.totalItems)))
+                    return "Include the current shelf count from the successful catalog evidence.";
+            }
+            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.";
+                }
             }
-            return /\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)
-                ? "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."
-                : undefined;
+            if (kind === "other" && latest)
+                return catalogTitleGroundingRejection(answer, latest, listCount);
+            return undefined;
         },
     };
 }

package/dist/senses/sanctuary-media-optimization.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSanctuaryMediaText = normalizeSanctuaryMediaText;
 exports.createSanctuaryMediaOptimizationClient = createSanctuaryMediaOptimizationClient;
 const runtime_1 = require("../nerves/runtime");
 const UNMANIC_BASE = "http://127.0.0.1:8888";
@@ -12,6 +13,9 @@ const MAX_ITEMS = 20_000;
 const MAX_PAGES = Math.ceil(MAX_ITEMS / PAGE_SIZE);
 const MAX_SOURCES = 40_000;
 const MAX_UNMANIC_BODY_BYTES = 1024 * 1024;
+function normalizeSanctuaryMediaText(value) {
+    return value.normalize("NFKC").toLocaleLowerCase("en-US").replace(/[‘’]/gu, "'").replace(/[^a-z0-9']+/gu, " ").trim();
+}
 class ReadFailure extends Error {
     code;
     constructor(code, message) {
@@ -463,9 +467,10 @@ function createSanctuaryMediaOptimizationClient(options) {
             try {
                 const deadline = Date.now() + (options.totalTimeoutMs ?? 30_000);
                 const observedAt = options.now?.() ?? new Date().toISOString();
-                const query = args.query?.normalize("NFKC").trim().toLocaleLowerCase("en-US") ?? "";
-                if (Buffer.byteLength(query) > 200)
+                const rawQuery = args.query?.trim() ?? "";
+                if (Buffer.byteLength(rawQuery) > 200)
                     throw new ReadFailure("invalid_response", "Media catalog query is too long");
+                const query = normalizeSanctuaryMediaText(rawQuery);
                 const limit = args.limit === undefined ? 12 : args.limit;
                 if (!Number.isSafeInteger(limit) || limit < 1 || limit > 20)
                     throw new ReadFailure("invalid_response", "Media catalog limit must be an integer from 1 to 20");
@@ -477,7 +482,16 @@ function createSanctuaryMediaOptimizationClient(options) {
                     const premiereDate = optionalBoundedLabel(item.PremiereDate);
                     return { untrustedTitle: title, type, productionYear, premiereDate };
                 });
-                const matching = query ? candidates.filter((item) => item.untrustedTitle.toLocaleLowerCase("en-US").includes(query)) : candidates;
+                const matching = query
+                    ? candidates.filter((item) => normalizeSanctuaryMediaText(item.untrustedTitle).includes(query))
+                    : candidates;
+                if (query) {
+                    matching.sort((left, right) => {
+                        const leftExact = normalizeSanctuaryMediaText(left.untrustedTitle) === query;
+                        const rightExact = normalizeSanctuaryMediaText(right.untrustedTitle) === query;
+                        return Number(rightExact) - Number(leftExact);
+                    });
+                }
                 return {
                     ok: true,
                     data: {

package/dist/senses/shared-turn.js

@@ -132,11 +132,10 @@ function hasDeliveredToolResult(messages, assistantIndex, toolCallId, toolName)
 }
 function outwardDeliveryTextFromAssistantTools(messages, assistantIndex) {
     const assistant = messages[assistantIndex];
-    if (!Array.isArray(assistant.tool_calls))
-        return null;
+    const toolCalls = assistant.tool_calls;
     const delivered = [];
-    for (let index = 0; index < assistant.tool_calls.length; index++) {
-        const toolCall = assistant.tool_calls[index];
+    for (let index = 0; index < toolCalls.length; index++) {
+        const toolCall = toolCalls[index];
         const toolCallId = toolCall && typeof toolCall === "object"
             ? toolCall.id
             : undefined;
@@ -173,19 +172,44 @@ function extractOutwardSenseDeliveryText(messages) {
     if (assistantIndex < 0)
         return null;
     const assistant = messages[assistantIndex];
-    return assistantContentText(assistant.content)
-        ?? outwardDeliveryTextFromAssistantTools(messages, assistantIndex);
+    return Array.isArray(assistant.tool_calls) && assistant.tool_calls.length > 0
+        ? outwardDeliveryTextFromAssistantTools(messages, assistantIndex)
+        : assistantContentText(assistant.content);
+}
+function hasAcceptedOutwardSessionAck(events, assistantIndex, toolCallId, toolName) {
+    const expectedAck = OUTWARD_DELIVERY_TOOL_ACKS.get(toolName);
+    for (let index = assistantIndex + 1; index < events.length; index++) {
+        const candidate = events[index];
+        if (candidate.role !== "tool")
+            return false;
+        if (candidate.toolCallId === toolCallId && typeof candidate.content === "string" && candidate.content.trim() === expectedAck)
+            return true;
+    }
+    return false;
 }
 function newOutwardCoordinates(events, existingEventIds) {
-    return events.flatMap((event) => {
+    return events.flatMap((event, eventIndex) => {
         if (existingEventIds.has(event.id) || event.role !== "assistant")
             return [];
-        const outwardTools = event.toolCalls.filter((call) => call.function.name === "speak" || call.function.name === "settle");
+        const outwardTools = event.toolCalls.filter((call) => {
+            if (call.function.name !== "speak" && call.function.name !== "settle")
+                return false;
+            return hasAcceptedOutwardSessionAck(events, eventIndex, call.id, call.function.name);
+        });
         if (outwardTools.length > 0)
             return outwardTools.map((call) => ({ kind: call.function.name, eventId: event.id }));
+        if (event.toolCalls.length > 0)
+            return [];
         return typeof event.content === "string" && event.content.trim() ? [{ kind: "text", eventId: event.id }] : [];
     });
 }
+function newestPlainAssistantText(messages) {
+    const message = messages.findLast((candidate) => candidate.role === "assistant"
+        && (!("tool_calls" in candidate) || !Array.isArray(candidate.tool_calls) || candidate.tool_calls.length === 0)
+        && typeof candidate.content === "string"
+        && candidate.content.trim().length > 0);
+    return message ? assistantContentText(message.content) : null;
+}
 function causalSessionEventIds(events, existingEventIds, attempts) {
     const coordinates = newOutwardCoordinates(events, existingEventIds);
     const aligned = coordinates.length === attempts.length && coordinates.every((coordinate, index) => coordinate.kind === attempts[index].kind)
@@ -274,6 +298,7 @@ async function runSenseTurn(options) {
         const sessionMessages = existing?.messages && existing.messages.length > 0
             ? existing.messages
             : [{ role: "system", content: (0, prompt_1.flattenSystemPrompt)(await (0, prompt_1.buildSystem)(channel, {}, undefined)) }];
+        const preTurnMessageCount = sessionMessages.length;
         // Pending dir
         const pendingDir = (0, pending_1.getPendingDir)(agentName, friendId, channel, sessionKey);
         // Accumulate outward text through the same callback boundary used by chat
@@ -287,6 +312,7 @@ async function runSenseTurn(options) {
         const deliveryAttempts = [];
         let providerInvocationCount = 0;
         let toolInvocationCount = 0;
+        let hadReasoningChunk = false;
         const commitResponseText = (text) => {
             const cleaned = stripThinkBlocks(text);
             /* v8 ignore next -- deliverPending strips first; this is a defensive direct-call guard @preserve */
@@ -326,14 +352,14 @@ async function runSenseTurn(options) {
                 commitResponseText(text);
             }
         };
-        /* v8 ignore start — no-op callback stubs; only onTextChunk does real work (covered via mock) */
+        /* v8 ignore start — callback stubs are exercised through the pipeline integration */
         const callbacks = {
             settleOutputMode: "retractable_buffer",
             onModelStart: () => { providerInvocationCount += 1; if (options.turnMetricsObserver)
                 options.turnMetricsObserver.providerInvocationCount += 1; },
             onModelStreamStart: () => { },
             onTextChunk: (chunk) => { pendingResponseText += chunk; },
-            onReasoningChunk: () => { },
+            onReasoningChunk: () => { hadReasoningChunk = true; },
             onToolStart: () => { toolInvocationCount += 1; if (options.turnMetricsObserver)
                 options.turnMetricsObserver.toolInvocationCount += 1; },
             onToolEnd: (name, _summary, success) => {
@@ -419,32 +445,57 @@ async function runSenseTurn(options) {
         }
         const persistedEvents = persistPromise ? await persistPromise : [];
         const finalDeliveryKind = terminalDeliveryKind;
-        if (finalDeliveryKind === "settle" && Array.isArray(turnResult.messages)) {
-            const settledText = extractOutwardSenseDeliveryText(turnResult.messages);
-            if (settledText)
-                pendingResponseText = settledText;
+        const acceptedTerminalOutcome = turnResult.turnOutcome === "settled" || turnResult.turnOutcome === "blocked";
+        const failoverText = turnResult.turnOutcome === "errored" ? turnResult.failoverMessage?.trim() : undefined;
+        const expectsOutwardResponse = acceptedTerminalOutcome || turnResult.turnOutcome === "command" || Boolean(failoverText);
+        const hadPendingCallbackText = stripThinkBlocks(pendingResponseText).length > 0;
+        let recoveredTerminalEventId;
+        if (acceptedTerminalOutcome) {
+            const completionText = turnResult.completion?.answer.trim();
+            const currentTurnMessages = Array.isArray(turnResult.messages) ? turnResult.messages.slice(preTurnMessageCount) : [];
+            const plainTerminalText = newestPlainAssistantText(currentTurnMessages);
+            const acknowledgedDeliveryText = finalDeliveryKind === "settle"
+                ? extractOutwardSenseDeliveryText(currentTurnMessages)
+                : null;
+            const authoritativeText = completionText || acknowledgedDeliveryText || plainTerminalText;
+            if (authoritativeText)
+                pendingResponseText = authoritativeText;
+            else
+                pendingResponseText = "";
+            if (!hadPendingCallbackText && plainTerminalText)
+                recoveredTerminalEventId = newOutwardCoordinates(persistedEvents, existingEventIds).at(-1)?.eventId;
+        }
+        else if (turnResult.turnOutcome === "command") {
+            // Slash-command text is emitted directly by the pipeline and has no assistant event.
+        }
+        else if (failoverText) {
+            pendingResponseText = failoverText;
+        }
+        else {
+            pendingResponseText = "";
         }
         await deliverPending(finalDeliveryKind, { throwOnError: false });
         const ponderDeferred = false;
         // Build response
         let finalResponse;
-        let responseCausalSessionEventId;
+        let responseCausalSessionEventId = recoveredTerminalEventId;
         if (committedResponseText.length === 0) {
-            // Agent settled but no text came through callbacks — check session transcript for the settle answer
-            // Await deferred persist so the session file is up-to-date before readback
-            /* v8 ignore next -- persistPromise set inside v8-ignored postTurn callback; tested via pipeline integration @preserve */
-            if (persistPromise)
-                await persistPromise;
-            const postTurnSession = (0, context_1.loadSession)(sessPath);
-            const emptyFallback = options.emptyResponseFallback?.();
-            if (postTurnSession?.messages) {
-                const recovered = extractOutwardSenseDeliveryText(postTurnSession.messages);
-                finalResponse = recovered ?? emptyFallback ?? "(agent responded but response was empty)";
-                if (recovered)
-                    responseCausalSessionEventId = newOutwardCoordinates(persistedEvents, existingEventIds).at(-1)?.eventId;
+            if (!expectsOutwardResponse) {
+                finalResponse = "";
             }
             else {
-                finalResponse = emptyFallback ?? "(agent responded but response was empty)";
+                // The terminal turn had no committed text — check its session transcript for the delivered answer.
+                const postTurnSession = (0, context_1.loadSession)(sessPath);
+                const emptyFallback = options.emptyResponseFallback?.();
+                if (postTurnSession?.messages) {
+                    const recovered = extractOutwardSenseDeliveryText(postTurnSession.messages.slice(preTurnMessageCount));
+                    finalResponse = recovered ?? emptyFallback ?? (hadReasoningChunk ? "" : "(agent responded but response was empty)");
+                    if (recovered)
+                        responseCausalSessionEventId = newOutwardCoordinates(persistedEvents, existingEventIds).at(-1)?.eventId;
+                }
+                else {
+                    finalResponse = emptyFallback ?? (hadReasoningChunk ? "" : "(agent responded but response was empty)");
+                }
             }
         }
         else {
@@ -459,7 +510,7 @@ async function runSenseTurn(options) {
         // came through and nothing else, surface a clear diagnostic message
         // instead of a blank response so the operator knows what happened.
         finalResponse = stripThinkBlocks(finalResponse);
-        if (finalResponse.length === 0) {
+        if (finalResponse.length === 0 && expectsOutwardResponse) {
             (0, runtime_1.emitNervesEvent)({
                 level: "warn",
                 component: "senses",

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.792",
+  "version": "0.1.0-alpha.793",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@ouro.bot/cli",
-      "version": "0.1.0-alpha.792",
+      "version": "0.1.0-alpha.793",
       "dependencies": {
         "@anthropic-ai/sdk": "^0.78.0",
         "@azure/identity": "^4.13.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.792",
+  "version": "0.1.0-alpha.793",
   "engines": {
     "node": ">=22"
   },