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

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

@@ -2,24 +2,132 @@
 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|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)\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 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 groundedCollection = new RegExp(`\\b(?:i\\s+can\\s+(?:(?:absolutely|clearly|currently|definitely|now|plainly|readily)\\s+)?(?:see|browse|access|view)|i\\s+(?:(?:currently|now)\\s+)?(?:see|browse|access|view)|i[’']m\\s+(?:(?:currently|now)\\s+)?looking\\s+at|i(?:\\s+have|[’']ve\\s+got)(?:\\s+access\\s+to)?)\\s+(?:all\\s+|about\\s+|around\\s+|exactly\\s+|roughly\\s+)?${escapedCount}\\s+(?:titles?|movies?|films?|shows?|episodes?)(?:\\s+(?:on\\s+the\\s+shelf|in\\s+the\\s+library))?\\b`, "iu");
+    return answer.split(/[.!?]+(?:\s+|$)/u).some((sentence) => (sentence.includes(formattedCount)
+        && groundedCollection.test(sentence)));
+}
+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 +137,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 (latest && !hasGroundedFirstPersonVisibility(answer, new Intl.NumberFormat("en-US").format(latest.totalItems)))
+                    return "Answer in your own voice: say what you can see or access on the household shelf or in the library.";
+                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.";
+                }
             }
-            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,25 +172,75 @@ 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 newOutwardCoordinates(events, existingEventIds) {
-    return events.flatMap((event) => {
-        if (existingEventIds.has(event.id) || event.role !== "assistant")
+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, afterEventId) {
+    const boundaryIndex = events.findIndex((event) => event.id === afterEventId);
+    if (boundaryIndex < 0)
+        return [];
+    return events.flatMap((event, eventIndex) => {
+        if (eventIndex <= boundaryIndex || existingEventIds.has(event.id) || event.role !== "assistant" || event.provenance?.captureKind === "synthetic")
             return [];
-        const outwardTools = event.toolCalls.filter((call) => call.function.name === "speak" || call.function.name === "settle");
+        const outwardTools = event.toolCalls.flatMap((call) => {
+            if (call.function.name !== "speak" && call.function.name !== "settle")
+                return [];
+            if (!hasAcceptedOutwardSessionAck(events, eventIndex, call.id, call.function.name))
+                return [];
+            const text = stripThinkBlocks(parseToolStringArg(call, call.function.name, call.function.name === "speak" ? "message" : "answer") ?? "");
+            return text ? [{ kind: call.function.name, eventId: event.id, text }] : [];
+        });
         if (outwardTools.length > 0)
-            return outwardTools.map((call) => ({ kind: call.function.name, eventId: event.id }));
-        return typeof event.content === "string" && event.content.trim() ? [{ kind: "text", eventId: event.id }] : [];
+            return outwardTools;
+        if (event.toolCalls.length > 0)
+            return [];
+        const text = stripThinkBlocks(typeof event.content === "string" ? event.content : "");
+        return text ? [{ kind: "text", eventId: event.id, text }] : [];
     });
 }
-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)
-        ? coordinates.map((coordinate) => coordinate.eventId)
-        : attempts.map(() => null);
-    return attempts.flatMap((attempt, index) => attempt.delivered ? [aligned[index] ?? null] : []);
+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, afterEventId) {
+    if (!afterEventId)
+        return attempts.flatMap((attempt) => attempt.delivered ? [null] : []);
+    const coordinates = newOutwardCoordinates(events, existingEventIds, afterEventId);
+    let nextCoordinate = 0;
+    return attempts.flatMap((attempt) => {
+        if (!attempt.delivered)
+            return [];
+        const coordinateIndex = coordinates.findIndex((coordinate, index) => index >= nextCoordinate && coordinate.kind === attempt.kind && coordinate.text === attempt.text);
+        if (coordinateIndex < 0)
+            return [null];
+        nextCoordinate = coordinateIndex + 1;
+        return [coordinates[coordinateIndex].eventId];
+    });
+}
+function currentIngressEventId(events, existingEventIds, userMessage, precommittedIngress, ingressRelations) {
+    if (precommittedIngress)
+        return precommittedIngress.eventId;
+    const reference = ingressRelations?.references[0];
+    return events.findLast((event) => (!existingEventIds.has(event.id)
+        && event.role === "user"
+        && event.content === userMessage
+        && event.provenance?.captureKind !== "synthetic"
+        && (!reference || event.relations?.references.includes(reference))))?.id;
 }
 function getSenseSessionPath(agentName, friendId, channel, sessionKey, agentRootOverride) {
     return path.join(agentRootOverride ?? (0, identity_1.getAgentRoot)(agentName), "state", "sessions", friendId, channel, `${(0, config_1.sanitizeKey)(sessionKey)}.json`);
@@ -274,6 +323,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 +337,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 */
@@ -303,7 +354,7 @@ async function runSenseTurn(options) {
             if (!text)
                 return;
             const delivery = { kind, text };
-            const attempt = { kind, delivered: false };
+            const attempt = { kind, text, delivered: false };
             deliveryAttempts.push(attempt);
             try {
                 await options.deliverySink?.onDelivery(delivery);
@@ -326,14 +377,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) => {
@@ -418,33 +469,59 @@ async function runSenseTurn(options) {
             };
         }
         const persistedEvents = persistPromise ? await persistPromise : [];
+        const ingressEventId = currentIngressEventId(persistedEvents, existingEventIds, userMessage, options.precommittedIngress, options.ingressRelations);
         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 = causalSessionEventIds(persistedEvents, existingEventIds, [{ kind: "text", text: stripThinkBlocks(plainTerminalText), delivered: true }], ingressEventId)[0] ?? undefined;
+        }
+        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 = causalSessionEventIds(persistedEvents, existingEventIds, [{ kind: finalDeliveryKind, text: stripThinkBlocks(recovered), delivered: true }], ingressEventId)[0] ?? undefined;
+                }
+                else {
+                    finalResponse = emptyFallback ?? (hadReasoningChunk ? "" : "(agent responded but response was empty)");
+                }
             }
         }
         else {
@@ -459,7 +536,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",
@@ -487,7 +564,7 @@ async function runSenseTurn(options) {
             providerInvocationCount,
             toolInvocationCount,
             sessionPath: sessPath,
-            ...(deliveries.length > 0 ? { causalSessionEventIds: causalSessionEventIds(persistedEvents, existingEventIds, deliveryAttempts) } : {}),
+            ...(deliveries.length > 0 ? { causalSessionEventIds: causalSessionEventIds(persistedEvents, existingEventIds, deliveryAttempts, ingressEventId) } : {}),
             ...(responseCausalSessionEventId ? { responseCausalSessionEventId } : {}),
         };
     });

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.792",
+  "version": "0.1.0-alpha.794",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@ouro.bot/cli",
-      "version": "0.1.0-alpha.792",
+      "version": "0.1.0-alpha.794",
       "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.794",
   "engines": {
     "node": ">=22"
   },